1. Epic GamesDeveloper
  3. 2. Cómo reproducir efectos visuales en los jugadores

2. Cómo reproducir efectos visuales en los jugadores

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

2. Cómo reproducir efectos visuales en los jugadores

Esta sección te mostrará cómo añadir un (efecto visual) personalizado de latido a tu juego que delate la ubicación de un elemento inmóvil.

Cuando los jugadores del equipo de elementos están inactivos durante demasiado tiempo, se reproduce un efecto visual de latido en ese jugador, y se notifica al equipo de cazadores. Este efecto visual se registra en cada jugador del equipo de elementos cuando aparecen en la partida.

Puedes utilizar dispositivos Generador de efectos visuales junto con Verse para implementar la funcionalidad de latido. Esto incluye:

  • Activación de los efectos visuales.

  • Teletransporte del generador de efectos visuales a los jugadores.

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

Este tutorial incluye fragmentos de Verse que muestran cómo ejecutar las mecánicas de juego necesarias. Sigue los pasos que se indican a continuación y copia la secuencia de comandos completa del paso 6 de este tutorial.

Antes de empezar

Carpetas de recursos

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

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

En el gif anterior, el dispositivo Generador de efectos visuales se arrastra a la carpeta «HeartBeatVFX» del equipo de elementos con fines organizativos. También puedes hacer clic con el botón derecho del ratón 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 los efectos visuales, se teletransportará a la ubicación del jugador. Cuando ya no los necesite, se ocultará hasta que se vuelvan a necesitar.

Los generadores de efectos visuales de esta plantilla utilizan los efectos visuales de Niagara para crear recursos personalizados que se muestran durante el juego. Los recursos de efectos visuales utilizados en este tutorial están configurados para que muestren un latido para revelar a los jugadores inmóviles del equipo de elementos. Estos efectos visuales aparecerán sobre elementos que hayan permanecido estáticos durante al menos 15 segundos.

Puedes consultar la sección Efectos visuales de la documentación para consultar tutoriales sobre cómo crear efectos visuales de latido. A continuación, puedes utilizar el latido personalizado que creaste con el generador de efectos visuales.

Puedes probarlo cuando coloques un generador de efectos visuales. En el panel Detalles, selecciona tu efecto personalizado en el menú desplegable Efecto visual personalizado. Asegúrate de activar Anulación de efectos visuales personalizados para que los efectos visuales seleccionados aparezcan en el visor.

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

A partir de aquí, puedes personalizar aún más tu efecto desde el panel Detalles, añadiendo color y decidiendo cuándo se reproducirán los efectos visuales y quién los verá.

Coloca este dispositivo en un lugar oculto para los jugadores y configura las opciones de usuario para que coincidan con la tabla siguiente. A continuación, copia y pega este dispositivo para que coincida con el número de jugadores que permite tu juego.

