Comunidad Game Maker

Si está marcada, desactiva la opción "Interpolate colors between pixels", y establece el port al doble de la view, se puede hacer en el editor de rooms o con código (revisa las funciones view_*)

Escribe [gml]path_speed = 0;[/gml]

Al importar un sprite debes marcar la opción "Remove background".

Ahora viene la segunda parte; calcular el lanzamiento con precisión.

Propongo que el lanzamiento sea de 45 grados, así se simplifican algunos cálculos. Digamos que el alcance horizontal es de 20 espacios de 24 px (480 px en total) y lo representamos con la letra X mayúscula. Como el ángulo de lanzamiento es de 45 grados, se tiene la siguiente relación
v_i es la magnitud de la velocidad inicial, considerando las 2 dimensiones del movimiento.

¿Cómo establecemos los valores que faltan?
Podemos proponer el tiempo requerido para completar el vuelo y de ahí calcular la velocidad de lanzamiento y la gravedad, también podemos proponer la velocidad de lanzamiento y calcular la gravedad. Yo elijo proponer la gravedad y calcular la velocidad de lanzamiento, y después hacer muchas pruebas.

Hay un ejemplo adjunto a este mensaje. En la primera room, el personaje tiene un alcance horizontal X = 480 px que no cambia. Lo que se puede cambiar es el valor de la gravedad; notarás que al aumentar el valor de g el tiempo de vuelo se reduce. Si quieres un lanzamiento super rápido (con g alta) el código del ejemplo puede tener errores (prueba con g = 4), para evitarlo sería necesario usar la ecuación larga de la posición como función del tiempo. En este ejemplo es preferible usar valores de g menores que 1.

Veamos las partes importantes de obPlayer0
En el evento Create se declaran las variables
[gml]
///Sin movimiento al principio

vx = 0; //velocidad horizontal
vy = 0; //velocidad vertical
g = 0.2; //gravedad

X = 20*24; //alcance horizontal maximo (20 bloques * 24 px)
vi = sqrt( X*g ); //velocidad inicial (de lanzamiento)
[/gml]
vi se calcula despejando la ecuación anterior.
Al presionar el dígito 2 se inicia el lanzamiento
[gml]
///Iniciar lanzamiento

x = xstart; //pos. inicial
y = ystart;
vx = vi/sqrt(2); //= vi*sen(45 grados); vel. horizontal
vy = -vx; //velocidad vertical (magnitud igual a vx)
[/gml]
vx y vy tienen la misma magnitud porque el ángulo de despegue es de 45 grados.
En el evento Step se realiza el movimiento
[gml]
///Desplazamiento

x += vx;
y += vy + g/2;
vy += g;

//aterrizaje
if( y >= ystart )
{
    vx = 0;
    vy = 0;
    move_snap( 24, 24 );
}
[/gml]
La primera parte es igual a la que puse en el mensaje anterior, el aterrizaje ocurre al cruzar la línea horizontal que pasa por el punto de despegue y la función move_snap asegura la alineación.

Presiona el dígito 3 para cambiar de room. En la segunda habitación el lanzamiento depende de la barra de distancia. Aquí el cambio significativo es el código de lanzamiento
[gml]
///Iniciar lanzamiento

x = xstart; //pos. inicial
y = ystart;

X = round(20*barra/100)*24; //alcance horizontal
vi = sqrt( X*g );

vx = vi/sqrt(2); //= vi*sen(45 grados); vel. horizontal
vy = -vx; //velocidad vertical (magnitud igual a vx)
[/gml]
el alcance X se determina con el valor de la barra (con la función round se obtiene un número entero de bloques, que se multiplica por 24 px).

Toma en cuenta que los puntos de lanzamiento y de aterrizaje están a la misma altura, si quieres que la resortera (punto de lanzamiento) esté sobre el piso hay que agregar otros códigos para tener un aterrizaje exacto.

Aquí va un análisis del problema.
Se me ocurren dos formas ligeramente diferentes para realizar el movimiento parabólico:

*La primera es usar el método que se ve frecuentemente en los tutoriales de GM, en el que se hace una aproximación del movimiento de un objeto real. Primero se definen las siguientes variables
[gml]
vx = //velocidad horizontal
vy = //velocidad vertical
g  = //gravedad
[/gml]
y el desplazamiento se realiza de esta forma (en el evento Step)
[gml]
vy += g; //efecto de la gravedad
x += vx; //desplazamiento
y += vy;
[/gml]
así se obtiene una trayectoria parabólica, no obstante, los significados de velocidad y aceleración son un poco diferentes a los de un objeto real.

*La segunda forma es definir la trayectoria del proyectil como se estudia en física clásica. Usaremos este método para no tener que pensar tanto, pues ya existen muchas fórmulas para calcular todas las características del lanzamiento, y hay mucha información en Internet (aunque prefiero los libros de texto para estudiar estos temas, por lo general la información de Internet no es muy clara).

Para un objeto con aceleración constante, la posición se define como una función del tiempo
la expresión anterior, en forma vectorial, puede definir el movimiento de un objeto en un espacio de cualquier número de dimensiones. En este caso el movimiento es en 2 dimensiones, y como la aceleración (gravedad) se aplica sólo en dirección vertical, se puede representar como la superposición de 2 movimientos independientes: uno en dirección horizontal con velocidad constante, y otro en dirección vertical que es afectado por la aceleración de la gravedad. Se modifica la expresión anterior para definir el movimiento en y
y_i es la posición inicial (en pixeles)
v_yi es la velocidad vertical inicial( en px/step)
g es la gravedad (en px/step²)
(la unidades sólo son para tener un planteamiento formal)

