Ver la versión completa : ¿Hacemos explosiones?
Buenas noches a todos, estoy aqui liado y ha llegado el momento de las explosiones. ¿Como hariais vosotros las explosiones?
Ahora mismo yo tengo un array para controlar las explosiones q pueda haber, un tanque q explote, granadas, etc. Lo que no se es si haciendolo con tanto if no sera un poco coñazo y si habra otra forma de hacerlo mas comoda.
Tengo algo como esto para llamar a la explosion
if (Explosion(&Barril1, &tExplosion[auxExplosiones]) ==1); donde barril y explosion son estructuras, pero claro si tengo q poner un if para cada elemento del juego no se yo si no cargare mucho la gp.
¿Alguna idea? q a estas horas ya esta uno espesito de darle todo el dia al teclado ;)
neostalker
29/08/2005, 22:02
CATA
PLUM!
xDDDD :quepalmo:
Weno, ahora en serio. Coméntale a Petiso este tema, es posible q el pueda ayudarte ya q en el GPeskiv ha implementado explosiones recientemente. Suerte! :brindis:
si es una secuencia como si fuese una animacion tan solo tienes que ir aumentando una variable que es la que ira desplazandose por el array de la imagen y ya esta, eso es lo que he hecho yo para alguna animacion ;)
jjdrako si la animacion la tengo clara, lo q no tengo claro es la mejor forma de poner las explosiones, es decir ahora por cada explosion hago un if (enemigo, tocabala) explosion()
Y claro eso con muchas explosiones puede ser un peñazo para mi escribirlas y la maquina no se yo si no ira algo petada con tanto if.
Por eso pregunto alguna forma de implementar la explosion sin tanto if, a estas horas la cabeza no da para mucho ya XD
the_goulin
29/08/2005, 22:33
Eskema no entiendo bien el problema...
haces un
if (enemigo1,tocabala2) {...}
if (enemigo2,tocabala1) {...}
if (enemigo3,tocabala3) {...}
??
si estas haciendo esto desde luego que es una locura...
la historia es que tengas todas las posiciones de los diferentes enemigos en un array y las compares con las balas activas, si una bala choca con un enemigo creas una explosion y eliminas al enemigo.
Saludillos,
The_Goulin
(_=*ZaXeR*=_)
29/08/2005, 22:33
No se muy bien como funciona tu juego, pero si fuera un disparo por ejemplo lo que probocara la explosion, podria el if dentro de la funcion que llama al disparo, y luego dentro de la funcion comprobaria que el disparo ha colisionado, en cuyo caso explotaria lo que fuera.
Claro esta que si disparas balas contra un tio, pos no valdria.
(_=*ZaXeR*=_)
29/08/2005, 22:36
Eskema no entiendo bien el problema...
haces un
if (enemigo1,tocabala2) {...}
if (enemigo2,tocabala1) {...}
if (enemigo3,tocabala3) {...}
??
si estas haciendo esto desde luego que es una locura...
la historia es que tengas todas las posiciones de los diferentes enemigos en un array y las compares con las balas activas, si una bala choca con un enemigo creas una explosion y eliminas al enemigo.
Saludillos,
The_Goulin
**** cuantos segundos antes que yo le has dado a enviar? :D
Exacto goulin es lo q hago, pq no se me ocurre otra cosa, eso de tener un array como dices, ¿me explicas algo mejor como? si no es mucho pedir algo de pseudocodigo para ver mejor como....
seria ir preguntando cada vez que desplazas la bala si esta conincide con otro objeto
:) -->:)
if (bala1.x+bala1.width=malo.x)
iniciar_explosion();
no se si es eso lo que quieres eskema
(_=*ZaXeR*=_) tambien puede haber una explosion de sangre cuando se dispare a una persona :D
(_=*ZaXeR*=_)
29/08/2005, 23:05
Hombre ya, pero para eso en la colision es donde deberia comprobar con que se colisiona.
Pero de todas forma si se disparan granadas las explosiones se hacen siempre, es que depende del arma. Yo en mi mini juego metal slug que me hice, cada arma tenia su propia funcion de disparo, ya que no todas las armas disparan con la misma trayectoria e impactan igual.
Lo mejor para las colisiones es usar la comparacion de colores de los pixels, asi no te tienes que currar un hiper mapa en arrays y ademas puedes dejar que los elementos objetivo se mueval libremente por el entorno
Lo mejor para las colisiones es usar la comparacion de colores de los pixels, asi no te tienes que currar un hiper mapa en arrays y ademas puedes dejar que los elementos objetivo se mueval libremente por el entorno
nunca habia visto esa manera de colisionar, yo siempre he oido que es comparando coordenadas, de todos modos tienes que ir preguntando asi que mas da el mirar si chocan por coordenadas que por colores, por no decir que cada uno tendria que ser de un color diferente, no???
Pues yo para evitar mucho rollo .... me echo una estructura explosion. De esta forma, puedo crear una epxlosion donde quiera, se produzca como se produzca, sin muchos if's.
Simplificando un poco es:
#define MAX_EXP 69
int explosio_x[MAX_EXP];
int explosio_y[MAX_EXP];
int explosio_frame[MAX_EXP];
int n_explosio;
Una funcion, que quando quiero que salga una explosion la llamo:
void InsertarExplosioNuke(int x,int y)
{
explosio_x[n_explosio]=x;
explosio_y[n_explosio]=y;
explosio_frame[n_explosio]=0;
n_explosio++;
}
Otra que quita uan explosion quando se ha acabado:
void EsborrarExplosioNuke(int x)
{
int i;
for(i=x;i < n_explosio-1;i++)
{
explosio_x[i]=explosio_x[i+1];
explosio_y[i]=explosio_y[i+1];
explosio_frame[i]=explosio_frame[i+1];
}
partida->n_item_explosio--;
}
Y para acavar, en la funcion de pintar pantalla:
if (n_item_explosio) //si tengo alguna explosion la pinto ......
{
for(i=partida.n_item_explosio-1;i>=0;i--) //nota: el for va al rebes para poder borrar quando se acabe uan explosion.
{
GpTransBlt(NULL,&gpDraw[nflip], explosio_x[i], explosio_y[i], DJO, DJO,
ani_explo[explosio_frame[i]],0,0,DJO,DJO,0);
explosio_frame[i]++;
if (explosio_frame[i]>=4) //cuando se acabe la esplosion al borro.
{
EsborrarExplosioNuke(&partida,i);
}
}
}
Ala, espero que te sirva.
(_=*ZaXeR*=_)
29/08/2005, 23:31
Hombre yo conozco 3 forma de colisionar, una por posicion X Y ,otra por situacion en un array (tanto de una como de dos dimensiones) de los dos elementos a colisionar, y la ultima por colores de los pixels.
La mas optima es la del color de los pixels, puesto que te olvidas de guardar y actualizar constantemente la posicion de los objetos que tienen que colisionar, es mas limpio, y ademas con tema de las situacion en un array, debes hacer el array tan grande como sea el escenario, y hacer que cada elemento del array corresponda con un numero de pixels, ya que tiene que caber exactamente el tamaño del mapa con el array, sin contar con que segun lo grande que hagas el mapa cambia la apreciacion del impacto en la pantalla.
hombre sea un objeto movil o inmovil seguro estas guardando sus coordenadas en alguna variable asi que tampoco veo que sea complicado por coordenas
(_=*ZaXeR*=_)
30/08/2005, 00:07
por no decir que cada uno tendria que ser de un color diferente, no???
Se me olvidaba, no tiene porque ser un color diferente, puede ser tambien el mismo color.
Me explico, la bala puede ser azul y solo impactar con los colores verdes y negro. Con los verdes da explosion, y con los negros da sangre. O puede ser azul y solo impactar con lo que sea azul tambien.
Yo por ejemplo veo mas facil hacer las colisiones con colores para juegos con muchos elementos en pantalla y mucho movimiento de personajes, pero veo mas favil quizas las colisiones por posicion en un array para una pantalla que es fija y no se muece, como la de un pong.
Lo de las coordenadas, no es algo que este muy depurado, porque cual es la X y la Y de cada objeto que vas a comparar para el impacto? al no poder elegir uno concreto, tendrias que guardar un rango de coordenadas X Y (normalmente el tamaño del sprite en altura y en anchura) de todos los objetos, sino, una bala que de en la pierna de un enemigo por ejemplo no impactaria ya que la coordenada del pixel del pie no la tienes guardada.
La posicion en un array de ambos objetos soluciona el tema del tamaño del sprite para el impacto, pero tienes que hacer que el sprite del personaje no se salga del tamaño de los pixels asingados para una celda del mapa, porque en ese caso estariamos en las misma, la cabeza se sale de la celda, y la bala va por la celda de la cabeza, pero como la posicion que guardas no es la de la celda de la cabeza, pues no hay impacto. Y por si fuera poco el tema del array, como tienes que dividir el entorno del juego en celdas de un tamaño concreto de pixels, como no afines bien, el efecto del impatco de la bala con el personaje, puede que no se vea bien, y quede mal.
pero eso de la colision con que instruccion es?? hay alguna para coger para saber de que color es el pixel que hay en pantalla ?¿?¿?
(_=*ZaXeR*=_)
30/08/2005, 00:35
Esa misma pregunta me hice yo en mi tiempo, miralo aqui.
http://www.gp32spain.com/foros/showthread.php?t=6985&page=1&pp=10&highlight=Wave
Ya te digo, que dependiendo del tipo de juego, es buena un tipo u otro de deteccion de colisiones, hay que estudiar bien la situacion para encontrar la mejor opcion.
A ver ..... estabamso hablando de epxlosiones, o de colisiones ?
Adios !
(_=*ZaXeR*=_)
30/08/2005, 00:47
Hablamos de que las explosiones tienen que darse cuando haya colisiones, que es lo que Eskema no sabia situar, ya que decia que si tenia que poner las explosiones a lo largo de tol juego, tenia que jartarse de pone ifss. Asi que hablamos de ambas cosas, bueno basicamente, yo le he dicho que haga el if de la explosion cuando haya una colision, cosa que se tiene que comprobar cuando se dispara.
the_goulin
30/08/2005, 08:48
Oyo,
bueno, la mejor forma de comprobar colisiones es por Pixels utilizando mascaras en los objetos.
la Tecnica de colision que yo recomendaria a Eskema es Bounding Box (u algo asi) que se basa en Deteccion de choque por Regiones
vamos seria algo asi
bala Muñeco
OOO XXXX
O O XXXX
OOO XXXX
XXXX
si bala choca con muñeco
bala Muñeco
OOOXXX
O OXXX
OOOXXX
XXXX
se produce la colision
para eso deberiamos almacenar las posiciones X,Y, Alto,Ancho (tambien podriamos guardar tipo:bala,humano,tanque,etc,etc) de todos los objetos en un array
y ir comprobando
typedef struct
{
int x;
iny y;
int w;
int h;
} coordenadas[maxObjetos];
for (n=0;n<maxObjetos;n++)
for (Obj=0;Obj<MaxObjetos;n++)
if (Obj!=n)
{
if (compruebaChoque()==TRUE)
{
mataObjeto();
creaExplosion(coordenadas[Obj);
}
}
creo que mas o menos seria eso, es similar a lo que utilizo en el GpFrogger :) si necesitas mas ayuda pos me lo dices.
Saludillos,
The_Goulin
Hombre yo conozco 3 forma de colisionar, una por posicion X Y ,otra por situacion en un array (tanto de una como de dos dimensiones) de los dos elementos a colisionar, y la ultima por colores de los pixels.
La mas optima es la del color de los pixels, puesto que te olvidas de guardar y actualizar constantemente la posicion de los objetos que tienen que colisionar, es mas limpio, y ademas con tema de las situacion en un array, debes hacer el array tan grande como sea el escenario, y hacer que cada elemento del array corresponda con un numero de pixels, ya que tiene que caber exactamente el tamaño del mapa con el array, sin contar con que segun lo grande que hagas el mapa cambia la apreciacion del impacto en la pantalla.
Te olvidas otra forma de detectar colisiones que es por máscara. Para mi es más óptima que por colores (que no conocía por cierto), ya que por colores tienes que comparar píxel a píxel y con máscaras comparas 32 píxeles a la vez con una operanción AND y algun que otro desplazamiento de bits.
El método es algo más pesado de poner en práctica pero es muy efectivo y mucho más rápido.
El gran defecto que le veo a tu método de colisión por colores es que tus rutinas de colisión dependen del color de tus sprites, con lo que tienes que ajustar el código si cambias el color.
Oankali.
the_goulin
30/08/2005, 08:53
Te olvidas otra forma de detectar colisiones que es por máscara. Para mi es más óptima que por colores (que no conocía por cierto), ya que por colores tienes que comparar píxel a píxel y con máscaras comparas 32 píxeles a la vez con una operanción AND y algun que otro desplazamiento de bits.
El método es algo más pesado de poner en práctica pero es muy efectivo y mucho más rápido.
El gran defecto que le veo a tu método de colisión por colores es que tus rutinas de colisión dependen del color de tus sprites, con lo que tienes que ajustar el código si cambias el color.
Oankali.
XDD Al final nos tendremos de llamar por telefono antes de escribir en el foro para no contar lo mismo xDD
Aunque tu has entrado en mas detalles :rever:
Saludillos Oankali ^_^,
The_Goulin
es de agredecer que por lo menos aprendamos entre nosotros ;)
Veo que os gusta mucho utilizar los arrays para culquier cosa. Yo en general prefiero listas dinámicas.
Puede que no sean tan rápidas, pero son mucho más prácticas a la hora de usárlas y sobretodo solo tienen como límite la memória disponible.
En el caso de las explosiones, una vez detectada la colisión, lo que haría es crear un objeto explosión en mi lista dinámica de objetos (también funciona en C con estructuras).
Cuando la explosión ha terminado, elimino el objeto explosión de mi lista y ya está.
Esta lista de objetos no tiene porqué estar limitada a explosiones, puedes meter lo que sea, un pájaro volando, una putuación flotando que tiene que desaparer, etc.
Normalmente trabajo con varias listas a la vez, en principio una para cada plano (objetos del decorado, objetos principales, efectos especiales).
Cada uno se lo monta como quiere.
La librería que utilizo para las listas dinámicas es list.h y la encontraréis en mi web.
XDD Al final nos tendremos de llamar por telefono antes de escribir en el foro para no contar lo mismo xDD
Aunque tu has entrado en mas detalles :rever:
Saludillos Oankali ^_^,
The_Goulin
Tienes razón :), aunque yo considero que está muy poco detallado, tu al menos te has currado algun ejemplillo. :brindis:
Oankali.
Gracias por las respuestas, tal como yo lo tengo implementado es casi igual que la forma q Petiso comenta, una funcion para crear la explosion, otra para ponerla. Lo cual hace q en la colision tenga q hacer todo el rato
if(enemigo[maxenemigos], colision(bala)) explosion();
if(tanque,colision(bala)) explosion();
y asi por cada cosa q tenga, vaaaale los enemigos son 1 array y solo los pongo una vez, pero el resto de objetos q pueda poner hay q hacerlos a mano.
De ahi q yo preguntaba si habia otra forma mas comoda de hacerlo o tenia q morir a hacer un if para añadir una explosion cada vez.
Oankali, ¿podrias explicar mejor eso de las mascaras para una colision? yo hago la tipica comparacion de coordenadas y listos, es mas ni sabia que se pudiera hacer de otra manera ;)
[...]
Oankali, ¿podrias explicar mejor eso de las mascaras para una colision? yo hago la tipica comparacion de coordenadas y listos, es mas ni sabia que se pudiera hacer de otra manera ;)
Para empezar, necesitas crear un bitmap monocromo de cada sprite que necesite detección de colisiones.
Monocromo significa que cada píxel ocupa solo un bit. O sea que en un long te entran 32 píxeles.
Esto lo tienes que hacer para cada frame de los sprites. Cada máscara vendría a ser la sombra del bitmap que contiene los sprites reales.
Lo puedes hacer de dos formas:
1.- Al momento de diseñar el juego con lo que puedes crear máscaras diferentes del sprite real.
Un ejemplo sería cuando quieres dar un poco de margen a la colisión, entonces tienes que hacer la máscara un poco más pequeña.
Otro ejemplo es cuando solo unas partes del sprite puede colisionar como por ejemplo las púas de un erizo.
2.- Al inicializar el juego (o una fase del juego).
En este caso, creas automáticamente una máscara en monocromo para cada sprite que consistiría en la sobra que produciría el sprite.
La detección de colisiones se hace de la manera siguiente:
1.- Primero se hace un control por coordenadas (bounding box). Aprovechamos para calcular las coordenadas del rectángulo resultado de la unión de los dos sprites (por ejemplo la esquina inferior-derecha con la esquina superior-izquierda). Si el rectángulo es nulo, o sea que los dos sprites a controlar no se solapan, pasamos de controlar las máscaras, en caso contrario pasamos al paso 2.
2.- Controlamos la colisión solo para el rectángulo que hemos calculado. Hasta ahora es el mismo principio que para un control directo sobre los píxeles (o colores).
Ahora es cuando entran en juego las máscaras.
En lugar de dos simples bucles, controlando cada píxel del rectángulo para cada sprite (ajustando las coordenadas en función de la posición de los sprites), usaremos un bucle para cada 'scan' del rectángulo o sea cada línea, y un bucle para cada 32 píxeles si usamos una máscara de 32 bits.
A cada bucle hacemos una operación AND y si da positivo, es que hay colisión. De esta manera controlamos 32 píxeles de golpe.
Hay que tener en cuenta que habrá que hacer desplazamientos de bits para ajustar correctamente la máscara a la posición horizontal de los sprites.
Bueno, espero que haya quedado algo más claro.
Tengo que admitir que personalmente no he programado nunca este algoritmo porque hasta ahora siempre he hecho juegos en que solo he necesitado hacer un control a partir de un array. Pero es el método que se utilizaba en tiempos del ZX Spectrum y daba muy buenos resultados.
Oankali.
Pues yo tampoco conocia la de comparacion de color, me imagino que tendras que controlar un poco la paleta si no quieres que se invente colisiones con los fondos y eso; pero para un enemigo que sea por ejemplo una masa sin forma que se va transformando o un conjunto de particulas seria muy interessante.
Lo de mapa de dureza solo lo he utilizado en div2, nose si seria capaz de programarlo bien en c.
Powered by vBulletin® Version 4.2.5 Copyright © 2025 vBulletin Solutions Inc. All rights reserved.