Eventos y ciclo de vida en gameplay con Unreal Engine

Cómo se dispara la lógica en gameplay

En Unreal Engine, la lógica de gameplay se ejecuta cuando ocurre algo: el inicio de un Actor, cada frame, una interacción, un temporizador, o un evento emitido por otro sistema. Entender el “ciclo de vida” de un Actor y elegir el disparador correcto te ayuda a crear Blueprints más eficientes, legibles y fáciles de mantener.

BeginPlay: el punto de arranque

Event BeginPlay se ejecuta una vez cuando el Actor (o componente) entra en juego: al comenzar el nivel, al spawnearse dinámicamente o al activarse. Es ideal para inicializar estados, enlazar eventos (bindings), arrancar timers y preparar referencias.

• Úsalo para: inicialización, suscripciones a Event Dispatchers, arranque de secuencias temporizadas.
• Evita: lógica que deba repetirse continuamente (para eso hay eventos o timers).

Tick: ejecución por frame

Event Tick se ejecuta cada frame y recibe Delta Seconds (tiempo transcurrido desde el frame anterior). Es útil cuando necesitas actualización continua y suave, por ejemplo: interpolaciones manuales, seguimiento de objetivos, o cálculos que dependen del frame.

• Úsalo para: movimiento/rotación continua que no puedas resolver con componentes o timelines, cálculos que deben reaccionar cada frame.
• Riesgo: si lo usas para “preguntar” cosas constantemente (polling), puedes degradar rendimiento y complicar el Blueprint.

Eventos personalizados: lógica bajo demanda

Un Custom Event es un punto de entrada que tú defines para ejecutar una secuencia cuando lo llames. Sirve para nombrar acciones (“Activar”, “Reiniciar”, “AplicarDaño”) y reutilizarlas desde distintos lugares sin duplicar nodos.

• Ventaja: mejora la lectura y permite disparar lógica solo cuando hace falta.
• Tip: si el evento debe recibir datos, agrega inputs (por ejemplo, Int, Float, Actor).

Elegir entre ejecución por evento vs por frame

Pautas para evitar abuso de Tick

• Prefiere eventos cuando la lógica depende de algo que “pasa” (entrar en un trigger, pulsar una tecla, cambiar un estado).
• Usa timers para repetición: en vez de comprobar “¿ya pasaron 2 segundos?” en Tick, programa un timer.
• Activa/Desactiva Tick si solo lo necesitas en ciertos momentos: Set Actor Tick Enabled (o en componentes, Set Component Tick Enabled).
• Reduce frecuencia cuando sea aceptable: ajusta Tick Interval (por ejemplo, 0.2s) para lógica no crítica.
• Evita búsquedas costosas por frame (por ejemplo, Get All Actors Of Class en Tick). Cachea referencias en BeginPlay.

Desacoplar sistemas con Event Dispatchers

Un Event Dispatcher es un evento “emitido” por un Blueprint para que otros se suscriban (bind) y reaccionen sin que el emisor conozca a los receptores. Esto reduce dependencias directas y facilita reutilizar Actors.

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

Cuándo usar un Dispatcher

• Un Actor necesita avisar “algo ocurrió” (Activado, Muerto, Completado, CambióEstado).
• Varios Blueprints podrían reaccionar (UI, sonido, puertas, partículas).
• No quieres referencias directas del emisor hacia cada receptor.

Custom Event vs Event Dispatcher

• Custom Event: lo llamas directamente (necesitas una referencia al objeto que lo contiene).
• Event Dispatcher: otros se suscriben; el emisor solo “broadcast” y no sabe quién escucha.

Práctica guiada: Actor activable con secuencia temporizada y evento “Activado”

Vas a crear un Actor que: (1) se activa al iniciar (BeginPlay), (2) ejecuta una secuencia de acciones temporizadas (sin Tick), y (3) expone un Event Dispatcher Activado para que otros Blueprints reaccionen.

Objetivo de la práctica

• Usar BeginPlay como disparador inicial.
• Reemplazar Tick por timers para acciones en el tiempo.
• Emitir un evento desacoplado con Event Dispatcher.

Paso 1: Crear el Blueprint del Actor

