Controlando la Velocidad de Sprites en GameMaker Studio 2

Los sprites son, sin lugar a dudas, el corazón visual de cualquier proyecto en GameMaker Studio 2. Son la esencia que da vida a tus personajes, los detalles que construyen tus escenarios y las piezas clave que conforman tus sistemas de colisión y elementos interactivos. Si bien GameMaker nos ofrece un potente editor para crearlos y modificarlos, el verdadero poder reside en la capacidad de manipularlos programáticamente durante la ejecución de nuestro juego. Entender cómo interactuar con ellos a través de código es fundamental para llevar nuestras creaciones a un nivel superior, permitiéndonos controlar no solo su apariencia, sino también su comportamiento y, crucialmente, su velocidad.

Desde la creación de complejas animaciones para tus objetos hasta la ambientación de tus escenarios con fondos dinámicos y la construcción de intrincados tilesets, los sprites son el pilar. Aunque ahora no contamos con un recurso específico para fondos (backgrounds) y se ha introducido el concepto de tilesets, la realidad es que los sprites siguen siendo la base de todo. No hay objeción a esta lógica; es un enfoque con sentido común que centraliza la gestión visual.

En este artículo, profundizaremos en cómo GameMaker Studio 2 nos permite manipular y gestionar los sprites desde el código, centrándonos en una de las propiedades más importantes para las animaciones: su velocidad. Veremos las variables y funciones esenciales que te permitirán tener un control absoluto sobre el ritmo visual de tu juego.

Diferencia Crucial: Recurso del Sprite vs. Sprite de la Instancia

Antes de sumergirnos en el control de la velocidad, es vital entender una distinción fundamental en GameMaker Studio 2: la diferencia entre el recurso del sprite y el sprite asignado a una instancia específica. Esta distinción es clave para evitar confusiones y aplicar las funciones y variables correctas en cada situación.

Imagina que tienes un recurso de sprite llamado spr_player. Este recurso tiene una anchura y altura definidas en el editor de GameMaker. Ahora, cuando creas un objeto y le asignas spr_player, y luego colocas una instancia de ese objeto en tu room, esa instancia tiene su propia representación de spr_player.

La variable sprite_width, por ejemplo, se usa en el contexto de una instancia. Si a esa instancia le aplicas un escalado (por ejemplo, image_xscale = 2;), su sprite_width cambiará para reflejar el nuevo tamaño. Es decir, sprite_width te da la anchura actual del sprite de esa instancia específica, después de cualquier transformación aplicada.

En contraste, la función sprite_get_width() se aplica al recurso del sprite. Para usarla, debes especificar el recurso entre paréntesis, como sprite_get_width(spr_player). Esta función siempre te devolverá la anchura original del recurso spr_player, independientemente de si alguna instancia lo ha escalado o no. Esto es útil si necesitas conocer las dimensiones base de un sprite sin tener una instancia de él en la room o sin preocuparte por las transformaciones que haya podido sufrir.

GameMaker Studio 2 distingue esto mediante variables de instancia (que comienzan con `image_` o `sprite_` y se refieren a la instancia actual) y funciones genéricas (que suelen comenzar con `sprite_get_` y requieren el nombre del recurso). Es una manera clara de diferenciar cuándo te refieres a las propiedades base de un sprite y cuándo a las propiedades de una instancia en particular.

Un apunte importante sobre sprite_width y sprite_height: son variables de solo lectura. Esto significa que no puedes modificarlas directamente para cambiar el tamaño del sprite de una instancia. Si deseas escalar visualmente un sprite, debes usar las variables image_xscale e image_yscale. Por ejemplo, para duplicar el tamaño de tu sprite, usarías image_xscale = 2; y image_yscale = 2;.

Variables Clave para el Control de Sprites en Instancias

Cuando trabajas con objetos en tu juego, la manipulación de sus sprites se realiza a través de un conjunto de variables de instancia. Estas variables te permiten alterar la apariencia y el comportamiento del sprite asignado a ese objeto en tiempo real.

