The age of Yawin (Work in progress)

[Yawin]

Buen, mientras mi juego "Marcianitos" está en fase de testeos varios, e comenzado un proyecto de estrategia en tiempo real (como ya sabréis algunos).

La idea del proyecto es:

• Hacer un juego multijugador (empleando Bennuplaynet) en el que se enfrenten hasta 8 jugadores en un mapa de 6000x6000 (igual cambio el tamaño).
  


• Que durante el juego puedan crear unidades de tres tipos: guerreras, constructoras y de transporte.
  
• Que para crearlas, tengan que construir edificios inmóviles.
  


• Que tengan que cojer recursos.


• Que se puedan atacar entre ellos.


• Que te puedas desplazar por el scroll con el raton, y al marcar un punto en el mapa marque las coordenadas del scroll, no de la pantalla.

Problemas que tengo:

• Desarrollar un mapa de tiles que me permita hacer campos de batalla de un tamaño aceptable.


• Que la cola de producción se inicie sin tener que seleccionar el edificio.


• Si asigno al puntero la capacidad de desplazar el scroll y le pongo el ctype necesario para ir por el scroll, como coje las coordenadas del mouse, nunca se mueve del mismo cuadrado (0,0) (640,480). Pero si le asigno el ctype para que se mueva por la pantalla, las coordenadas que da todo el rato están entre (0,0) y (640,480), y por tanto las naves sólo se desplazan por ahi.


• El eterno problema de obtener la facción de la nave a la que he hecho click derecho.[url]

Ahora mismo, he estado codificando la cola de producción. Tiene dos cachos. Por un lado, he declarado la estructura Colt en las globales:

Code Select Expand

global
int fpgs[3]; // Gráficos
puntero ppunt; // ID del Puntero
int puni[2]; //ID de las unidades

////Estructura de la cola de producción////////////////////////////////////////////////////////
struct colt
bool oc; // Marca si esa casilla de la cola está ocupada o libre;
int xp; // X donde aparecerá el producto;
int yp; // Y donde aparecerá el producto;
int tmpP; // Tiempo que tarda el producto en producirse;
end
///////////////////////////////////////////////////////////////////////////////////////////////
end

Y por otro lado tengo la cola de producción:

Code Select Expand

process cola(lim)
public
colt produccion[lim];
end
private
int i;
colt prodaux;
end
begin
for(i=0; i<lim;i++)
produccion[i].oc=false;
end
loop
if(produccion[0].oc!=false)
prodaux=producto[0];
for(i=0;i<lim;i++)
if(producto[i+1].oc!=false)
producto[i]=producto[i+1];
end
end
produto[lim-1].oc=false;
for(i=0;i>prodaux.tmp;i++)
frame;
end
// Llamamos al gestor de llamadas;
end
frame;
end
end

No he podido probarlo, pero ¿veis algo que pueda hacer que no funcione o que no haga lo que quiero?

[Noivern]

Gran proyecto, perseverancia++!!

[Yawin]

Gracias por los ánimos. A ver si consigo dejar de tener errores chungos que no se resolver... xD

[DCelso]

Salvo  por los errores tipográficos, como los dos for que no se ven bien y el campo tmpP que no llamaste igual en el if, la lógica del código se ve correcta para lo que quieres realizar.

[Yawin]

Muchas gracias por el apoyo DCelso.
Ni que decir tiene que aparecerás en los créditos xD
______________________________________________________________________________

Al final, la cola de producción se ha quedado así:

Code Select Expand

