GameMaker: Eventos, Operadores y Licencia

Adentrarse en el mundo del desarrollo de videojuegos con GameMaker es una experiencia fascinante. Para construir juegos robustos y predecibles, es fundamental comprender cómo funciona el motor internamente. Dos pilares esenciales para cualquier desarrollador en GameMaker son el conocimiento del orden de eventos y el manejo adecuado de los operadores, además de tener claridad sobre los aspectos de licenciamiento.

Este artículo profundiza en estos temas, proporcionando una guía clara basada en la documentación y la información disponible. Entender el flujo de los eventos te permitirá controlar con precisión cuándo ocurre cada acción en tu juego, mientras que conocer los operadores te dará las herramientas para escribir código eficiente y legible. Abordaremos también la pregunta común sobre si GameMaker es gratuito, basándonos en la información proporcionada.

El Orden de Eventos en GameMaker

Uno de los aspectos más importantes al programar en GameMaker es saber en qué momento se ejecutan las diferentes piezas de código. GameMaker procesa una serie de eventos en un orden específico durante cada paso (o frame) del juego, así como al inicio de una sala. Aunque el orden exacto de ejecución de *todas* las partes internas puede variar ligeramente entre versiones o plataformas, hay secuencias clave que son consistentes y fiables.

Es crucial entender que, aunque el orden de los eventos es predecible, el orden en que las instancias ejecutan un evento particular *no* está garantizado dentro de ese evento específico, a menos que se especifique lo contrario (como en el orden de creación o el orden de las capas de dibujo). Si necesitas que una instancia ejecute su código de un evento *después* de otra, a menudo deberás mover ese código a un evento posterior en la secuencia general.

Al Entrar a una Sala

Cuando tu juego entra por primera vez en una sala, se desencadena una serie de eventos en un orden muy particular. Este orden es vital para la configuración inicial del juego y de las instancias presentes en esa sala:

• Todas las instancias se crean una tras otra. Este proceso sigue el Orden de Creación de Instancia definido en el Editor de Sala. Por cada instancia creada, ocurre lo siguiente:
  • La instancia es creada (equivalente a llamar a instance_create_depth o instance_create_layer).
  • Las Variables de Objeto de la instancia se inicializan a sus valores por defecto.
  • El Evento Create se ejecuta para la instancia.
  • El Código de Creación de Instancia asociado a esa instancia específica en el Editor de Sala se ejecuta, si existe.
• El Evento Game Start se activa una única vez en la primera sala del juego para todas las instancias colocadas desde el Editor de Sala. Ten en cuenta que llamar a game_restart() también activa este evento.
• El Código de Creación de Sala definido en el Editor de Sala se ejecuta. Este es un código único para la sala que se ejecuta solo al entrar en ella por primera vez (o después de un reinicio).
• El Evento Room Start de todas las instancias se dispara. Este evento pertenece a la categoría "Other" y se ejecutará para todas las instancias presentes, sean persistentes o no.

Nota importante: Puedes influir en el orden en que se crean instancias específicas dentro del Editor de Sala ajustando su posición en la lista de propiedades de la capa de instancias.

Cada Paso/Frame del Juego

Una vez que la sala está configurada, GameMaker entra en un ciclo constante de pasos (frames). Durante cada paso, una secuencia fija de eventos se ejecuta para procesar la lógica del juego, las actualizaciones y el dibujo. El orden de estos eventos es fundamental:

• Evento Begin Step: Se ejecuta al principio de cada paso. Es útil para código que debe ocurrir antes de que las variables de posición (como `x`, `y`, `xprevious`, `yprevious`) se actualicen con el movimiento.
• Timelines y Time Sources: Los Time Sources (incluyendo Timelines, aunque son un tipo más antiguo) se actualizan o "tickean" en este punto. Esto incluye callbacks y Time Sources hijos.
• Alarmas: Los eventos de Alarma cuyo contador ha llegado a cero se ejecutan aquí.
• Evento Step: Este es el evento principal donde ocurre la mayor parte de la lógica del juego. Durante este evento:
  • Todas las instancias se mueven a sus nuevas posiciones basándose en sus velocidades (`hspeed`, `vspeed`).
  • Se verifican las colisiones.
  • Si se detecta una colisión y una de las instancias involucradas es sólida, ambas instancias son movidas de vuelta a sus posiciones de frame anterior (si no son sólidas, permanecen en la nueva posición) y se llaman sus eventos de colisión. (Nota: En Modo de Compatibilidad de Colisiones, el comportamiento de retroceso puede variar ligeramente).
• Evento End Step: Se ejecuta al final de cada paso, después de que se ha completado la lógica principal y las colisiones. Es útil para código que debe ocurrir después de todas las actualizaciones de posición y colisión, pero antes del dibujo.

Eventos de Dibujo (Draw Events)