Al derivar la ecuación anterior se obtiene la expresión de la velocidad como función del tiempo

Con esto ya podemos hacer que el objeto se mueva en una trayectoria parabólica, sin embargo, las expresiones anteriores se pueden simplificar si consideramos que la posición se actualiza en unidades de tiempo (steps) y hacemos que la posición inicial sea la del step anterior
entonces el código quedaría así (en el evento Step)
[gml]
x += vx;
y += vy +g/2;
vy += g;
[/gml]

¿El botón se debe mantener encendido?

No había notado ese efecto en GM8, seguramente es lo mismo que se explica aquí: https://www.yoyogames.com/tech_blog/8
Esta es una herramienta para editar los mapas de tiles: http://gmc.yoyogames.com/index.php?showtopic=546371

Si hay funciones que no se encuentran en GMS (revisa la sección Obsolete Functions), y hay otras nuevas que sólo se encuentran en GMS.

Tal vez la detección de colisiones se debe optimizar, y desactivar las instancias que están fuera de la view también ayuda.

Las funciones gamepad detectan los mandos que usan xinput, el nuevo protocolo de Microsoft usado en mandos de Xbox, sin embargo es posible usar un emulador: http://www.x360ce.com/default.aspx
http://www.comunidadgm.org/preguntas-y-respuestas/compatibilidad-con-gamepad/

El problema no es la lista, ya que la lista por sí misma no dibuja las piezas, sólo sirve para mantener el orden de profundidad y no tener profundidades repetidas. Para limpiar la lista se usa la función ds_list_clear, también se podría destruir al regresar al menú con la función ds_list_destroy.

Parece que en realidad se están creando más piezas de las necesarias, ¿has modificado el evento Create del controlador?

Distribuir las piezas alrededor del marco es fácil, mañana muestro un ejemplo.

Si, he leído varias veces que usan la application_surface para mostrar pantallas de pausa, pero nunca lo he intentado, no estoy seguro de cómo hacerlo.

Cada vez que se carga una imagen externa se crea una nueva página de textura, y esos son de los recursos que más memoria ocupan, usar la función draw_texture_flush() al quitar la pausa ayudaría a liberar memoria.

Bien, pensé en la variable imagen para facilitar el cambio de sprite, aunque veo que es mejor que se convierta en una variable global.
Para no modificar tanto los objetos que ya tenemos, se me ocurre crear una habitación que sea el menú principal (o un menú de selección de imagen). Al seleccionar una imagen se debe asignar la variable (ahora global) e ir a la habitación que contiene el objeto controlador:
[gml]
global.imagen = spr_x;
room_goto( rmPuzzle );
[/gml]
En el objeto controlador se deberían borrar las líneas donde se definen las variables que ya fueron definidas por el otro objeto, y agregar la palabra global. donde se necesite. También se podrían asignar otras variables como la separación entre objetos y la cantidad de piezas en horizontal y vertical. El diseño del menú dependerá del tipo de menú.

En código para soltar la pieza se pueden meter los sonidos y disparar otras acciones como las que mencionas. Para el sonido sólo se necesita la función audio_play_sound. El mensaje puede ser una instancia que es creada por la pieza y que se desvanece poco a poco, tal vez quieras que el mensaje mostrado dependa de otras variables como la puntuación, el tiempo, combos, etc., en ese caso se podría necesitar pasar algunos datos al controlador y que éste se encargue de decidir qué mensaje mostrar; por ejemplo para detectar un combo o cadena (varias piezas correctas seguidas) se puede iniciar una alarma en el controlador, si se coloca otra pieza correcta entes de que acabe la cuenta regresiva se incrementa la variable combo. Para regresar la pieza a su posición anterior se puede usar un algoritmo parecido al que se usó para mezclar, es más, se puede usar el mismo código, sólo hay que cambiar el estado de la pieza a MEZCLA.
Quedaría más o menos así:
[gml]
///Soltar pieza

if( ESTADO = ACTIVO ) //si esta activa
if( global.seleccion = id ) //y esta seleccionada
{
    global.seleccion = noone; //seleccionar nada
   
    //si esta cerca de la posicion correcta
    if( point_distance(x,y,xstart,ystart) < 64 )
    {
        x = xstart; //plop
        y = ystart;
        ESTADO = CALZA; //cambiar estado
        global.calzadas += 1; //incrementar contador
        audio_play_sound( snPlop, 1, false ); //sonido plop
       
        if( obControl.alarm[0] > 0 ) //si la alrma continua
            global.combo += 1; //la nueva pieza incrementa el combo
        else //si la alarma ha terminado
            global.combo = 0; //restablecer variable
        obControl.alarm[0] = room_speed; //alarma de 1 segundo
    }
    else //la pieza NO esta en la posicion correcta
    {
        audio_play_sound( snError, 1, false ); //sonido error
        ESTADO = MEZCLA; //regresar a la pos. anterior
    }
}
[/gml]
Debo decir que hacer que la pieza regrese a la posición anterior no me agrada, porque en rompecabezas grandes a veces es necesario poner piezas en posiciones aproximadas para completar varias secciones de forma independiente.

Ya he pensado en formas de cortar las imágenes dentro del juego, pero aún no me decido, ya que todas tiene sus ventajas e inconvenientes.

La posición del rompecabezas se cambia en el evento Create de obControl, en donde dice:
[gml]
with instance_create( i*dx+96, j*dy+96, obPieza )
[/gml]
Los números (96,96) son la posición inicial de la pieza que está arriba a la izquierda.
Saludos.

Encontré un bug, cuando se suelta el botón del ratón y el puntero está fuera de la máscara de colisión, la pieza no se suelta, para arreglarlo cambia el evento Left Released por Global Left Released.