Comunidad Game Maker

Perdona que insista, pero no entiendo dónde es que destruyes la instancia enemigo cuando el personaje cambia de tipo de objeto a obj_granjero_pos. Entiendo que tu problema es que la instancia enemigo no se destruye.

No hay una función simple que pueda ayudarte, lo que quieres hacer es bastante complejo por la cantidad de casos que pueden darse. Toma en cuenta que no es adecuado utilizar el evento colisión para esto ya que las piezas no necesariamente tienen que colisionar para formar una línea (por ejemplo cuando se forma una línea horizontal). Te sugiero como idea que crees una función recursiva que analice, para una pieza dada, todas las piezas que están adyacentes a ella, incrementando un contador cada vez que encuentre una pieza contigua del mismo tipo en la misma fila o columna.

Saudio es compatible con mp3 y wav, puedes ver las características en http://gmc.yoyogames.com/?showtopic=153450

¿Tienes GM 8.0 u 8.1?

De acuerdo a lo que dices que hiciste, debería funcionar. Intenta ver si este ejemplo que te adjunto corre en tu GM.

Tienes razón, es la versión de GM:S, actualicé a la 1.3 y se escucha perfecto.

Tengo la versión 1.1.917 de GM:S y al agregar un sonido en formato mp3 el previsualizador que viene incorporado en las propiedades del sonido lo reproduce perfectamente. Sin embargo, durante el juego el sonido se reproduce con una calidad espantosamente mala. ¿A qué puede deberse esto? ¿Le pasa lo mismo a alguien más?

Adjunto el proyecto para importarlo en formato .gmz

¿Dónde destruyes la instancia enemigo?

Como te dijo Penumbra, los scripts de Saudio no los debes modificar, lo que debes hacer es hacer una llamada a esos scripts entregándoles los argumentos apropiados. Yo usaba esa dll para incorporar sonidos mp3 a mis proyectos pero cuando cambié a windows 7 x64 la dll dejó de funcionar. Espero que no sea tu caso, yo me puse a buscar una alternativa compatible con Windows 7 x64 y luego de mucho buscar encontré SXMS-3.dll.

Para usar saudio haz esto:

1. Importar los scripts que vienen con el ejemplo editable de GM (lo cual entiendo que ya hiciste).
2. Copiar el archivo saudio.dll a la misma carpeta donde está el editable del juego
3. Inicializar la dll:

saud_Init();

4. Cargar el archivo de música (donde Musica.mp3 es el nombre del archivo que contiene el sonido, o la ruta hasta él; cámbialo según corresponda):

path="Musica.mp3";
saud_Load(path,"sonido1");
if saud_CanPlay("sonido1")!="true"
    show_message("Sonido incompatible");

El string "sonido1" es simplemente un identificador que usa la dll para ese sonido cargado y que se usa al llamar a los scripts.

5. Reproducir el archivo:

saud_Loop("sonido1");

Luego, si quieres pausar el sonido, haces una llamada al script saud_Pause:

saud_Pause("sonido1");

Si quieres que continúe sonando:

saud_Resume("sonido1");

Recuerda cerrar el sonido cuando ya no lo necesites:

saud_Close("sonido1");

O cierra todos si el juego termina:

saud_CloseAll();

Supongamos que el área donde debe aparecer la instancia está definida por un rectángulo cuyos vértices superior izquierdo e inferior derecho son (x1,y1) y (x2,y2), respectivamente. Para acotar la creación de la instancia a esta superficie, modifica el código del instance_create como sigue:

instance_create(x1+irandom(x2-x1),y1+irandom(y2-y1),obj_energia);

Esto hace que la ubicación de la instancia creada esté entre x1 y x2 (para la coordenada x) y entre y1 e y2 (para la coordenada y).

Supongamos que identificas para cada instancia del juego si el jugador es el host o el cliente usando una variable global.master (true para el host, false para el cliente). Si lo que ve el jugador del host se encuentra en la view[0] y lo que ve el otro se encuentra en la view[1], cambia los valores de view_visible como sigue:

if global.master
    {
    view_visible[0]=true;
    view_visible[1]=false;
    }