Generador de efectos visuales modificado
Opción Valor Explicación
Efecto visual personalizado HeartBeatVFX Define el efecto de partículas personalizado que se usará en lugar del preestablecido de la lista.
Anulación de efecto visual personalizado Activado Establece si se usan los efectos de los desarrolladores.
Habilitado en fase Solo en partida Establece las fases del juego durante las que el dispositivo estará habilitado. Un generador de efectos visuales habilitado reproducirá el efecto de partículas que tenga definido.

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 elementos.

  1. Crea un nuevo archivo de Verse en tu proyecto y llámalo heartbeat.verse. No será un dispositivo de Verse, así que puedes crearlo como un archivo de Verse vacío.

  2. Empieza haciendo doble clic en el archivo de Verse que has creado para añadir las siguientes rutas de Verse a 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. Este código crea una clase nombrada heartbeat_vfx en heartbeat.verse. La clase heartbeat_vfx contiene una estructura de datos para rastrear los objetos vfx_spawner_device por jugador, así como las funciones para fijar los efectos visuales en una posición o reiniciarlos.

     log_heart_beat := class(log_channel){}
     # Estos mensajes se utilizan para notificar a un agente de elementos con un mensaje (u ocultarlo) cuando necesitan moverse para evitar que su latido se haga visible.
 HeartBeatWarningMessage<localizes>(Time:int):message = "Latido en {Time} segundos. ¡Muévete!"
 HeartBeatWarningClear<localizes>:message = ""
     # Esta clase expone las propiedades editables del latido al dispositivo prop_hunt de Verse.
 heart_beat := class<concrete>():
     Logger:log = log{Channel:=log_heart_beat}
     @editable # Número de segundos antes de que un agente de elementos deba moverse antes de que el latido revele su posición.
     MoveTime:float = 15.0
     @editable # Segundos restantes antes de que aparezca el aviso de latido. No debe ser > que HeartBeatTimer.
     WarningTime:float = 5.0
     @editable # Matriz de dispositivos de efectos visuales de latido. Hay una por jugador.
     AgentVFX:[]heartbeat_vfx = array{}
     @editable # El dispositivo Reproductor de radio se utiliza para reproducir los efectos de sonido del latido.
     SFXPlayer:radio_device = radio_device{}
     # Este mapa asocia una interfaz de usuario para mostrar el aviso de latido a cada agente de elementos.
     var WarningUI:[agent]heartbeat_warning_ui = map{}
     # Realiza un seguimiento de cuántos jugadores tienen un latido activo para que podamos gestionar el dispositivo de efectos de sonido.
     var NumberOfHeartBeats:int = 0
     # Configura la interfaz de usuario de latidos para el 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 de sonido de latido para el jugador especificado.
     Enable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
         if:
             # Obtén el personaje que se utiliza para encontrar la posición del agente de elementos en la escena.
             Character := PropAgent.GetFortCharacter[]
         then:
             # Establece la posición de los efectos visuales del latido a la posición del agente de elementos.
             HeartBeatVFXData.Activate(Character.GetTransform())
             # Incrementa el número de latidos, y si este es el primer latido que se reproduce, tenemos que reproducir el audio para que comience.
             set NumberOfHeartBeats += 1
             if (NumberOfHeartBeats = 1) then SFXPlayer.Play()
             # Registra el agente de elementos en el dispositivo reproductor de audio para que el audio del latido se reproduzca desde esa posición.
             SFXPlayer.Register(PropAgent)
         else:
             Logger.Print("Character, Index, o HeartBeatVFXData no encontrados. No se puede iniciar el latido.")
     # Borra los efectos visuales y de sonido de latido del agente de elementos especificado.
     Disable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
         Logger.Print("Desactivando latido.")
         # Desactiva los efectos visuales.
         HeartBeatVFXData.Deactivate()
         # Anula el registro del agente de elementos del dispositivo reproductor de audio; esto provocará que el audio del latido se detenga.
         SFXPlayer.Unregister(PropAgent)
         # Disminuye el contador de latidos. Este contador no debe bajar nunca de 0.
         set NumberOfHeartBeats -= 1
         if (NumberOfHeartBeats < 0) then set NumberOfHeartBeats = 0
     # Borra todos los efectos visuales y de sonido de latido para todos los agentes de elementos.
     DisableAll():void =
         Logger.Print("Desactivando todos los latidos.")
         # Itera por todos los efectos visuales y muévelos a 0,0,0.
         for (HeartBeatVFXDevice : AgentVFX):
             HeartBeatVFXDevice.Deactivate()
         # Anula el registro de todos los jugadores del audio de latidos.
         SFXPlayer.UnregisterAll()
         # Reinicializa el contador de latidos a 0.
         set NumberOfHeartBeats = 0
     # La clase heartbeat_warning_ui contiene una estructura de datos para rastrear el lienzo de interfaz de usuario y el text_block (bloque de texto) por jugador, así como la función para crear un nuevo lienzo de interfaz de usuario de aviso de latido.
 heartbeat_warning_ui := class:
     var Canvas:canvas = canvas{}
     var Text:text_block = text_block{}
     # Crea el lienzo de interfaz de usuario 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. Este código 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 rastrear la raíz de los efectos visuales y los objetos vfx_spawner_device por jugador, así como las funciones para fijar los efectos visuales en una posición o reiniciarla.
 heartbeat_vfx := class<concrete>:
     @editable # Dispositivo de efectos visuales para cada latido.
     VFXDevice:vfx_spawner_device = vfx_spawner_device{}
     # Este desplazamiento se utiliza para posicionar el latido por encima de la cabeza de un agente de elementos.
     HeartBeatVFXOffset:vector3 = vector3{X := 0.0, Y := 0.0, Z := 110.0}
     # Establece la posición de los efectos visuales de latido y luego los habilita.
     Activate(Transform:transform):void =
         VFXPosition := Transform.Translation + HeartBeatVFXOffset
         if (VFXDevice.TeleportTo[VFXPosition, Transform.Rotation]):
             VFXDevice.Enable()

  5. Este código crea un método Deactivate() en la clase heartbeat_vfx que desactiva el dispositivo Generador de efectos visuales y, por tanto, oculta los efectos visuales del latido.

     # La clase heartbeat_vfx contiene una estructura de datos para rastrear la raíz de los efectos visuales y los objetos vfx_spawner_device por jugador, así como las funciones para establecer los efectos visuales en una posición o restablecerla.
 heartbeat_vfx := class<concrete>:
     @editable # Dispositivo de efectos visuales para cada latido.
     VFXDevice:vfx_spawner_device = vfx_spawner_device{}
     # Este desplazamiento se utiliza para posicionar el latido por encima de la cabeza de un agente elemento.
     HeartBeatVFXOffset:vector3 = vector3{X := 0.0, Y := 0.0, Z := 110.0}
     # Establece la posición de los efectos visuales de latido y luego los habilita.
     Activate(Transform:transform):void =
         VFXPosition := Transform.Translation + HeartBeatVFXOffset
         if (VFXDevice.TeleportTo[VFXPosition, Transform.Rotation]):
             VFXDevice.Enable()
            # Desactiva los efectos visuales, ocultando los elementos visuales de latido.
     Deactivate():void =
         VFXDevice.Disable()