1. Crea un Blueprint Class de tipo Actor llamado BP_ActivadorSecuencia.
2. Agrega un componente visual simple (por ejemplo, Static Mesh) para verlo en escena.

Paso 2: Definir variables de configuración

En BP_ActivadorSecuencia, crea estas variables (Edit Anywhere para poder ajustar en el editor):

• AutoActivar (Boolean) = true
• DelayAntesDeActivar (Float) = 0.5
• DuracionSecuencia (Float) = 3.0
• IntervaloPulso (Float) = 0.25

También crea una variable interna:

• EstaActivado (Boolean) = false

Paso 3: Crear el Event Dispatcher “Activado”

1. En el panel de My Blueprint, crea un Event Dispatcher llamado OnActivado.
2. Opcional: agrega un parámetro Actor Activador (tipo Actor) para que los oyentes sepan quién emitió el evento.

Paso 4: Crear Custom Events para estructurar la lógica

Crea estos Custom Events:

• Activar
• IniciarSecuencia
• Pulso
• FinalizarSecuencia

La idea es que cada evento tenga una responsabilidad clara, evitando un grafo gigante conectado a BeginPlay.

Paso 5: BeginPlay → activar con delay (sin Tick)

En el Event Graph:

1. Desde Event BeginPlay, usa un Branch con AutoActivar.
2. Si es true, usa Set Timer by Event con tiempo DelayAntesDeActivar (One Shot).
3. En el pin del evento del timer, llama al Custom Event Activar.

Esto evita usar Tick para “esperar” tiempo.

Paso 6: Implementar “Activar” y emitir el Dispatcher

En el Custom Event Activar:

1. Usa Branch para evitar doble activación: condición EstaActivado == false.
2. Si pasa, setea EstaActivado = true.
3. Llama a OnActivado usando Call / Broadcast (si agregaste parámetro, pasa Self).
4. Llama a IniciarSecuencia.

Paso 7: Secuencia temporizada con timers (pulsos) y final

En IniciarSecuencia:

1. Arranca un timer repetitivo para Pulso con Set Timer by Event, Time = IntervaloPulso, Looping = true.
2. Guarda el Timer Handle en una variable (por ejemplo, HandlePulso) para poder detenerlo.
3. Arranca otro timer one-shot para FinalizarSecuencia con Time = DuracionSecuencia.

En Pulso (ejemplo de acción):

• Cambia un material, alterna visibilidad, o ajusta intensidad de una luz (si tienes un componente Light).
• Si no tienes luz, puedes hacer una animación simple con Set Relative Scale 3D alternando entre dos escalas.

En FinalizarSecuencia:

1. Detén el timer repetitivo usando Clear and Invalidate Timer by Handle con HandlePulso.
2. Ejecuta una acción final (por ejemplo, dejar el mesh en un color/escala final).

Paso 8: Hacer que otros Blueprints reaccionen al evento “OnActivado”

Ahora crea un segundo Blueprint que escuche el evento. Por ejemplo, BP_ReceptorActivacion (Actor) con una luz o un mesh.

1. En BP_ReceptorActivacion, crea una variable ReferenciaActivador de tipo BP_ActivadorSecuencia (Object Reference) y márcala como Edit Instance Only para asignarla desde el nivel.
2. En Event BeginPlay del receptor:
   • Valida la referencia con Is Valid.
   • Desde la referencia, usa Bind Event to OnActivado.
   • Crea el evento de binding (Unreal te permite generar un Custom Event conectado) y dentro ejecuta la reacción: encender una luz, reproducir un sonido, abrir una puerta, etc.

Con esto, el activador no necesita conocer al receptor. Puedes tener 1 activador y múltiples receptores escuchando el mismo dispatcher.

Checklist de buenas prácticas para este patrón

• BeginPlay: úsalo para inicializar y arrancar timers/bindings.
• Custom Events: divide la lógica en acciones con nombre (Activar, IniciarSecuencia, FinalizarSecuencia).
• Event Dispatchers: notifica cambios importantes a otros sistemas sin referencias cruzadas innecesarias.
• Timers: para acciones temporizadas o repetitivas, reemplaza Tick.
• Control de estado: usa flags como EstaActivado para evitar ejecuciones duplicadas.