Comunidad Game Maker

Comprueba antes de mover, si no hay ningún objeto sólido en la dirección de movimiento.


De todas formas, te recomendaría que intentaras aprender GML, es mucho mejor.

[gml]get_string_async()[/gml]
Creo que es lo que buscas.

No uses máscara de colisión precisa, eso causa muchos errores.
Muestra también una captura de las acciones DnD que usas.

Muestra las coordenadas de origen y máscara de colisión del sprite del personaje, y muestra también el código que usas para moverle.

[gml]
direction += 180;
[/gml]

XD.
[GML]
///Evento create del controlador
globalvar base, hecho;
base = ds_list_create(); //Lista para meter los identificadores en el orden correcto.
ds_list_add(base, 1, 2, 3, 4); //Se añaden los valores en ese orden.

hecho = ds_list_create(); //Lista para meter los identificadores de los bloques que se van activando
[/GML]
Ése era.

¿Y el código en donde declaras la variable hecho? (está en el controlador)

Aquí hay varios ejemplos:
https://manual-gamemakerstudio.000webhostapp.com/contenido/string_replace_all.html
https://manual-gamemakerstudio.000webhostapp.com/contenido/string_copy.html
https://manual-gamemakerstudio.000webhostapp.com/contenido/string_length.html
https://manual-gamemakerstudio.000webhostapp.com/contenido/string_count.html
https://manual-gamemakerstudio.000webhostapp.com/contenido/string_char_at.html

Y entre otras funciones.

Inténtalo así:
[GML]
///Toooodo este código va en el step del jugador; ni más ni menos. Elimina el código antíguo y pega éste.
var vel = 5;
var hor = keyboard_check(ord("D")) - keyboard_check(ord("A"));
var ver = keyboard_check(ord("S")) - keyboard_check(ord("W"));
repeat(vel)
{
    if(place_free(x + hor, y))
        x += hor;
    else break;
}
repeat(vel)
{
    if(place_free(x, y + ver))
        y += ver;
    else break;
}
//Codigo encargado de los patrones alarma
var wall = instance_place(x, y, oBlock); //Encontrar el bloque con quien colisiona
if(instance_exists(wall)) //Si hay colisión
{
    with(wall)
    {
        if(!colliding) //Si no ha cambiado antes (para evitar parpadeo)
        {
            if(image_index == 0) //Si no está activo
                image_index = 1; //Activarlo
            else if(image_index == 1) //y viceversa
                image_index = 0;
               
            colliding = true; //Evitar nueva colisión
        }
    }
}
wall = instance_place(x, y, oBlockPattern); //Encontrar el bloque con quien colisiona
if(instance_exists(wall)) //Si hay colisión
{
    with(wall)
    {
        if(!colliding) //Si no ha cambiado antes (para evitar parpadeo)
        {
            if(image_index == 0) //Si no está activo
            {
                image_index = 1; //Activarlo
                ds_list_add(hecho, orden); //Meter el identificador en la lista, en orden de llegada.
            }
            else if(image_index == 1) //y viceversa
                image_index = 0;
               
            colliding = true; //Evitar nueva colisión
        }
    }
}
[/GML]
[gml]
///Y tooodo éste en el step del controlador; ni más ni menos. Borra el código antíguo y pega éste.
var completed = true; //Comenzamos pensando que todos están completos
with(oBlock)
{
    if(image_index == 0) //Si se encuentra uno incompleto
        completed = false; //No se ha completado el puzzle
}
if(completed) //Si se ha completado el puzzle
    with(oBlock)
    {
        image_index = 2; //Ponerles la imagen verde
    }


