1. Epic GamesDeveloper
  3. 2. Reproducción de efectos visuales en los jugadores

2. Reproducción de efectos visuales en los jugadores

Obtén más información sobre cómo añadir efectos visuales personalizados al dispositivo Generador de efectos visuales.

2. Reproducción de efectos visuales en los jugadores

En esta sección, se mostrará cómo añadir VFX (efectos visuales) personalizados de latidos de corazón a tu juego que delaten la ubicación de una utilería inmóvil.

Cuando los jugadores del equipo de utilería están inactivos durante demasiado tiempo, se reproduce un efecto visual de latido en ese jugador, y se le notifica al equipo de cazadores. Este efecto visual se registra en cada jugador del equipo de utilería cuando se generan en el juego.

Podrás utilizar dispositivos Generadores de efectos visuales junto con Verse para implementar la función de latido. Esto incluye:

  • Activación de los efectos visuales.

  • Teletransportación del Generador de efectos visuales a los jugadores.

  • Creación de una IU que muestre a los miembros del equipo de utilería cuánto tiempo les queda para moverse antes de que suene el latido.

En este tutorial, se incluyen fragmentos de Verse que muestran cómo ejecutar las mecánicas de juego necesarias en este juego. Sigue los pasos que aparecen a continuación y copia la secuencia completa de comandos en el paso 6 de este tutorial.

Antes de empezar

Carpeta de recursos

Es una buena práctica mantener los recursos y los dispositivos organizados en carpetas para facilitar su localización. Puedes agrupar los dispositivos por finalidad, ubicación, tipo o lo que desees.

Puedes mover los recursos colocados a las carpetas y a los actores que crees.

En el gif anterior, el Generador de efectos visuales se arrastra a la carpeta HeartBeatVFX del equipo de utilería con fines organizativos. También puedes hacer clic derecho y seleccionar Mover a para elegir la carpeta a la que quieres mover el recurso.

Dispositivos utilizados:

Dispositivo Generador de efectos visuales

Generador de efectos visuales

Crea un Generador de efectos visuales para cada jugador. Cuando un jugador necesite efectos visuales, se teletransportará a la ubicación del jugador. Cuando ya no los necesite, se ocultará hasta que los vuelva a necesitar.

Los Generadores de VFX de esta plantilla utilizan los efectos visuales de Niagara para crear recursos personalizados que se muestran durante el juego. Los recursos de efectos visuales que se utilizan en este tutorial se configuran para mostrar un latido del corazón que delate a los jugadores inmóviles en el equipo de utilería. Este efecto visual aparecerá sobre las utilerías que permanezcan estáticas durante, al menos, 15 segundos.

Puedes visitar la sección Efectos visuales de nuestra documentación para ver muchos tutoriales sobre cómo crear efectos visuales de latidos. Luego, podrás utilizar el latido personalizado que creaste con el Generador de efectos visuales.

Puedes intentar esto cuando coloques un Generador de efectos visuales. En el panel de detalles, selecciona tu efecto personalizado en el menú desplegable Efecto visual personalizado. Asegúrate de habilitar Anulación del efecto visual personalizado para que el efecto visual seleccionado aparezca en el visor.

Selecciona tus propios efectos visuales personalizados del Generador de efectos visuales.

Desde aquí, puedes personalizar aún más tu efecto en el panel de detalles, mediante la adición de color y la decisión de cuándo se reproducirá el efecto visual y quién lo verá.

Coloca este dispositivo en un lugar que no lo vean los jugadores y configura las Opciones de usuario para que coincidan con la siguiente tabla. A continuación, copia y pega este dispositivo para que coincida con la cantidad de jugadores que se permite en tu juego.

Generador de efectos visuales modificado
Opción Valor Explicación
Efecto visual personalizado HeartBeatVFX Define la partícula personalizada que se usará en lugar de elegir una de la lista de prestablecidos.
Anulación de efecto visual personalizado Determina si se usan efectos especiales de desarrollador.  
Habilitado durante fase Solo durante la partida Determina las fases de la partida en las que se habilitará el dispositivo. Un generador de efectos visuales habilitado reproducirá el efecto de partículas establecido.