else
    {
    view_visible[0]=false;
    view_visible[1]=true;
    }

Indica cómo hiciste aparecer el objeto aleatoriamente, así será más fácil ayudarte.

Nombre del creador: Guacusio

Versión GM utilizada:  :GMS: (compatible con  :GM6:  :GM7:  :GM8:)

Descripción: Cambia en forma continua y automática el valor de una variable dada en una instancia dada entre dos valores dados a una velocidad dada

Este script surge de la necesidad de cambiar variables en forma continua sin necesidad de crear código especial para cada una en los objetos que las contienen. Ejemplos del uso de este script son mover una instancia de un punto a otro, rotarla, cambiar su escala, velocidad, etc. cambiando la variable correspondiente en forma continua en vez de discreta. Pueden cambiarse variables de 0, 1 o 2 dimensiones.

El formato de llamada del script es el siguiente:

argument0=nombre de la variable a cambiar(string)
argument1=valor inicial con que partirá la variable
argument2=valor final deseado de la variable
argument3=número de steps deseados para el cambio
argument4=id de la instancia que contiene a la variable

Ejemplos (asumiendo que el script se llama scr_cv):

Mueve la instancia actual 100 pixeles a la derecha y 80 pixeles hacia arriba en 35 steps:
scr_cv("x",x,x+100,35,id);
scr_cv("y",y,y-80,35,id);

Rotar 90º la instancia j en 40 steps:
scr_cv("image_amgle",j.image_angle,j.image_angle+90,40,j);

Mover el view[0] hasta las coordenadas (100,100) en 60 steps:
scr_cv("view_xview[0]",view_xview[0],100,60,id);
scr_cv("view_yview[0]",view_yview[0],100,60,id);

Este script requiere un objeto auxiliar que manipule las variables, llamado o_cv. Se requiere agregar este objeto con los siguientes eventos:

Create:
[gml]nvar=0;[/gml]

End step:
[gml]//proceso principal de cambio de variables
//array v[i,j] guarda los datos necesarios para cambiar la variable i-ésima
//v[i,0]=id de la instancia que contiene a la variable
//v[i,1]=nombre de la variable a cambiar (string)
//v[i,2]=valor inicial de la variable
//v[i,3]=valor final de la variable
//v[i,4]=valor actual de la variable
//v[i,5]=incremento aplicado a la variable en cada step

var i,j,a1,a2,n,n1,n2,c,fin,aux;
i=0;
while i<nvar//recorre el array con variables
    {
    fin=false;//indica si la variable ya llegó a su valor final
    if instance_exists(v[i,0])//sólo cambia variables de instancias existentes
        {
        if sign(v[i,3]-(v[i,4]+v[i,5]))!=sign(v[i,5])//detecta si la variable alcanza su valor final ahora
            {
            fin=true;
            v[i,4]=v[i,3];
            }
        else
            v[i,4]+=v[i,5];
        aux=v[i,4];//valor actualizado de la variable
        n=v[i,1];//nombre de la variable
        a1=string_pos("[",v[i,1]);//revisa si es array
        if a1>0
            {
            a2=string_pos("]",v[i,1]);
            n=string_copy(v[i,1],1,a1-1);
            c=string_pos(",",v[i,1]);//revisa si es de 2 dimensiones
            if c>0
                {//variable de 2 dimensiones
                n1=real(string_copy(v[i,1],a1+1,c-a2+1));//subíndice 1 de la variable
                n2=real(string_copy(v[i,1],c+1,a2-c+1));//subíndice 2 de la variable
                }
            else//variable de 1 dimensión
                n1=real(string_copy(v[i,1],a1+1,a2-a1+1));//subíndice de la variable
            }
        with v[i,0]
            {
            switch n//actualiza el valor de la variable
                {//NOTA: modificar según las variables esperadas que se cambiarán
                case "image_angle":
                    image_angle=aux;
                    break;
                case "x":
                    x=aux;
                    break;
                case "y":
                    y=aux;
                    break;
                case "a0":
                    a0=aux;
                    break;
                case "image_xscale":
                    image_xscale=aux;
                    break;
                case "image_yscale":
                    image_yscale=aux;
                    break;
                case "vspeed":
                    vspeed=aux;
                    break;
                case "hspeed":
                    hspeed=aux;
                    break;
                case "view_xview":
                    view_xview[n1]=aux;
                    break;
                case "view_yview":
                    view_yview[n1]=aux;
                    break;
                case "view_angle":
                    view_angle[n1]=aux;
                    break;
                }
            }
        }
    if fin or !instance_exists(v[i,0])
        {//elimina del array de variables las variables que ya no necesitan cambiarse
        for(j=0;j<6;j+=1)
            v[i,j]=v[nvar-1,j];
        nvar-=1;
        i-=1;
        }
    i+=1;
    }[/gml]