process cola(lim)
public
////Estructura de la cola de producción////////////////////////////////////////////////////////
struct producto[10]
bool oc; // Marca si esa casilla de la cola está ocupada o libre;
int xp; // X donde aparecerá el producto;
int yp; // Y donde aparecerá el producto;
int tmpP; // Tiempo que tarda el producto en producirse;
int prod; //Producto a producir;
int tipo; //Tipo de producto a producir;
end
///////////////////////////////////////////////////////////////////////////////////////////////
end
private
int i;
struct prodaux
int xp; // X donde aparecerá el producto;
int yp; // Y donde aparecerá el producto;
int tmpP; // Tiempo que tarda el producto en producirse;
int prod; //Producto a producir;
int tipo; //Tipo de producto a producir;
end
end
begin
for(i=0;i < lim ; i + + )
producto[i].oc=false;
end
loop
if(producto[0].oc!=false)
prodaux.xp=producto[0].xp;
prodaux.yp=producto[0].yp;
prodaux.tmpP=producto[0].tmpP;
prodaux.prod=producto[0].prod;
prodaux.tipo=producto[0].tipo;
for(i=0;i < lim;i++)
if(producto[i+1].oc!=false)
producto[i].oc=producto[i+1].oc;
producto[i].xp=producto[i+1].xp;
producto[i].yp=producto[i+1].yp;
producto[i].tmpP=producto[i+1].tmpP;
producto[i].prod=producto[i+1].prod;
producto[i].tipo=producto[i+1].tipo;
else
producto[i].oc=false;
end
end
producto[lim-1].oc=false;
write_var(0,320,270,3,i);
for(i=0;i<prodaux.tmpP;i++)
frame;
end
gestorllamadas(prodaux.tipo,prodaux.prod,prodaux.xp,prodaux.yp,0,faction_jug);
end
frame;
end
end


Además, he creado un gestor de llamadas, de forma que si le paso el tipo de unidad, el tipo de producto, sus coordenadas, su ángulo y su facción, puedo generar automáticamente cualquier cosa (unidades, edificios,etc...) de cualquier jugador con la misma función:

Code Select Expand


process gestorllamadas(int tipo,int prod,x,y,angle,int fact)
begin
switch(tipo)
case 1:

end
case 2:

end
case 3:
guerrero(prod,x,y,angle,fact);
end
case 4:

end
case 5:

end
end
end

[Noivern]

Te recomiendo que cuando hagas esa función "universal", definas antes mediante constantes los números que representarán las unidades y/o edificios, para que te sea mucho más fácil saber que vas a construir con las llamadas a esa función, especialmente cuando el código crece mucho.

[Yawin]

Está definido xD

Por un lado, tengo estas variables globales:

Code Select Expand


struct guer[]
string nombre;
int vida;
int grafini;
int veloc;
int retardo;
int daño;
end

struct edif[]
string nombre;
int vida;
int graf;
int tipo;
int cantp;
int producs[2];
int tmppr;
int limitp;
end
Todavía no está definida la capacidad de la array, porque la iré aumentando a medida que haga unidades y edificios.

Y por otro lado, tengo este fichero:

guer[0].nombre="Crucero de batalla";
guer[0].vida=200;
guer[0].grafini=1;
guer[0].veloc=2;
guer[0].retardo=4;
guer[0].daño=10;


guer[1].nombre="Goliath";
guer[1].vida=50;
guer[1].grafini=9;
guer[1].veloc=3;
guer[1].retardo=2;
guer[1].daño=3;


edif[0].nombre="Cuartel";
edif[0].vida=2000;
edif[0].graf=100;
edif[0].tipo=3;
edif[0].cantp=2;
edif[0].producs[0]=0;
edif[0].producs[1]=1;
edif[0].tmppr=1000;
edif[0].limitp=5;

Esas cosas, las tengo muy bien pensadas.

[DjSonyk]

Te recomiendo que use type en vez de una estructura,ya que con type puedes instanciarlas tantas como edificios y enemigos necesites,asi obligatoriamente tienes que asignar las dimensiones,y puede que no te haga falta dentro del juego usar todas.Me explico :
struct guer[100]
............... resto del codigo
end
asi solo puedes tener 100 guerreros pero puede que al final no de tiempo a crear mas de 60,con lo que estas despediciando memoria que la puedes reserbar para musica,efectos,graficos,ect.
Con type lo puedes instanciar como se intancia los objetos en java,te digo esto porque creo recordad que dijiste que sabias java.
_guer guerrero