Reproducción de efectos de latido en una ubicación

Sigue estos pasos para mover el dispositivo Generador de efectos visuales en Verse para reproducir y detener el efecto de latido en los jugadores del equipo de utilería.

  1. Crea un archivo de Verse nuevo en tu proyecto llamado heartbeat.verse. Este no será un dispositivo de Verse, así que puedes crearlo como un archivo de Verse vacío.

  2. Primero, haz doble clic en el archivo de Verse que creaste para añadir las siguientes Rutas de Verse para importar.

     using { /Fortnite.com/Characters }
 using { /Fortnite.com/Devices }
 using { /Fortnite.com/UI }
 using { /UnrealEngine.com/Temporary/SpatialMath }
 using { /UnrealEngine.com/Temporary/Diagnostics }
 using { /UnrealEngine.com/Temporary/UI }
 using { /Verse.org/Colors }
 using { /Verse.org/Simulation }

  3. Con este código, se crea una clase llamada heartbeat_vfx en heartbeat.verse. La clase heartbeat_vfx contiene una estructura de datos para realizar un seguimiento de los objetos vfx_spawner_device por jugador, así como las funciones para establecer el efecto visual en una posición o restablecerlo.

     log_heart_beat := class(log_channel){}
     # Estos mensajes se utilizan para notificar a un agente de utilería con un mensaje (u ocultarlo) cuando deben moverse para evitar que su latido se haga visible.
 HeartBeatWarningMessage<localizes>(Time:int):mensaje = "Latido en {Time} segundos. ¡Muévete!"
 HeartBeatWarningClear<localizes>:message = ""
     # Esta clase expone las propiedades editables para el latido al dispositivo prop_hunt de Verse.
 heart_beat := class<concrete>():
     Logger:log = log{Channel:=log_heart_beat}
     @editable # La cantidad de segundos antes de que un agente de utilería deba moverse para que el latido revele su posición.
     MoveTime:float = 15.0
     @editable # Los segundos restantes antes de que aparezca el aviso de latido. No debe ser > que HeartBeatTimer.
     WarningTime:float = 5.0
     @editable # Una matriz de dispositivos de efectos visuales de latido. Existe uno por jugador.
     AgentVFX:[]heartbeat_vfx = array{}
     @editable # El dispositivo Reproductor de radio que se utiliza para reproducir los efectos de sonido (SFX) de los latidos del corazón.
     SFXPlayer:radio_device = radio_device{}
     # Este mapa asocia una IU para mostrar el aviso de latido a cada agente de utilería.
     var WarningUI:[agent]heartbeat_warning_ui = map{}
     # Realiza un seguimiento de cuántos jugadores tienen un latido activo para poder gestionar el dispositivo de SFX.
     var NumberOfHeartBeats:int = 0
     # Establece una IU de latido para este agente.
     SetUpUI(PropAgent:agent):void =
         if:
             not WarningUI[PropAgent]
             AsPlayer := player[PropAgent]
             PlayerUI := GetPlayerUI[AsPlayer]
         then:
             UIData:heartbeat_warning_ui = heartbeat_warning_ui{}
             UIData.CreateCanvas()
             PlayerUI.AddWidget(UIData.Canvas, player_ui_slot{ZOrder := 1})
             if (set WarningUI[PropAgent] = UIData) {}
     # Activa los efectos visuales y los efectos de sonido de latido para el reproductor especificado.
     Enable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
         if:
             # Obtén el personaje, que se utiliza para encontrar la posición del agente de utilería en la escena.
             Character := PropAgent.GetFortCharacter[]
         then:
             # Establece la posición del efecto visual del latido del corazón a la posición del agente de utilería.
             HeartBeatVFXData.Activate(Character.GetTransform())
             # Aumenta la cuenta de latidos, y si este es el primer latido que se reproduce, necesitamos reproducir el audio para que comience.
             set NumberOfHeartBeats += 1
             if (NumberOfHeartBeats = 1) then SFXPlayer.Play()
             # Registra el agente de utilería al dispositivo Reproductor de audio para que el audio del latido se reproduzca desde esa posición.
             SFXPlayer.Register(PropAgent)
         else:
             Logger.Print("No se encontró el personaje, índice o HeartBeatVFXData. No se puede empezar a reproducir el latido.")
     # Borra los VFX y SFX de latido para el agente de utilería especificado.
     Disable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
         Logger.Print("Se está deshabilitando el latido.")
         # Desactiva los VFX.
         HeartBeatVFXData.Deactivate()
         # Cancela el registro del agente de utilería del dispositivo Reproductor de audio para que el audio del latido se detenga.
         SFXPlayer.Unregister(PropAgent)
         # Disminuye el contador de latidos. Este contador nunca debe ser inferior a 0.
         set NumberOfHeartBeats -= 1
         if (NumberOfHeartBeats < 0) then set NumberOfHeartBeats = 0
     # Borra todos los efectos visuales y los efectos de sonido de latido para todos los agentes de utilería.
     DisableAll():void =
         Logger.Print("Se están deshabilitando todos los latidos.")
         # Itera a través de todos los efectos visuales y muévelos a 0,0,0.
         for (HeartBeatVFXDevice : AgentVFX):
             HeartBeatVFXDevice.Deactivate()
         # Cancela el registro de todos los reproductores de audio de latido.
         SFXPlayer.UnregisterAll()
         # Reinicia el contador de latidos a 0
         set NumberOfHeartBeats = 0
     # La clase heartbeat_warning_ui contiene una estructura de datos para rastrear el lienzo de IU y un text_block por jugador, así como la función para crear un nuevo lienzo de IU de aviso de latido.
 heartbeat_warning_ui := class:
     var Canvas:canvas = canvas{}
     var Text:text_block = text_block{}
     # Crea el lienzo de la IU para el mensaje de aviso.
     CreateCanvas():void =
         set Text = text_block{DefaultTextColor := NamedColors.White, DefaultShadowColor := NamedColors.Black}
         set Canvas = canvas:
             Slots := array:
                 canvas_slot:
                     Anchors := anchors{Minimum := vector2{X := 0.5, Y := 0.75}, Maximum := vector2{X := 0.5, Y := 0.75}}
                     Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
                     Alignment := vector2{X := 0.5, Y := 1.0}
                     SizeToContent := true
                     Widget := Text

  4. Con este código, se crea un método Activate() en la clase heartbeat_vfx que toma un argumento de transformación y mueve el dispositivo Generador de efectos visuales a esa transform.

     # La clase heartbeat_vfx contiene una estructura de datos para realizar un seguimiento de la raíz del VFX y de los objetos vfx_spawner_device por jugador, así como las funciones para establecer el VFX en una posición o restablecerlo.
 heartbeat_vfx := class<concrete>:
     @editable # El dispositivo de efectos visuales para cada latido.
     VFXDevice:vfx_spawner_device = vfx_spawner_device{}
     # Esta compensación se utiliza para posicionar el latido por encima de la cabeza de un agente de utilería.
     HeartBeatVFXOffset:vector3 = vector3{X := 0.0, Y := 0.0, Z := 110.0}
     # Establece la posición del efecto visual del latido del corazón y, luego, habilita el efecto visual.
     Activate(Transform:transform):void =
         VFXPosition := Transform.Translation + HeartBeatVFXOffset
         if (VFXDevice.TeleportTo[VFXPosition, Transform.Rotation]):
             VFXDevice.Enable()

  5. Con este código, se crea un método Deactivate() en la clase heartbeat_vfx que deshabilita el dispositivo Generador de efectos visuales y, por lo tanto, oculta los visuales del latido del corazón.

     # La clase heartbeat_vfx contiene una estructura de datos para realizar un seguimiento de la raíz del VFX y de los objetos vfx_spawner_device por jugador, así como las funciones para establecer el VFX en una posición o restablecerlo.
 heartbeat_vfx := class<concrete>:
     @editable # El dispositivo de efectos visuales para cada latido.
     VFXDevice:vfx_spawner_device = vfx_spawner_device{}
     # Esta compensación se utiliza para posicionar el latido por encima de la cabeza de un agente de utilería.
     HeartBeatVFXOffset:vector3 = vector3{X := 0.0, Y := 0.0, Z := 110.0}
     # Establece la posición del efecto visual del latido del corazón y, luego, habilita el efecto visual.
     Activate(Transform:transform):void =
         VFXPosition := Transform.Translation + HeartBeatVFXOffset
         if (VFXDevice.TeleportTo[VFXPosition, Transform.Rotation]):
             VFXDevice.Enable()
            # Deshabilita los efectos visuales y oculta los visuales de latidos del corazón.
     Deactivate():void =
         VFXDevice.Disable()