El código del evento end step anterior debe ser editado dentro de la sentencia switch para agregar o quitar las variables que reconoce el script; esto es así porque en GM Studio no existe la antigua función variable_local_set que habría facilitado enormemente la programación permitiendo el reconocimiento de cualquier variable. Por el mismo motivo, no es posible crear dentro del script el objeto o_cv usando object_add, ya que esta función también quedó obsoleta.

Script de llamada a la función:
[gml]// cambia el valor de la variable numérica argument0
// desde el valor argument1 hasta el valor argument 2
// en argument3 pasos
// en la instancia argument4

var aux,i,inc;
if !instance_exists(o_cv)
    instance_create(0,0,o_cv);//crea una instancia de o_cv si no existe
with o_cv
    {
    aux=nvar;
    for(i=0;i<nvar;i+=1)
        {
        if v[i,0]=argument4 and v[i,1]=argument0
            aux=i;//esta variable ya estaba cambiando
        }
    v[aux,0]=argument4;
    v[aux,1]=argument0;
    v[aux,2]=argument1;
    v[aux,3]=argument2;
    v[aux,4]=argument1;
    inc=(argument2-argument1)/argument3;//incremento por paso
    if inc<0
        v[aux,5]=min(-0.0001,inc);
    else
        v[aux,5]=max(0.0001,inc);
    if aux=nvar
        nvar+=1;//esta variable es nueva
    }[/gml]

Tienes un problema con el uso del evento de colisión con el suelo en el objeto obj_saltando: cuando el personaje cae y colisiona con el suelo, como éste es sólido, el personaje retrocede hacia arriba hasta la posición anterior a la colisión, y como inmediatamente abajo del personaje vuelve a estar vacío, el evento step del objeto obj_corriendo hace que el personaje vuelva a transformarse en el objeto obj_saltando. Esto produce un cambio sucesivo de la instancia entre ambos objetos hasta que se estabiliza la coordenada vertical y el personaje queda a ras de suelo. Esto se soluciona agregando una acción Move to contact hacia abajo (270º) para asegurarte de que cuando el personaje toca por primera vez el suelo, quede a ras del suelo en vez de volver a la posición inmediatamente anterior en el aire. Te adjunto el archivo modificado.

knd144 y zeit: tienen raz?n, como el eje Y avanza hacia abajo, hay que restar el resultado que entrega lengthdir_y(largo,direccion) de la coordenada Y inicial. Aclarado eso, tratemos de encontrar una forma eficiente de crear personajes a base de esqueletos rotulados formados por sprites.

Cuando digo que hay que permitir el giro relativo de las partes respecto a sus "padres", me refiero a que los cuadrados puedan rotar individualmente, manteni?ndose unidos a las dam?s partes con r?tulas. El ejemplo que dejaste permite rotar las partes, s?lo que no se nota porque dejas fijos los ?ngulos (0, 0 y 90). Dejo tu ejemplo ligeramente modificado para rotar las partes con las flechas. Pero yo me refiero a que las rotaciones no sean en ?ngulos absolutos, sino relativos a sus "padres". Por ejemplo, si rotas el nodo 2 en 45?, que el nodo 3 rote autom?ticamente lo mismo; imagina un brazo que sostiene una vara inicialmente en forma vertical y rotas el antebrazo en torno al codo... la vara dejar? de estar vertical y tambi?n rotar? apuntando hacia t?, no seguir? vertical a menos que t? gires la mu?eca hacia adelante para mantener la vara vertical. Bueno, tu ejemplo hace justamente eso: deja siempre la vara en forma vertical.