Después de que todos los eventos de Step (Begin, Step, End) se han completado en un paso, GameMaker ejecuta los eventos de dibujo para todas las instancias. El orden en que las instancias se dibujan *dentro* de un evento de dibujo particular depende del orden de las capas: las instancias en capas de mayor profundidad se dibujan primero (apareciendo visualmente debajo), y las de menor profundidad se dibujan al final (apareciendo visualmente encima).

La secuencia de los eventos de dibujo es la siguiente:

• Evento Pre-Draw: Se ejecuta antes de que comience el proceso de dibujo normal.
• Evento Draw Begin: Se ejecuta justo antes del Evento Draw principal.
• Evento Draw: Aquí es donde normalmente dibujas la apariencia de tu instancia. Si no colocas código en este evento, GameMaker dibujará el sprite asignado a la instancia por defecto (si tiene uno).
• Evento Draw End: Se ejecuta después del Evento Draw principal.
• Evento Post-Draw: Se ejecuta después de que se han completado todos los eventos de dibujo normales.
• Evento Draw GUI Begin: Se ejecuta al inicio de la fase de dibujo de la interfaz gráfica de usuario (GUI). La GUI se dibuja en una capa separada que normalmente no se ve afectada por la vista de la cámara del juego.
• Evento Draw GUI: Aquí dibujas elementos de la interfaz de usuario que permanecen fijos en la pantalla, como puntuaciones, barras de vida, etc.
• Evento Draw GUI End: Se ejecuta después de que se ha completado el dibujo de la GUI.

Comprender esta secuencia te permite decidir en qué evento colocar tu código para lograr los efectos visuales y la lógica deseada en el momento preciso.

Operadores Clave en GameMaker Language (GML)

Los operadores son símbolos que realizan operaciones sobre valores y variables. Conocer los operadores más comunes y cómo utilizarlos correctamente es esencial para escribir código funcional y mantenible en GML.

Asignación vs. Comparación: `=` y `==`

Una fuente común de confusión para los principiantes es la diferencia entre el operador de asignación y el operador de comparación de igualdad:

• El operador `=` se utiliza para asignación. Asigna un valor a una variable. Por ejemplo: velocidad = 5; o nombre = "Jugador";.
• El operador `==` se utiliza para comparación. Comprueba si dos valores o el contenido de dos variables son iguales y devuelve `true` o `false`. Por ejemplo: if (puntuacion == 100) { // hacer algo }.

Aunque en versiones antiguas de GameMaker se permitía usar `=` para comparación en algunos contextos (y podrías verlo en código legado), la buena práctica estándar y recomendada es usar siempre `==` para comparar igualdad y `=` solo para asignación. Esto mejora la claridad de tu código y evita posibles errores o comportamientos inesperados.

Incremento y Decremento: `++` y `--`

Los operadores `++` y `--` son atajos convenientes para añadir o restar uno (1) a una variable. Su uso es muy común en bucles y contadores.

• `++`: Incrementa el valor de la variable en 1.
• `--`: Decrementa el valor de la variable en 1.

Existe una diferencia sutil pero importante entre colocar el operador antes (pre-incremento/decremento) o después (post-incremento/decremento) de la variable, especialmente cuando se utiliza dentro de una expresión más compleja:

• `++variable` (pre-incremento): Incrementa la variable y *luego* devuelve el nuevo valor incrementado.
• `variable++` (post-incremento): Incrementa la variable pero devuelve el valor que tenía *antes* de ser incrementada.

Considera este ejemplo para ilustrar la diferencia:

var a = 1;
show_debug_message(string(a++)); // Muestra 1 (a se incrementa a 2 después)
show_debug_message(string(a)); // Muestra 2
show_debug_message(string(++a)); // Muestra 3 (a se incrementa a 3 antes)

El resultado de la salida de depuración sería 1, 2 y 3. Es fundamental entender esto para evitar errores lógicos, especialmente en bucles o asignaciones complejas.

Otros Operadores Comunes

GML ofrece una amplia gama de operadores para diversas operaciones:

• Aritméticos: `+`, `-`, `*`, `/`, `div` (división entera), `mod` o `%` (módulo).
• Lógicos: `&&` (AND), `||` (OR), `^^` (XOR), `!` (NOT).
• Comparación: `<`, `<=`, `!=` (distinto de), `>`, `>=`.
• Bitwise: `|` (OR bit a bit), `&` (AND bit a bit), `^` (XOR bit a bit), `<<` (desplazamiento a la izquierda), `>>` (desplazamiento a la derecha).

Es vital entender la precedencia de los operadores, aunque siempre es una buena práctica usar paréntesis () para agrupar expresiones y asegurar que las operaciones se realicen en el orden deseado, mejorando la claridad y la consistencia de tu código entre diferentes plataformas.

Agrupación con Paréntesis y Llaves

La agrupación no es un operador en sí, pero el uso de paréntesis () para expresiones y llaves {} para bloques de código/sentencias es crucial para la claridad y la consistencia.

• Paréntesis (): Utiliza paréntesis para forzar un orden específico de evaluación en expresiones complejas, como en matemáticas c = a * (b + d); o lógica if ((a == b) || (c != d)) { ... }. Esto elimina la ambigüedad sobre la precedencia de operadores y asegura que tu código se comporte igual en todas las plataformas.
• Llaves {}: Utiliza llaves para agrupar múltiples sentencias de código que pertenecen a un bloque, como dentro de una declaración if, un for, while, o la definición de un script o función. Por ejemplo: if (condicion) { sentencia1; sentencia2; }. Aunque GML a veces permite una sola sentencia sin llaves, usarlas siempre es una buena práctica que previene errores al añadir código posteriormente y mejora la legibilidad.

¿GameMaker es Realmente Gratis? Aspectos de Licencia

La pregunta sobre el costo de GameMaker y si es posible usarlo de forma gratuita es muy común. Basándonos en la información proporcionada, el texto se centra principalmente en la transición de licencias para usuarios que ya habían pagado suscripciones antiguas (como Creator o Indie) a los nuevos modelos de licenciamiento.

Según esta información:

• Las suscripciones antiguas (Creator, Indie) no se renovarán al expirar.
• Los usuarios con suscripciones expiradas tienen la opción de comprar una licencia Profesional de pago único o suscribirse a Enterprise.
• Se aplican descuentos en la licencia Profesional basados en la cantidad que el usuario pagó previamente en suscripciones.
• Usuarios que cumplieron ciertos criterios de pago (por ejemplo, un año en el nivel Indie antiguo o dos meses en Enterprise) recibirán una licencia Profesional gratuita.

La información proporcionada describe un escenario de migración para usuarios existentes hacia modelos de pago (licencias Profesional o Enterprise), ofreciendo compensaciones por pagos anteriores. No especifica si existe una opción completamente gratuita disponible para nuevos usuarios que nunca han tenido una licencia o suscripción pagada. Por lo tanto, según este texto, el enfoque está en modelos de pago para el uso continuado o la adquisición por parte de usuarios con historial de pago.

Preguntas Frecuentes (FAQ)

Aquí respondemos algunas preguntas comunes basadas en los temas tratados:

P: ¿Cuál es el orden exacto de los eventos en cada paso del juego?
R: El orden de los eventos durante un paso es Begin Step, (Timelines/Time Sources, Alarms), Step, End Step, y luego la secuencia de eventos de Dibujo (Pre-Draw, Draw Begin, Draw, Draw, End, Post-Draw, Draw GUI Begin, Draw GUI, Draw GUI End). Sin embargo, el orden en que las instancias individuales ejecutan su código dentro de uno de estos eventos *no* está garantizado (excepto por el orden de creación al inicio de la sala y el orden de las capas para el dibujo).

P: ¿Por qué se considera "mala práctica" usar `=` para comparar en GameMaker?
R: Usar `=` para comparar es un legado de versiones antiguas. La buena práctica moderna y recomendada es usar `==` para comparaciones de igualdad y reservar `=` estrictamente para la asignación de valores. Esto hace que tu código sea más claro, más fácil de leer y entender, y reduce la probabilidad de errores.

P: ¿Hay alguna diferencia entre `miVariable++` y `++miVariable`?
R: Sí, la diferencia está en el valor que devuelve la expresión. `miVariable++` (post-incremento) incrementa la variable *después* de que su valor actual es utilizado en la expresión. `++miVariable` (pre-incremento) incrementa la variable *antes* de que su nuevo valor sea utilizado. Esto es especialmente relevante cuando se usan dentro de una asignación o una llamada a función.

P: Según la información proporcionada, ¿GameMaker es gratis?
R: La información proporcionada se centra en la transición de usuarios existentes con suscripciones pagadas a nuevos modelos de licencia de pago (Profesional y Enterprise), ofreciendo descuentos basados en pagos previos. No afirma que exista una opción completamente gratuita para nuevos usuarios que nunca han pagado. El texto describe modelos de pago con beneficios para usuarios recurrentes.

Conclusión

Dominar el orden de eventos es fundamental para estructurar la lógica de tu juego de manera efectiva, asegurando que las acciones ocurran en el momento adecuado. Un uso correcto de operadores como `=` para la asignación y `==` para la comparación es una buena práctica que mejora enormemente la calidad y legibilidad de tu código. Aunque los modelos de licencia de GameMaker evolucionan, la información indica un enfoque en licencias de pago (Profesional, Enterprise) para el uso completo, con consideraciones especiales para los usuarios que han apoyado la plataforma previamente. Al comprender estos conceptos clave, estás mejor equipado para desarrollar tus proyectos en GameMaker con confianza y eficiencia.

Si quieres conocer otros artículos parecidos a GameMaker: Eventos, Operadores y Licencia puedes visitar la categoría Maquillaje.