Mostrar aviso de latido a un jugador

Sigue estos pasos para configurar una interfaz de usuario personalizada con un bloque de texto que mostrará el mensaje de aviso de latidos. Consulta Interfaces de usuario en el juego para obtener más información sobre la creación de una IU personalizada y otros componentes de la IU en Verse.

  1. Las dos constantes siguientes controlan el texto que se mostrará a los jugadores del equipo de utilería en diferentes momentos del juego.

    • La constante HeartBeatWarningMessage es una función que toma un int y devuelve el tipo message. Este tipo se utiliza en elementos de la IU porque se puede localizar. Este es el texto que los jugadores verán cuando necesiten moverse para evitar que el efecto del latido del corazón revele su posición.

    • La constante HeartBeatWarningClear es un message vacío que se mostrará para que los jugadores dejen de ver el mensaje de aviso.

     # Estos mensajes se utilizan para notificar a un agente de utilería con un mensaje (u ocultarlo) cuando necesitan moverse a fin de evitar que su latido se haga visible.
 HeartBeatWarningMessage<localizes>(Time:int):mensaje = "Latido en {Time} segundos. ¡Muévete!"
 HeartBeatWarningClear<localizes>:message = ""

  2. Crea una nueva clase llamada heartbeat_warning_ui en heartbeat.verse. La clase heartbeat_warning_ui contiene una estructura de datos para rastrear el lienzo de IU y un text_block por jugador, así como la función para crear un nuevo lienzo de IU de aviso de latido.

     # La clase heartbeat_warning_ui contiene una estructura de datos para rastrear el lienzo de IU y un text_block por jugador, así como la función para crear un nuevo lienzo de IU de aviso de latido.
 heartbeat_warning_ui := class:
     var Canvas:canvas = canvas{}
     var Text:text_block = text_block{}
     # Crea el lienzo de la IU para el mensaje de aviso.
     CreateCanvas():void =
         set Text = text_block{DefaultTextColor := NamedColors.White, DefaultShadowColor := NamedColors.Black}
         set Canvas = canvas:
             Slots := array:
                 canvas_slot:
                     Anchors := anchors{Minimum := vector2{X := 0.5, Y := 0.75}, Maximum := vector2{X := 0.5, Y := 0.75}}
                     Offsets := margin{Top := 0.0, Left := 0.0, Right := 0.0, Bottom := 0.0}
                     Alignment := vector2{X := 0.5, Y := 1.0}
                     SizeToContent := true
                     Widget := Text