• ; asi lo instanciarias, por ejemplo.

[Yawin]

Esque... croe que no has entendido como funciona. Es algo asi como una bd. Es una array con esa estructura que guarda la información de el producto nave de batalla, goliath, etc...
de forma que, cuando instancio una unidad nueva, le paso de qué tipo es, y coje de ahí su vida, sus armas, su nombre, etc...

[DjSonyk]

Ah vale no me fije en la parte de abajo,te lei que lo tenias como variables globales :P,ya veo lo que quieres hacer.

[Yawin]

Bueno, ahora tengo un pequeño problema que no se me ocurre cómo resolver.

Por un lado, teniendo en cuenta que la resolución es de 800x600, de cuánto pondríais el mapa? 6000x6000?? Eso no ralentizará mucho un ordenador?

Por otro lado:
¿Alguna idea de cómo hacer el minimapa? Porque no se me ocurre ninguna forma.

[Drumpi]

En teoría, el mapa da igual el tamaño que tenga, ya que el blit se encarga de dibujar sólo la parte que interese. La pega puede venir por la memoria disponible, ya que un mapa de 6000x6000 ocuparía unos 6000x6000 bytes en formato 256 colores (unos 36MB), el doble si es en 16bits.
En este caso es casi mejor recurrir a un mapa de tiles, como toda la vida de dios, pero hay que trabajar el scroll de tiles.
Otra intermedia sería dividir el mapa en trozos más pequeños (no sé ¿1600x1200?) y usar las funciones de carga en background y diversos procesos para moverlos, es mucho más simple, pero hay que controlar muy bien cuándo se carga y se descarga cada mapa.

El minimapa no tienes más remedio que dibujarlo aparte y usar una región exclusivamente para él. Si lo quieres de forma redonda, tendrás que dibujar sobre un mapa y aplicarle una máscara para eliminar lo que sobra a cada frame (y eso sí que puede ralentizar el juego, aunque en un PC, lo dudo, tendría que tener sus buenos años ya).

[Yawin]

No entiendo eso de los mapas de tiles. xD

[Noivern]

En teoría, el mapa da igual el tamaño que tenga, ya que el blit se encarga de dibujar sólo la parte que interese. La pega puede venir por la memoria disponible, ya que un mapa de 6000x6000 ocuparía unos 6000x6000 bytes en formato 256 colores (unos 36MB), el doble si es en 16bits.
En este caso es casi mejor recurrir a un mapa de tiles, como toda la vida de dios, pero hay que trabajar el scroll de tiles.
Otra intermedia sería dividir el mapa en trozos más pequeños (no sé ¿1600x1200?) y usar las funciones de carga en background y diversos procesos para moverlos, es mucho más simple, pero hay que controlar muy bien cuándo se carga y se descarga cada mapa.

El minimapa no tienes más remedio que dibujarlo aparte y usar una región exclusivamente para él. Si lo quieres de forma redonda, tendrás que dibujar sobre un mapa y aplicarle una máscara para eliminar lo que sobra a cada frame (y eso sí que puede ralentizar el juego, aunque en un PC, lo dudo, tendría que tener sus buenos años ya).

Cuando el fondo de scroll era un mapa de 640x3000 px Free me dijo que en las portátiles andaba el juego a menos fps que cuando lo cambié a varias imagenes de 640x480 c/u. Parece que a las pequeñas les cuesta mover un mapa muy grande, no solo en cuanto a ram.

No entiendo eso de los mapas de tiles. xD

Es armar mapas en base a baldosas o tiles. Imaginate un rompecabezas de piezas cuadradas. La gracia es que permite ahorrar memoria, ya que con pocas imagenes pequeñas puedes armar grandes mapas. El punto en contra es que requiere más planeamiento y programación para hacerlo funcionar. Y en el caso de bennu, si haces cada baldosa como un proceso, entonces pedirá más poder de cpu.

[Yawin]

No a ver, sé lo que es. Lo que no entiendo es cómo va.