//Otro puzzle
var completed = true; //Comenzamos pensando que todos están completos
with(oBlockPattern)
{
    if(image_index == 0) //Si se encuentra uno incompleto
        completed = false; //No se ha completado el puzzle
}
if(completed) //Si se ha completado el puzzle
{
    with(oBlockPattern)
    {
        image_index = 2; //Ponerles la imagen verde
    }
   
    var correcto = true; //Comenzamos pensando que se hizo correctamente
    for(var i = 0; i < ds_list_size(base); i++) //Recorremos toda la lista
    {
        var bs = base[| i]; //Obtenemos el valor i de la lista original
        var he = hecho[| i]; //Obtenemos el valor i en el orden de activación
        if(bs <> he) //Si los valores son diferentes (si se activaron en un orden incorrecto)
        {
            correcto = false; //No se ha completado;
            break; //Ya con eso no tenemos que recorrer más la lista
        }
    }
    if(correcto)
    {
        //Algo si el puzzle es correcto
    }
    else
    {
        //Supongo que se reiniciará el puzzle
        with(oBlockPattern)
        {
            image_index = 0; //Ponemos su estado a 'desactivado'
        }
        ds_list_clear(hecho); //Vaciamos la variable `hecho`
    }
}
[/gml]

Ah vale, que son dos puzzles distintos. En ese caso, lo más fácil sería dividir cada puzzle en un objeto separado: Uno que funcione hasta el punto de colisionar, y otro que compruebe el orden, algo como oBlock y oBlockPattern, con quienes ejecutarías sólo partes del código completo.

Si tienes la secuencia  {1, 2, 3, 4} con los bloques separados, se supone que los cinco (creo que son cinco) que están juntos tienen todos orden 0, por lo que el patrón original debe cambiar. Sería algo así:
[gml]
ds_list_add(base, 0, 0, 0, 0, 0, 1, 2, 3, 4); //Se añaden los valores en ese orden.
[/gml]
De esa manera, no importa el orden en el que se activen los cinco primeros, mientras se activen antes que cualquiera de los cuatro separados, y al activarse éstos últimos se haga en el orden correcto ( {1, 2, 3, 4} ), se completará el puzzle.

Por cierto, en el evento step del jugador sobra este código:
[gml]
//Codigos encargados del funcionamiento de los patrones
var completed = true; //Comenzamos pensando que todos están completos
with(oBlock)
{
    if(image_index == 0) //Si se encuentra uno incompleto
    {
        completed = false; //No se ha completado el puzzle
        break; //Ya con eso no tenemos que recorrer los bloques
    }
}
[/gml]
Déjalo sólo en el controlador, no en el jugador.

Hiciste algo muy distinto a lo que deberías haber hecho.

La variable orden debes declararla en el objeto oBlock, y debes modificar su valor bloque por bloque en el creation code de cada instancia para hacer la secuencia. Con creation code me refiero en el editor de rooms, pon varias instancias del bloque, dales clic derecho y selecciona creation code; ahí modifica la variable.

Además, lee bien en dónde deben ir los códigos, no necesitas de los llamados "obj_patron", todo funciona con los mismos objetos del ejemplo original.

[gml]
///Evento create del controlador
globalvar base, hecho;
base = ds_list_create(); //Lista para meter los identificadores en el orden correcto.
ds_list_add(base, 1, 2, 3, 4); //Se añaden los valores en ese orden.

hecho = ds_list_create(); //Lista para meter los identificadores de los bloques que se van activando
[/gml]
TODO este código va en un solo objeto, un controlador que se ejecuta primero. Si algún código debe ponerse en un evento u objeto distinto, suelo separarlos en bloques distintos.

PD: Qué feos mensajes, encierra los códigos dentro de las etiquetas [gml]código[/gml] para que se vean bien.

Lol, XD.
Lo siento, es el nombre de la variable or, ése es un operador booleano, no sé como se me pasó xDxD.
Sólo cambia el nombre de la variable, algo así:
[gml]         var bs = base[| i]; //Obtenemos el valor i de la lista original
        var he = hecho[| i]; //Obtenemos el valor i en el orden de activación
        if(bs <> he) //Si los valores son diferentes (si se activaron en un orden incorrecto)
        {
            correcto = false; //No se ha completado;
            break; //Ya con eso no tenemos que recorrer más la lista
        }