Gestión de los efectos de latido

Sigue estos pasos para crear el gestor de latidos.

  1. Con el código siguiente, se crea una clase llamada heart_beat en heartbeat.verse. Esta clase expone las propiedades editables para el latido al dispositivo prop_hunt y gestiona los efectos de latido.

     log_heart_beat := class(log_channel){}
 # Esta clase expone las propiedades editables para el latido al dispositivo prop_hunt.
 heart_beat := class<concrete>():
     Logger:log = log{Channel:=log_heart_beat}
         @editable 
         MoveTime:float = 15.0
  2. Con este código, se añaden las siguientes propiedades editables a la clase heart_beat.

    1. Con este código, se controlan los segundos antes de que un agente de utilería deba moverse antes de que el efecto de latido revele su posición.

           @editable 
     MoveTime:float = 15.0

      1. Con este código, se controlan los segundos que quedan antes de que aparezcan palabras en la pantalla para avisar a un miembro del equipo de utilería e indicarle que se mueva antes de que suene el latido.

         @editable
 WarningTime:float = 5.0

      2. Este código es una matriz de dispositivos de efectos visuales de latido. Existe uno por jugador.

         @editable
 AgentVFX:[]heartbeat_vfx = array{}

      3. En este código, el dispositivo Reproductor de radio se utiliza para reproducir los efectos de sonido (SFX) de los latidos del corazón.

         @editable
 SFXPlayer:radio_device = radio_device{}

  3. Este mapa de código se asocia a una IU para mostrar el aviso de latido a cada agente de utilería.

     # Este mapa asocia una IU para mostrar el aviso de latido a cada agente de utilería.
 var WarningUI:[agent]heartbeat_warning_ui = map{}

  4. Con este código, se realiza un seguimiento de cuántos jugadores tienen un latido activo para poder gestionar el dispositivo de efectos de sonido.

     # Realiza un seguimiento de cuántos jugadores tienen un latido activo para poder gestionar el dispositivo de SFX.
 var NumberOfHeartBeats:int = 0

  5. Este código muestra la IU de aviso para los jugadores.

     # Establece una IU de latido para este agente.
 SetUpUI(PropAgent:agent):void =
     if:
         not WarningUI[PropAgent]
         AsPlayer := player[PropAgent]
         PlayerUI := GetPlayerUI[AsPlayer]
     then:
         UIData:heartbeat_warning_ui = heartbeat_warning_ui{}
         UIData.CreateCanvas()
         PlayerUI.AddWidget(UIData.Canvas, player_ui_slot{ZOrder := 1})
         if (set WarningUI[PropAgent] = UIData) {}

  6. Con este código, se activan los efectos visuales (VFX) y los efectos de sonido (SFX) para el reproductor especificado.

         # Activa los efectos visuales y los efectos de sonido de latido para el reproductor especificado.
        Enable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
         if:
             # Obtén el personaje, que se utiliza para encontrar la posición del agente de utilería en la escena.
             Character := PropAgent.GetFortCharacter[]
         then:
             # Establece la posición del efecto visual del latido del corazón a la posición del agente de utilería.
             HeartBeatVFXData.Activate(Character.GetTransform())
             # Aumenta la cuenta de latidos, y si este es el primer latido que se reproduce, necesitamos reproducir el audio para que comience.
             set NumberOfHeartBeats += 1
             if (NumberOfHeartBeats = 1) then SFXPlayer.Play()
             # Registra el agente de utilería al dispositivo reproductor de audio para que el audio del latido se reproduzca desde esa posición.
             SFXPlayer.Register(PropAgent)
         else:
             Logger.Print("No se encontró el personaje, índice o HeartBeatVFXData. No se puede empezar a reproducir el latido.")

  7. Con este código, se crea un método a fin de deshabilitar los efectos visuales y los efectos de sonido para un jugador, y otro a fin de deshabilitarlos para todos los jugadores.

         # Borra los efectos visuales y los efectos de sonido de latido para el agente de utilería especificado.
     Disable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
         Logger.Print("Se está deshabilitando el latido.")
         # Desactiva los VFX.
         HeartBeatVFXData.Deactivate()
         # Cancela el registro del agente de utilería del dispositivo Reproductor de audio para que el audio del latido se detenga.
         SFXPlayer.Unregister(PropAgent)
         # Disminuye el contador de latidos. Este contador nunca debe ser inferior a 0.
         set NumberOfHeartBeats -= 1
         if (NumberOfHeartBeats < 0) then set NumberOfHeartBeats = 0
     # Borra todos los efectos visuales y los efectos de sonido de latido para todos los agentes de utilería.
     DisableAll():void =
         Logger.Print("Se están deshabilitando todos los latidos.")
         # Itera a través de todos los efectos visuales y muévelos a 0,0,0.
         for (HeartBeatVFXDevice : AgentVFX):
             HeartBeatVFXDevice.Deactivate()
         # Cancela el registro de todos los reproductores de audio de latido.
         SFXPlayer.UnregisterAll()
         # Reinicia el contador de latidos a 0
         set NumberOfHeartBeats = 0

Sección siguiente

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page