• sprite_index: Esta es quizás la variable más fundamental. Define qué recurso de sprite está siendo utilizado por la instancia en un momento dado. Cambiar sprite_index te permite alternar entre diferentes animaciones o apariencias para tu objeto, por ejemplo, cambiar de un sprite de "caminar" a uno de "saltar" o "atacar".
• image_index: Representa el fotograma actual de la animación del sprite. Si un sprite tiene 5 fotogramas (numerados del 0 al 4), image_index te dirá qué fotograma se está mostrando. Puedes manipularlo directamente para forzar un fotograma específico, aunque lo más común es que GameMaker lo actualice automáticamente basándose en image_speed.
• image_xscale y image_yscale: Controlan el escalado horizontal y vertical del sprite de la instancia. Un valor de 1 es el tamaño original. Un valor de 2 duplicaría el tamaño, mientras que 0.5 lo reduciría a la mitad. Valores negativos pueden voltear el sprite horizontal o verticalmente, lo cual es muy útil para personajes que se mueven en diferentes direcciones.
• image_angle: Permite rotar el sprite de la instancia en grados (0-360). Un valor de 0 es la orientación original, 90 es girado 90 grados a la derecha, etc.
• image_alpha: Controla la transparencia del sprite, con valores de 0 (completamente transparente/invisible) a 1 (completamente opaco). Útil para efectos de desvanecimiento o para simular objetos semitransparentes.
• image_blend: Permite teñir el sprite con un color específico. Se utiliza una constante de color (por ejemplo, c_red, c_blue) o un valor hexadecimal. Esto es excelente para efectos de daño, estados alterados o simplemente para dar variedad visual a tus sprites sin crear nuevos recursos.

Controlando la Velocidad de un Sprite: La Clave de la Animación Dinámica

Llegamos al punto central de nuestro artículo: ¿cómo cambiamos la velocidad de un sprite en GameMaker Studio 2? La respuesta principal reside en la variable de instancia image_speed.

image_speed es una variable de instancia que determina la velocidad a la que GameMaker avanza a través de los fotogramas de la animación del sprite asignado a esa instancia. Su valor por defecto es 1, lo que significa que la animación se reproduce a la velocidad definida en el recurso del sprite. Al modificar image_speed, podemos acelerar, ralentizar o incluso pausar la animación de un sprite.

¿Cómo usar image_speed?

Es muy sencillo. Simplemente asigna un valor numérico a image_speed:

• image_speed = 1;: Velocidad normal (tal como está definida en el editor de sprites).
• image_speed = 0.5;: La animación se reproduce a la mitad de la velocidad normal, haciendo que se vea más lenta.
• image_speed = 2;: La animación se reproduce al doble de la velocidad normal, haciendo que se vea más rápida.
• image_speed = 0;: Pausa la animación del sprite en el fotograma actual. No avanzará hasta que image_speed sea un valor diferente de 0.
• image_speed = -1;: La animación se reproduce hacia atrás a velocidad normal.

Puedes cambiar image_speed en cualquier momento en tu código. Por ejemplo, en el evento Step de un objeto:

// Si el jugador está corriendo, acelera la animación if (hspeed != 0) { image_speed = 1.5; // Corre 1.5 veces más rápido } else { image_speed = 0.5; // Ralentiza la animación cuando está quieto }

O para pausar una animación cuando un evento ocurre:

// En un evento de colisión o cuando la vida llega a 0 if (vida <= 0) { image_speed = 0; // Pausa la animación del personaje moribundo image_index = 3; // Asegura que se muestre un fotograma específico (ej. "muerte") }

Es importante recordar que image_speed solo afecta la instancia específica en la que se modifica. Si tienes múltiples instancias del mismo objeto usando el mismo recurso de sprite, cada una puede tener su propia image_speed, permitiendo animaciones independientes para cada una.

Recuperando la Velocidad Original del Sprite

En el editor de sprites de GameMaker Studio 2, puedes definir una velocidad de animación predeterminada para el recurso. Esta velocidad puede ser en "Frames per second" (fotogramas por segundo) o "Frames per game frame" (fotogramas por fotograma del juego). Para recuperar este valor original desde el código, utilizas la función sprite_get_speed().

sprite_get_speed(sprite_index) te devolverá el valor de velocidad que configuraste en el editor para el sprite actual de la instancia. Esto es útil si has modificado image_speed y quieres volver al valor predeterminado del recurso:

// Volver a la velocidad original definida en el recurso del sprite image_speed = sprite_get_speed(sprite_index);