[/gml]
Por cierto, sólo por si acaso, el último bloque de código que escribí en mi mensaje anterior iría en el lugar del evento step del controlador.

Se me ocurre que podrías, como dice [user]bochaPastore[/user], definir una identificación a cada bloque, en el orden en el que deban activarse. Además, contar con dos arreglos en un controlador: El patrón original y correcto, y un arreglo vacío donde se meterán los ids en el orden en el que se activan.
[gml]
///Evento create del controlador
globalvar base, hecho;
base = ds_list_create(); //Lista para meter los identificadores en el orden correcto.
ds_list_add(base, 1, 2, 3, 4); //Se añaden los valores en ese orden.

hecho = ds_list_create(); //Lista para meter los identificadores de los bloques que se van activando
[/gml]
[gml]
///Evento create de cada bloque
orden = 1;
[/gml]
Para este objeto (bloque) deberás modificar el valor de orden en el creation code de cada instancia.

[gml]
///Evento step del jugador
//El código completo sería el mismo del adjunto de puzzles con colisiones
var wall = instance_place(x, y, oBlock); //Encontrar el bloque con quien colisiona
if(instance_exists(wall)) //Si hay colisión
{
    with(wall)
    {
        if(!colliding) //Si no ha cambiado antes (para evitar parpadeo)
        {
            if(image_index == 0) //Si no está activo
            {
                image_index = 1; //Activarlo
                ds_list_add(hecho, orden); //Meter el identificador en la lista, en orden de llegada.
            }
            else if(image_index == 1) //Y viceversa
                image_index = 0;
               
            colliding = true; //Evitar nueva colisión
        }
    }
}
[/gml]
La idea es, cuando se completen todos los bloques, se compruebe si la lista hecho es igual a la lista base: Si es así, entonces el puzzle se completó correctamente; si no, pues no.

De nuevo, asumo que aún usas el código que de dejé en el adjunto de puzzles con colisiones, la forma de comprobar si el orden es correcto sería algo así:
[gml]
var completed = true; //Comenzamos pensando que todos están completos
with(oBlock)
{
    if(image_index == 0) //Si se encuentra uno incompleto
    {
        completed = false; //No se ha completado el puzzle
        break; //Ya con eso no tenemos que recorrer los bloques
    }
}
if(completed) //Si se ha completado el puzzle
{
    with(oBlock)
    {
        image_index = 2; //Ponerles la imagen verde
    }
    /*A partir de aquí asumimos (como debería ser) que todos
      los bloques ya han sido activados, por lo que el tamaño
      de las listas `orden` y `hecho` tiene que ser el mismo.
    */
    var correcto = true; //Comenzamos pensando que se hizo correctamente
    for(var i = 0; i < ds_list_size(base); i++) //Recorremos toda la lista
    {
        var or = base[| i]; //Obtenemos el valor i de la lista original
        var he = hecho[| i]; //Obtenemos el valor i en el orden de activación
        if(or <> he) //Si los valores son diferentes (si se activaron en un orden incorrecto)
        {
            correcto = false; //No se ha completado;
            break; //Ya con eso no tenemos que recorrer más la lista
        }
    }
    if(correcto)
    {
        //Algo si el puzzle es correcto
    }
    else
    {
        //Supongo que se reiniciará el puzzle
        with(oBlock)
        {
            image_index = 0; //Ponemos su estado a 'desactivado'
        }
        ds_list_clear(hecho); //Vaciamos la variable `hecho`
    }
}
[/gml]
Estos código no los he probado, pero en teoría deberían funcionar. En todo caso, reporta si hay algún error.

Espero que si tienes problemas no digas que las listas son inútiles XD.

Son eso mismo, distintas formas de almacenar y organizar información. En ese enlace sólo encuentras referencia de una estructura, tendrás que mirar la documentación oficial para leer acerca de las seis estructuras de datos:
http://docs.yoyogames.com/source/dadiospice/002_reference/data%20structures/index.html