estoy tratando de hacer algo igual a mario bros que cuando le cae a la tortuga queda el caparazon y luego le caes de nuevo la matas y desaparece verdad hasta hay claro todo .
Ahora viene lo que me sucede resulta que tengo 10 gusanos difrenetes cada uno con su sprite de muerte y otro de aplastado
ahora lo que quiero hacer es usar solo un obj_gusano
con random_range logro crear los gusanos random hasta hay bien todo pero ahora como saber a que imagen corresponde cada gusano muerto.
Gracias espero me entiendas mi duda.
La variable que relaciona un objeto con un sprite es "sprite_index".
En el evento "create", incluye este código:
randomize() // Activa la "semilla" aleatoria.
sprite_index=choose(sprgu1,sprgu2,sprgu3,etc)
Marth muchas gracias pero eso ya lo tengo listo ahora lo que me.hace falta es como comparar que sprite es y que a la.hora de caerle en cima me tiere el sprite de gusano rojo digamos el sprite muerto tendria que ser rojo en este caso y asi sucesivamente..
Gracias
En realidad ni siquiera hace falta que sepas que gusano es para cambiarle el sprite.
Simplemente haz esto:
1) acomoda los nombres de los sprites de forma conveniente.
spr_gusano1, spr_gusano2, spr_gusano3, ..., spr_gusano10
spr_gusano1_muerto, spr_gusano2_muerto, spr_gusano3_muerto, ..., spr_gusano10_muerto
spr_gusano1_aplastado, spr_gusano2_aplastado, spr_gusano3_aplastado, ..., spr_gusano10_aplastado
2) cuando tengas que mostrar el sprite muerto, solo pon esta línea de código:
sprite_index = asset_get_index(sprite_get_name (sprite_index) + "_muerto");
Debería funcionar, no lo probé. La idea es que el nombre del sprite del gusano muerto sea el mismo nombre del sprite que ya tiene pero con el sufijo "_muerto".
Entonces habría que hallar primero el nombre del sprite en texto del objeto gusano para agregarle el sufijo "_muerto", esto se logra con sprite_get_name (sprite_index) siendo sprite_index el número identificador del sprite, al pasárselo a esta función devuelve su nombre en texto. Luego de esto le agregamos el sufijo. Con esto tenemos el nombre en texto del sprite que debería tener el gusano, ahora falta hacer la operación inversa, es decir, obtener el número identificador del sprite que corresponda a ese nombre en texto que generamos. Esto se logra con la función asset_get_index() y por último almacenamos ese numero en el sprite_index y ¡listo!
De esta forma podés agregar la cantidad de gusanos que quieras y no tendrías que alterar el código porque funcionaría igual, siempre y cuando respetes la convención de nombres de los sprites, que el sprite correspondiente a la muerte sea el mismo nombre pero con el sufijo "_muerto" (o el que quieras porsupuesto)
3) cuando tengas que mostrar el sprite aplastado, haz lo mismo pero con el sufijo correspondiente:
sprite_index = asset_get_index(sprite_get_name (sprite_index) + "_aplastado");
Nota:
No se las transiciones que hay entre los estados del gusano. Porque si primero es aplastado y después muerto, vas a tener que hacer unas modificaciones en el código o en los nombres de los sprites. Porque primero va genial de spr_gusano5 a spr_gusano5_aplastado pero si luego muere va a quedar el nombre como spr_gusano5_aplastado_muerto en lugar de spr_gusano5_muerto. Podrías pensar en poner los nombres de los sprites de muerte con el sufijo: _aplastado_muerto para que cuando sea aplastado le agregue "_aplastado" y cuando esté muerto le agregue "_muerto" quedando perfecto pero el problema es ¿que pasa si el gusano muere directamente con un disparo de llama del mario bros sin ser aplastado antes? pasaría del estado normal a muerto directamente y no funcionaría el código.
Aclaro esto porque hay que tener en cuenta todo, y este código que te pasé es solo para transmitir la idea pero hay que hacerle modificaciones para que ande en tu juego. Conceptualmente lo correcto sería dejar los nombres de los sprites con un solo sufijo, es decir, el nombre del sprite mas el guión bajo seguido del nombre del estado, como esto:
spr_gusano01_normal, spr_gusano02_normal, spr_gusano99_normal
spr_gusano01_muerto, spr_gusano02_muerto, spr_gusano99_muerto
spr_gusano01_aplastado, spr_gusano02_aplastado, spr_gusano99_aplastado
hice la modificación de rellenar con un cero los gusanos de una sola cifra, es decir, gusano01 en lugar de gusano1 para que todos estos nombres antes del sufijo tengan el mismo tamaño de caracteres. Entonces a la hora de cambiarle el sufijo habria que copiar los primeros 13 caracteres de la cadena (con alguna función de manejo de cadena de texto) y agregarle el sufijo que queramos después y por último convertir esto a índice.
quedando así para el caso de muerte:
sprite_index = asset_get_index(string_copy(sprite_get_name(sprite_index),1,13) + "muerto");
y así cuando es aplastado:
sprite_index = asset_get_index(string_copy(sprite_get_name(sprite_index),1,13) + "aplastado");
y de esta forma si muere directo, o si es aplastado antes no importa, porque cambia el sufijo en lugar de agregarlo funcionando para todos los casos.
Todo lo anterior es para evitar un gran switch de este tipo:
switch(sprite_index)
{
case gusano01:
//acciones para cambiar al sprite correspondiente
break;
case gusano02:
//acciones para cambiar al sprite correspondiente
break;
case gusano03:
//acciones para cambiar al sprite correspondiente
break;
case gusano04:
//acciones para cambiar al sprite correspondiente
break;
case gusano05:
//acciones para cambiar al sprite correspondiente
break;
case gusano06:
//acciones para cambiar al sprite correspondiente
break;
case gusano07:
//acciones para cambiar al sprite correspondiente
break;
case gusano08:
//acciones para cambiar al sprite correspondiente
break;
case gusano09:
//acciones para cambiar al sprite correspondiente
break;
case gusano10:
//acciones para cambiar al sprite correspondiente
break;
}
y un switch así para la muerte y otro para cuando es aplastado, es muy ineficiente y poco elegante. Encima habría que modificarlo cada vez que se agregue un nuevo tipo de gusano. Por eso doy la idea de poner los nombres de los sprites de forma conveniente para que con una línea de código tengas la solución genérica que te servirá para la cantidad de tipos de gusanos que quieras.
Por último:
Si los sprites de los gusanos son estáticos y no hay ningún sprite animado la cosa es aún más simple. En la posición cero del sprite ponés la imagen del gusano en su estado normal, en la posición 1 la imagen del gusano aplastado y en la posición 2 la imagen del gusano muerto. En el objeto pones: "image_speed = 0". Y luego cuando el gusano es aplastado simplemente poner: image_index = 1 y cuando muere: image_index = 2.
Con la lógica anterior podrías hacerlo con sprites animados pero haciendo unas modificaciones.Supongamos que en el modo normal todos los gusanos muestren su correspondiente sprite de animación de 5 sub-imágenes (pero aunque las imágenes son distintas todos con la misma cantidad de cuadros de animación). El sprite aplastado y muerto sean sprite simples de una sola imagen. Entonces haz esto:
1) usa un solo sprite para cada tipo de gusano que reúna todas las fases de su vida (normal, aplastado y muerto).
1) De la posición "0" a la posición "4" pon la secuencia de animación del modo normal
2) En la posición 5 pon cualquier imagen, si quieres transparente, porque esta subimagen no se va a mostrar nunca simplemente va a servir como bandera para decir que ya terminó la animación y hay que volver a la subimagen cero, por
lo tanto jamás se dibujará esta subimagen.
3) en la posición 6 pon la imagen del gusano aplastado
4) en la posición 7 pon la imagen del gusano muerto
en el evento "step" del objeto gusano pon:
if (image_index == 5)
image_index = 0;
esto hará que se muestre la animación cíclica de las subimágenes 0,1,2,3 y 4.
cuando es aplastado:
image_speed = 0; //para que muestre una imagen fija
image_index = 6; //que es la imagen del gusano aplastado
cuando muere:
image_speed = 0; //para que muestre una imagen fija
image_index = 7; //que es la imagen del gusano muerto
Amplié aún más mi comentario anterior agregando nuevas alternativas (le puse modificar comentario y le agregué cosas) te aviso por si ya leíste mi comentario para que vuelvas a fijarte. Si te funcionó o tienes alguna duda avisame. Saludos!
Bueno los ejemplos que te pasé tuvieron como fin proporcionarte ideas para que puedas mostrar el sprite de aplastado o muerto correspondiente al gusano sin ni siquiera tener necesidad de saber de que tipo de gusano se trata pudiendo lograr un código genérico que funcione para todos los casos.
Pero si necesitas saber que tipo de sprite tiene asignado el objeto para darle un comportamiento distinto según sea el caso, esto es muy sencillo.
sprite_index guarda el número identificador del sprite que tiene almacenado.
Entonces... hacemos un switch ( o if )preguntando si el número del sprite_index corresponde al spr_gusano01, en ese caso hacemos las acciones que querramos correspondientes a ese tipo de gusano, luego preguntamos por el caso de que si el sprite_index corresponde al spr_gusano02, etc.
¿Cómo sabemos cuál es el número de sprite de spr_gusano01 y de cada sprite? No hace falta saberlo, Game Maker nos la hace fácil, definiendo como una especie de "variable" (para que se entienda) con el mismo nombre que el sprite cuyo valor almacena ese número. Entonces podemos hacer:
if (sprite_index == spr_gusano01)
{
//realizar las acciones correspondientes
}
el if compara la igualdad con spr_gusano01 sin comillas porque no es una cadena de texto sino esa especie de variable creada por Game Maker con el mismo nombre del sprite que tiene el valor numérico del id de sprite correspondiente.
Waooo tengo que veer por donde comienzo XD XD
Gracias voy a probar a ver que pasa
Tomando la idea de fasst007 para llevarla a código, puedes crear un script que retorne el sprite asociado a un tipo de gusano y un estado. Por ejemplo:
//argument0=número de gusano
//argument1=estado ("aplastado", "muerto")
return asset_get_index("spr_gusano"+string(argument0)+"_"+argument1);
Para que funcione, los nombres de los sprites deben estar en la forma spr_gusanoN_estado, donde:
N=1,2,3....,10 que representa el tipo de gusano
estado=aplastado, muerto
entonces, por ejemplo, el gusano tipo 3 en su estado muerto quedaría como spr_gusano3_muerto.
Donde necesites saber qué sprite corresponde a un gusano que ha cambiado su estado, invocas al script con esos 2 argumentos. Por ejemplo si nombras al script scr_spr_gusano, para cambiar el sprite del gusano tipo 7 a aplastado colocas:
sprite_index=scr_spr_gusano(7,"aplastado");
dios mio que infierno de sugerencias xD se va a tirar por la ventana xD ?) no es más fácil y ordenado que desde un principio en create, haga una variable con un numero irandom y luego use switches? (pregunto eeh xD)
y no... porque la idea era evitar los switches porque si por ejemplo tenes 20 elementos tenés que usar 20 cases para el switch para cambiar a un modo, otro switch con otros 20 cases para pasar al otro modo. Y además si agregas elementos al juego tenés que modificar todos los switch. En cambio de esta forma se haría todo con una sola linea de código y no habría que modificarla aún cuando se agregaran elementos lo que sería más fácil, más corto y más genérico que los switch.
La cantidad de sugerencias era para que tenga varias alternativas para enfocar el problema, es mejor dar varias opciones que una sola opción, porque por más que le demos la mejor opción a nuestro criterio quizás para él sea mejor otra. Bueno entonces uno brinda varias ideas, para dar un abanico mayor de posibilidades y que elija, y de paso también le puede servir a muchas otras personas que entran a leer estos comentarios .
Teniendo en cuenta el problema original de tener un sprite distinto por cada estado, hice un proyecto a las apuradas de forma muy simplificada. Al ejecutar el proyecto aparecen en el room 4 instancias gusano y 2 rectángulos con nombres: "aplastar" y "matar". Estos rectángulos hay que arrastrarlos con el mouse y hacerlos colisionar con las instancias de gusano, al hacer esto el sprite del gusano cambiará con el sprite correspondiente.
La mayoría del código es usado para manejar el arrastrado de esos dos rectángulos y la ubicación de los elementos en el escenario con su inicializaciones correspondientes. Pero el código que cambia los sprites está en el evento colisión del objeto: accion y es una sola línea de código. Esto es un ejemplo para captar la idea.
También hay código en el "Creation Code" del room.