La elección entre "Frames per second" y "Frames per game frame" es crucial y afecta cómo se interpreta la velocidad. Con Frames per second (FPS), el sprite intentará reproducir el número de fotogramas por segundo que especifiques, independientemente de la velocidad de fotogramas de tu juego (game_speed). Por ejemplo, si un sprite está configurado a 15 FPS, intentará mostrar 15 fotogramas por cada segundo real. Si tu juego corre a 60 FPS, GameMaker ajustará el avance de los fotogramas del sprite para mantener esa tasa.

Con Frames per game frame (FPGF), el sprite avanza un número de fotogramas por cada fotograma del juego. Si lo configuras a 0.5 FPGF, el sprite avanzará medio fotograma por cada fotograma que el juego renderice. Esto significa que la velocidad de la animación estará directamente ligada a la velocidad de fotogramas de tu juego. Si tu juego va a 30 FPS, la animación será más lenta que si va a 60 FPS con la misma configuración FPGF.

Para saber qué tipo de velocidad está configurada en el recurso de un sprite, puedes usar la función sprite_get_speed_type(). Esta función devolverá una de dos constantes:

• spritespeed_framespersecond
• spritespeed_framespergameframe

var _speed_type = sprite_get_speed_type(spr_player_run); if (_speed_type == spritespeed_framespersecond) { show_debug_message("La velocidad del sprite se define por segundos."); } else { show_debug_message("La velocidad del sprite se define por fotogramas de juego."); }

Obteniendo Más Información del Sprite (Funciones sprite_get_*)

Además de la velocidad, GameMaker ofrece una suite de funciones para obtener información estática del recurso de un sprite, es decir, sus propiedades tal como fueron definidas en el editor. Estas funciones son de solo lectura y se refieren al recurso, no a una instancia específica.

• sprite_get_name(sprite_resource): Devuelve el nombre del sprite como una cadena de texto (string). Esto puede ser útil para depuración o para lógica basada en patrones de nombres. Sin embargo, no puedes usar el string devuelto directamente para referirte al sprite en asignaciones como sprite_index = "spr_player";. Para eso, usarías asset_get_index("spr_player"). Un truco útil es usar esta función combinada con string_pos() para verificar si un sprite pertenece a una categoría basada en su nombre (ej. if string_pos("blue", sprite_get_name(sprite_index)) > 0).
• sprite_get_number(sprite_resource): Devuelve el número total de imágenes (fotogramas) que contiene el sprite. Recuerda que los fotogramas se indexan desde 0 hasta (número_total - 1).
• sprite_get_width(sprite_resource): Devuelve la anchura original del sprite en píxeles, tal como se definió en el editor.
• sprite_get_height(sprite_resource): Devuelve la altura original del sprite en píxeles.
• sprite_get_xoffset(sprite_resource): Devuelve la posición X del origen (punto de anclaje) del sprite en relación con su esquina superior izquierda. Si el origen está en el centro, este valor será la mitad de la anchura.
• sprite_get_yoffset(sprite_resource): Devuelve la posición Y del origen del sprite en relación con su esquina superior izquierda.

Los valores de sprite_get_xoffset y sprite_get_yoffset son cruciales para cálculos precisos de posición, especialmente si el origen de tu sprite no está en la esquina superior izquierda. Por ejemplo, para asegurar que un objeto con un origen centrado no salga de los límites de la room, podrías hacer lo siguiente:

if (x - sprite_get_xoffset(sprite_index) < 0) { x = sprite_get_xoffset(sprite_index); } if (y - sprite_get_yoffset(sprite_index) < 0) { y = sprite_get_yoffset(sprite_index); } // Y para el lado derecho/inferior if (x + (sprite_get_width(sprite_index) - sprite_get_xoffset(sprite_index)) > room_width) { x = room_width - (sprite_get_width(sprite_index) - sprite_get_xoffset(sprite_index)); } if (y + (sprite_get_height(sprite_index) - sprite_get_yoffset(sprite_index)) > room_height) { y = room_height - (sprite_get_height(sprite_index) - sprite_get_yoffset(sprite_index)); }

Funciones de la Máscara de Colisión (Bounding Box)

La máscara de colisión de un sprite define el área que GameMaker usa para detectar colisiones. Aunque a menudo coincide con el tamaño del sprite, puede ser diferente para optimización o para ajustar la precisión de las colisiones. Estas funciones te permiten obtener las coordenadas de esta máscara:

• sprite_get_bbox_left(sprite_resource): Devuelve la coordenada X del borde izquierdo de la máscara de colisión del sprite.
• sprite_get_bbox_right(sprite_resource): Devuelve la coordenada X del borde derecho de la máscara de colisión del sprite.
• sprite_get_bbox_top(sprite_resource): Devuelve la coordenada Y del borde superior de la máscara de colisión del sprite.
• sprite_get_bbox_bottom(sprite_resource): Devuelve la coordenada Y del borde inferior de la máscara de colisión del sprite.

Estos valores son relativos al origen del sprite. Por ejemplo, si el origen es (0,0) (esquina superior izquierda), y el sprite tiene una máscara de 10x10 píxeles, sprite_get_bbox_left sería 0, sprite_get_bbox_right sería 9, etc.

Tabla Comparativa: Control de Velocidad del Sprite

Preguntas Frecuentes (FAQ)

¿Cómo pauso la animación de un sprite?

Para pausar la animación de un sprite en un fotograma específico, simplemente establece su image_speed a 0. Si también quieres asegurar que se muestre un fotograma en particular, puedes combinarlo con image_index:

image_speed = 0; // Pausa la animación image_index = 0; // Muestra el primer fotograma (o el que desees)

¿Puedo tener diferentes velocidades para diferentes objetos que usan el mismo sprite?

¡Absolutamente! La variable image_speed es una variable de instancia. Esto significa que cada objeto individual (instancia) en tu juego puede tener su propio valor de image_speed, incluso si todos están utilizando el mismo recurso de sprite. Por ejemplo, puedes tener dos personajes idénticos, pero uno corre el doble de rápido que el otro simplemente ajustando su image_speed individualmente.

¿Qué diferencia hay entre la velocidad que configuro en el editor del sprite y image_speed?

La velocidad configurada en el editor es la velocidad por defecto o base del recurso del sprite. Es el ritmo al que se reproducirá la animación si image_speed se deja en su valor predeterminado de 1. La variable image_speed, por otro lado, es un multiplicador que aplicas a esa velocidad base en cada instancia. Si la velocidad del editor es de 10 FPS y image_speed es 0.5, la animación se reproducirá a 5 FPS para esa instancia. Si image_speed es 2, se reproducirá a 20 FPS.

¿Cómo hago que un sprite se anime más rápido o más lento?

Para que un sprite se anime más rápido, establece su image_speed a un valor mayor que 1 (ej., 1.5, 2, 3). Para que se anime más lento, establece image_speed a un valor entre 0 y 1 (ej., 0.8, 0.5, 0.2).

¿Es mejor usar Frames per second o Frames per game frame para la velocidad del sprite?

Depende de tus necesidades. Si quieres que la animación se reproduzca a una velocidad constante sin importar la tasa de fotogramas de tu juego (por ejemplo, si quieres que una animación de explosión dure exactamente 1 segundo), usa Frames per second. Si quieres que la velocidad de la animación esté ligada a la velocidad de tu juego (por ejemplo, si el juego se ralentiza, la animación también lo haga, lo cual es útil para efectos de "bullet time"), entonces Frames per game frame podría ser más adecuado.

Conclusión

La manipulación de los sprites en GameMaker Studio 2 va mucho más allá de simplemente asignarlos a un objeto. Entender cómo controlar su velocidad a través de la variable image_speed, cómo obtener información estática con las funciones sprite_get_* y la crucial distinción entre el recurso del sprite y la instancia, te brinda un poder inmenso para crear experiencias visuales dinámicas y atractivas.

Experimentar con estas variables y funciones te permitirá implementar efectos como cámara lenta, aceleración de personajes, pausas en animaciones complejas y mucho más. La flexibilidad que ofrece GameMaker Studio 2 para el control de sprites es una de sus mayores fortalezas, permitiéndote dar vida a tus ideas con un nivel de detalle y fluidez impresionantes. ¡Ahora tienes las herramientas para hacer que tus sprites no solo se vean bien, sino que también se muevan a tu propio ritmo!

Si quieres conocer otros artículos parecidos a Controlando la Velocidad de Sprites en GameMaker Studio 2 puedes visitar la categoría Entrenamiento.