Cómo mostrar un 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 latido. Consulta Interfaces de usuario en el juego para obtener más información sobre la creación de interfaces de usuario personalizadas y otros componentes de la interfaz de usuario de Verse.

  1. Las dos constantes siguientes controlan el texto que se mostrará a los jugadores del equipo de elementos en distintos momentos de la partida.

    • La constante HeartBeatWarningMessage es una función que toma un int y devuelve el tipo message. Este tipo se utiliza en los elementos de la interfaz de usuario porque se puede localizar. Este es el texto que verán los jugadores cuando tengan que moverse para evitar que el efecto del latido 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 elementos con un mensaje (u ocultarlo) cuando necesitan moverse para evitar que su latido se haga visible.
 HeartBeatWarningMessage<localizes>(Time:int):message = "Latido en {Time} segundos. ¡Muévete!"
 HeartBeatWarningClear<localizes>:message = ""

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

     # La clase heartbeat_warning_ui contiene una estructura de datos para rastrear el lienzo de interfaz de usuario y el text_block (bloque de texto) por jugador, así como la función para crear un nuevo lienzo de interfaz de usuario de aviso de latido.
 heartbeat_warning_ui := class:
     var Canvas:canvas = canvas{}
     var Text:text_block = text_block{}
     # Crea el lienzo de interfaz de usuario 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

Administración de efectos de latido

Sigue estos pasos para crear el administrador de latidos.

  1. El código siguiente crea una clase nombrada heart_beat en heartbeat.verse. Esta clase expone las propiedades editables del latido al dispositivo prop_hunt y gestiona los efectos del latido.

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

    1. Este código controla los segundos que un agente de elementos debe moverse antes de que el efecto de latido revele su posición.

           @editable 
     MoveTime:float = 15.0

      1. Este código controla los segundos que quedan antes de que aparezcan palabras en pantalla para avisar a un miembro del equipo de elementos e indicarle que se mueva antes de que se active el latido.

         @editable
 WarningTime:float = 5.0

      2. Este código es una matriz de dispositivos de efectos visuales de latido. Hay una 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 de latido.

         @editable
 SFXPlayer:radio_device = radio_device{}

  3. Este código asocia una interfaz de usuario para mostrar el aviso de latido a cada agente de elementos.

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

  4. Este código realiza un seguimiento de cuántos jugadores tienen un latido activo para que podamos gestionar el dispositivo de efectos de sonido.

     # Realiza un seguimiento de cuántos jugadores tienen un latido activo para que podamos gestionar el dispositivo de efectos de sonido.
 var NumberOfHeartBeats:int = 0

  5. Este código muestra la interfaz de usuario del aviso para los jugadores.

     # Configura la interfaz de usuario de latidos para el 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. Este código activa los efectos visuales y de sonido del jugador especificado.

         # Activa los efectos visuales y de sonido de latido para el jugador especificado.
        Enable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
         if:
             # Obtén el personaje que se utiliza para encontrar la posición del agente elemento en la escena.
             Character := PropAgent.GetFortCharacter[]
         then:
             # Configura la posición de los efectos visuales de latido a la posición del agente de elementos.
             HeartBeatVFXData.Activate(Character.GetTransform())
             # Incrementa el número de latidos, y si este es el primer latido que se reproduce, tenemos que reproducir el audio para que comience.
             set NumberOfHeartBeats += 1
             if (NumberOfHeartBeats = 1) then SFXPlayer.Play()
             # Registra el agente de elementos en el dispositivo reproductor de audio para que el audio del latido se reproduzca desde esa posición.
             SFXPlayer.Register(PropAgent)
         else:
             Logger.Print("Character, Index, o HeartBeatVFXData no encontrados. No se puede iniciar el latido.")

  7. Este código crea un método para desactivar los efectos visuales y de sonido para un jugador, y otro para desactivarlos para todos los jugadores.

         # Borra los efectos visuales y de sonido de latido del agente de elementos especificado.
     Disable(PropAgent:agent, HeartBeatVFXData:heartbeat_vfx):void =
         Logger.Print("Desactivando latido.")
         # Desactiva los efectos visuales.
         HeartBeatVFXData.Deactivate()
         # Anula el registro del agente de elementos del dispositivo reproductor de audio; esto provocará que el audio del latido se detenga.
         SFXPlayer.Unregister(PropAgent)
         # Disminuye el contador de latidos. Este contador no debe bajar nunca de 0.
         set NumberOfHeartBeats -= 1
         if (NumberOfHeartBeats < 0) then set NumberOfHeartBeats = 0
     # Borra todos los efectos visuales y de sonido de latidos para todos los agentes elementos.
     DisableAll():void =
         Logger.Print("Desactivando todos los latidos.")
         # Itera por todos los efectos visuales y muévelos a 0,0,0.
         for (HeartBeatVFXDevice : AgentVFX):
             HeartBeatVFXDevice.Deactivate()
         # Anula el registro de todos los jugadores del audio de latidos.
         SFXPlayer.UnregisterAll()
         # Reinicializa el contador de latidos a 0.
         set NumberOfHeartBeats = 0

Siguiente sección

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page