Respecto a las timelines, s?, cada timeline guarda una animaci?n completa. En este momento no sabr?a c?mo ver si las timelines ocupan m?s espacio que los scripts pero si existe una diferencia, debe ser m?nima; adem?s, me parece mucho m?s ordenado guardar las animaciones en timelines en vez de varios scripts.

Voy a dejar el editable del programa que usaba antiguamente para crear animaciones de humanoides, s?lo para mostrar a lo que me refiero con rotaci?n relativa al "padre": las teclas para usarlo est?n en el game information.

Creo que ya nos alejamos bastante del tema de tu pregunta. Quiz? sea mejor tratar este tema en otra parte del foro.

SP_Christian, podr?as poner un ejemplo pr?ctico del uso de io_handle()? La definici?n que sale en el manual es bastante breve y aunque he tratado de experimentar con ella no veo que su uso tenga ning?n efecto.

Ya veo lo que tratas de hacer... mmmm... viendo algunas im?genes del juego Quantum Distortion de Raul_Omega (http://www.comunidadgm.org/index.php?action=blog;blog=136) y del juego en desarrollo de demon_hio Guerra de smillies (http://www.comunidadgm.org/index.php?topic=9421.0), me parece que intentaron lo mismo: marionetas articuladas para personajes, en vez de usar una infinidad de sprites para recrear las animaciones. De hecho, hace bastante tiempo vengo usando esta idea y la he aplicado a algunos juegos que hice, el ?ltimo de los cuales (Master of Mementors, en desarrollo) la usa en forma intensiva (http://www.comunidadgm.org/index.php?topic=2717.0).

Sobre lo que dices, estoy de acuerdo en que es una t?cnica extraordinariamente ?til y tiene resultados espectaculares; como dices, permite crear infinitas animaciones en base a rotaciones de las partes del esqueleto, todo con un pu?ado de sprites. Sin embargo, la desventaja est? en que he comprobado que el rendimiento en t?rminos de procesamiento puede decrecer bastante si hay muchas partes m?viles en juego y adem?s todo debe girar dentro del plano de la pantalla, a diferencia de los sprites animados donde puedes poner lo que te plazca y simular rotaciones fuera de ?ste.

Analizando tu ejemplo, me parece que funciona bien para simular rotaciones de cuerpo r?gido en torno a un punto, pero hay que tener cuidado del orden en que actualizas las posiciones y ?ngulos de las partes: si no partes por la base del esqueleto y luego por los "hijos", obtendr?s extra?os efectos de retardo (te lo digo por experiencia propia) as? que hay que tener cuidado con eso (me refiero, por ejemplo, a llamar al script sc_ctrlnodos() primero para la parte 5 en vez de la 1). Ahora bien, podr?a mejorarse notablemente el sistema si permitieras que cada parte gire en forma relativa a la parte de donde se sujeta: ah? tendr?as una enorme libertad para crear animaciones (y ah? es donde comienza a complicarse el asunto). No s? si alguna vez lo viste, pero en los tiempos en que exist?a GM Forge, expliqu? all? c?mo lo hac?a yo para lograr este efecto; de hecho invent? una aplicaci?n hecha en GM para crear modelos y animarlos usando esta idea. La animaci?n propiamente tal se basa en el uso masivo de timelines. Adjunto la idea que tengo y un ejemplo de c?mo lo hago hasta ahora, aunque s? que podr?a mejorarse bastante (en la demo, para simplicidad, no actualizo en el orden correcto cada parte y por eso se ve un peque?o desfase entre las partes rotuladas). En mi teor?a yo le llamo "amo" al elemento de donde se agarra una parte (t? le llamas padre[ i ], es lo mismo). Dejo los c?digos libres por si alguien se interesa en mejorarlos y que el conocimiento se disperse. Sobre la aplicaci?n, tengo que corregir algunos bugs as? que por ahora no la coloco (y nadie entender?a c?mo se usa, deber?a crear una gu?a  XD ).