Comunidad Game Maker

Mira estos temas:
http://webcache.googleusercontent.com/search?q=cache:2IwQaR-5SoMJ:www.comunidadgm.org/preguntas-y-respuestas/niveles-y-experiencia/
http://webcache.googleusercontent.com/search?q=cache:l0zY40ezqfMJ:www.comunidadgm.org/preguntas-y-respuestas/pasar-de-nivel-matando-cierta-cantidad-de-enemigos/

Sí, usar draw_sprite dentro de unos bucles es buena opción. Si decides usar tiles, puedes crear cada paso de la animación en una capa y después usar tile_layer_hide y tile_layer_show.

Aunque se usen instancias, el rendimiento no baja demasiado, ya que lo único que hacen es dibujar un sprite. También se pueden ahorrar unos mili segundos de procesamiento desactivando las instancias que están fuera de la vista (con las funciones instance_activate_* e instance_deactivate_*).

El error indica que las variables no se han definido como arrays, ¿has creado la cuadricula previamente?

Adjunto la prueba que hice.

¿Un balde de pintura como la herramienta "fill area" del editor de sprites de GM?

Una opción sería dibujar en la surface y al mismo tiempo actualizar una matriz con la misma información. Esto sería fácil siempre y cuando se dibujen pixeles simples o rectángulos de un sólo color, pero si se dibuja con draw_line u otras primitivas sería muy complicado.

Una mejor alternativa sería copiar la surface a un buffer (con buffer_get_surface), así es mucho más rápido leer la información de un pixel, el problema es manejar el buffer como matriz. Para facilitar el manejo de los datos, se podría copiar el buffer a una matriz (array 2D o ds_grid), el inconveniente es que la memoria utilizada se duplicaría: el buffer usaría la misma cantidad de memoria que la surface (4 bytes por pixel), y la matriz ocuparía el doble de memoria que la surface (8 bytes por pixel). Aún así, es mejor que usar surface_getpixel.

Yo me quedé en infierno, me pareció demasiado difícil, ya no pude avanzar.

¿Es esto lo que buscas? (Adjunto)

Autor: Clamud, basado en algunos scripts de gmlscripts.com
Versión: :GM8:
Descripción: Crea una copia del sprite indicado, pero los pixeles no transparentes se hacen blancos.

sprite_blanco( spr );
[gml]
///sprite_blanco( spr );
//Copia el sprite indicado, en blanco
//Devuelve el indice del nuevo sprite creado
//NOTA: el blend_mode se hace normal

var s, w, h, xo, yo, sf, i, s2;

s = argument0; //sprite
w = sprite_get_width(s); //anchura
h = sprite_get_height(s); //altura
n = sprite_get_number(s); //numero de sub-imagenes
xo = sprite_get_xoffset(s); //origen x
yo = sprite_get_yoffset(s); //origen y

sf = surface_create(w,h); //superficie
surface_set_target(sf); //establecer como lienzo
draw_set_blend_mode_ext( bm_zero, bm_src_alpha ); //copiar alfa

for( i=0; i<n; i+=1 )
{
    draw_clear( c_white ); //llenar de color blanco
    draw_sprite( s,i, xo,yo ); //copiar alfa
    if( i == 0 ) s2 = sprite_create_from_surface( sf, 0,0, w,h, false,false, xo,yo );
    else sprite_add_from_surface( s2,sf, 0,0, w,h, false,false );
}

draw_set_blend_mode( bm_normal );
surface_reset_target();
surface_free( sf );

return s2;
[/gml]

La variable image_blend no se puede usar para dibujar un sprite en blanco, porque en realidad la variable no guarda un color que se combina con el sprite, más bien es un multiplicador de color. Por ejemplo, si un sprite tiene pixels negros, cuyo valor de color es cero, aunque la variable image_blend sea blanco no modificará el color de esos pixels, porque cualquier valor multiplicado por cero es igual a cero. Sin embargo, existen otras alternativas para lograr ese efecto.

Un método es crear una copia del sprite en blanco, y dibujar ese sprite encima del sprite original. Éste es el método menos eficiente, porque se crea una nueva página de textura para almacenar el sprite.

Otro método es invertir los colores de un área rectangular, después dibujar el sprite en negro (con image_blend=c_black o draw_sprite_ext) y volver a invertir los colores del área rectangular. Para ello se usa este script: http://www.gmlscripts.com/script/draw_rectangle_inverted

Los dos métodos anteriores se muestran en un archivo adjunto.

El mejor método en GMS es usar un shader, como el shader #6 que aparece en la demo de la imagen:

No se si entendí bien tu explicación; tienes un objeto que es el personaje principal y cuando toca a un objeto cubo, ese cubo imita los movimientos del personaje.
Podrías crear una variable al inicio del juego
[gml]
global.imitador = noone; //no hay imitador
[/gml]
En el evento colisión, del personaje con un cubo, se asigna el imitador
[gml]
global.imitador = other.id;
[/gml]
En el objeto cubo podrías poner el mismo código de movimiento del personaje, pero con una condición previa
[gml]
if( id == global.imitador ) //si yo soy el imitador
{
    //ejecutar codigo de movimiento
}
[/gml]

Siempre se toma la última configuración, por eso se debe configurar y dibujar de inmediato. Mira el ejemplo adjunto.

Lo que falta es dibujar el texto justo después de definir sus características:
[gml]
draw_set_color(c_white);
draw_set_halign(fa_center);
draw_set_valign(fa_middle);
draw_set_font(fnt_texto1);

draw_text( x,y, texto );
[/gml]
Y el código debe estar en el evento Draw.

Esta parece ser la referencia más completa en internet sobre el tema: http://www.extentofthejam.com/pseudo/
Y aquí hicieron una implementación en javascript: http://codeincomplete.com/posts/2012/6/22/javascript_racer/

Tal vez esto te sirva: http://www.comunidadgm.org/desarrollo-de-scripts/obtener-posicion-de-adjuntado/

El movimiento se debe hacer en 3D y se deben convertir esas coordenadas a 2D. El piso no se debería crear con objetos; la detección del piso se hace revisando la coordenada z.

Adjunto un simple ejemplo, camina con WASD y salta con ESPACIO.

Hice unas modificaciones a los scripts, que permiten poner el origen del sprite en cualquier lugar.

En el primer script he modificado el incremento (ahora es 1), para no dejar espacios vacíos dentro de los arrays.
[gml]
///crear_cuadricula( size );
size = argument0;
for( i=0; i<sprite_width/size;  i+=1 )
for( j=0; j<sprite_height/size; j+=1 )
{
    px[i,j] = i*size;
    py[i,j] = j*size;
}
[/gml]

En el segundo script, el argumento se puede usar para indicar la velocidad de desplazamiento de los pixeles, y la suma aleatoria está en otra posición para que los pixeles del centro no queden alineados.
[gml]
///dibujar_efecto( vel );
var z; //variable auxiliar
for( i=0; i<sprite_width/size;  i+=1 )
for( j=0; j<sprite_height/size; j+=1 )
{
    draw_sprite_part( sprite_index, image_index,
        i*size, j*size, size, size,
        x - sprite_xoffset + px[i,j],
        y - sprite_yoffset + py[i,j] );
       
    if( argument0 > 0 ){
        z = point_direction( px[i,j], py[i,j], sprite_width/2, sprite_height/2 );
        px[i,j] -= lengthdir_x( argument0, z ) + random_range(-1,1);
        py[i,j] -= lengthdir_y( argument0, z ) + random_range(-1,1);
    }
}
[/gml]