1. Epic GamesDeveloper
  3. 8. Visualización de los jugadores que sostienen objetivos

8. Visualización de los jugadores que sostienen objetivos

Crea ayudas visuales para encontrar jugadores que sostienen objetivos.

8. Visualización de los jugadores que sostienen objetivos

La invisibilidad del infiltrado crea un problema interesante a la hora de atrapar el objetivo del defensor. ¿Cómo van a encontrar los defensores a un jugador invisible que podría estar corriendo de vuelta a la base con su objetivo? Para resolver este problema, puedes utilizar una ayuda visual, en este caso una utilería, para mostrar a los Defensores dónde está el infiltrado.

Sigue los pasos que se indican a continuación para aprender a crear un objeto que flote sobre la cabeza de un jugador cuando esté sosteniendo un objetivo.

Cómo crear el administrador de captura de objeto

  1. Crea un nuevo dispositivo de Verse denominado item_capture_manager con el explorador de Verse y arrastra el dispositivo al nivel.
  2. En la parte superior del archivo item_capture_manager:
    1. Añade using { /UnrealEngine.com/Temporary/SpatialMath } para acceder a la estructura vector3. Lo utilizarás para saber dónde teletransportar los indicadores que flotan sobre la cabeza del jugador. Agrega también using { /Fortnite.com/Characters } para acceder a fort_character de un jugador. 
       using { /Fortnite.com/Devices }
 using { /Verse.org/Simulation }
 using { /Fortnite.com/Characters }
 using { /UnrealEngine.com/Temporary/Diagnostics }
 using { /UnrealEngine.com/Temporary/SpatialMath }
  3. En la definición de la clase item_capture_manager, añade los siguientes campos:
    1. Una matriz editable de dispositivos de aparición de objeto de captura llamada CaptureItemSpawners. Esta matriz contiene el dispositivo generador de objetos de captura para los infiltrators. 
       item_capture_manager := class(creative_device):

     Logger:log = log{Channel := triad_item_capture_log_channel}

     # Generador de objetos de captura que genera el elemento que se capturará.
     @editable
     CaptureItemSpawner:capture_item_spawner_device = capture_item_spawner_device{}
    2. Una utilería creativa editable llamada CaptureItemIndicator. Este es la utilería que flotará sobre la cabeza de un infiltrado cuando capture el objetivo. 
       # Generador de objetos de captura que genera el elemento que se capturará.
 @editable
 CaptureItemSpawner:capture_item_spawner_device = capture_item_spawner_device{}
    
 # Utilería que flota sobre la cabeza de los jugadores cuando están sosteniendo el elemento de 
 # CaptureItemSpawner.
 @editable
 CaptureItemIndicator:creative_prop = creative_prop{}
    3. Un dispositivo indicador de mapa editable denominado MapIndicator. Esto se ubicará debajo de CaptureItemSpawner en el nivel y mostrará en el mapa el lugar donde se encuentran los objetivos para cada equipo. 
       # Utilería que flota sobre la cabeza de los jugadores cuando están sosteniendo el elemento de 
 # CaptureItemSpawner.
 @editable
 CaptureItemIndicator:creative_prop = creative_prop{}

 # Indicador que muestra en el mapa el lugar donde se encuentran los objetivos de cada equipo que son.
 @editable
 MapIndicator:map_indicator_device = map_indicator_device{}
    4. Dos floats editables UpdateRateSeconds y VerticalOffset. El primero controla la rapidez con la que cambia la posición de CaptureItemIndicator y el segundo controla la distancia a la que flota CaptureItemIndicator por encima de la cabeza del jugador. 
       # Indicador que muestra en el mapa el lugar donde se encuentran los objetivos de cada equipo que son.
 @editable
 MapIndicator:map_indicator_device = map_indicator_device{}

 # Frecuencia con la que CaptureItemIndicator actualiza su posición.
 @editable
 UpdateRateSeconds:float = 0.15

 # Altura a la que flota CaptureItemIndicator sobre la cabeza de un jugador.
 @editable
 VerticalOffset:float = 180.0
    5. Dispositivo de mensajes editable del HUD denominado ItemGrabbedMessageDevice. Envía un mensaje a cada jugador cuando se recoge un objetivo. 
       # Altura a la que flota CaptureItemIndicator sobre la cabeza de un jugador.
 @editable
 VerticalOffset:float = 180.0

 # Muestra un mensaje cuando un jugador agarra el elemento de captura.
 @editable
 ItemGrabbedMessageDevice:hud_message_device = hud_message_device{}
    6. Dispositivo administrador de puntaje editable denominado ScoreManagerDevice. Otorga puntaje a un equipo cada vez que un jugador captura el objeto. 
       # Muestra un mensaje cuando un jugador agarra el elemento de captura.
 @editable
 ItemGrabbedMessageDevice:hud_message_device = hud_message_device{}
    
 # Otorga la puntuación cuando un jugador captura el elemento de captura.
 @editable
 ScoreManagerDevice:score_manager_device = score_manager_device{}
    7. Valor float editable denominado ReturnTime. Si el elemento de captura tiene un tiempo de devolución antes de volver a CaptureItemSpawner, es necesario que hagas un seguimiento de cuánto dura ese tiempo de devolución para saber cuándo devolver los indicadores nuevamente a CaptureItemSpawner.
  4. Añade un nuevo método FollowCharacter() a la definición de la clase item_capture_manager. Este método toma un fort_character y lo rastrea con los indicadores que se muestran encima de la cabeza del personaje. Agrega el especificador <suspends> a esta función, ya que querrás generar uno de estos para un jugador siempre que sostenga un objetivo. 
     # Hace que CaptureItemIndicator siga continuamente a un jugador encima de su cabeza.
 # Hace una carrera entre el bucle de actualización para CaptureItemIndictator, y si el jugador
 # captura el elemento, suelta el elemento o es eliminado.
 FollowCharacter(FortCharacter:fort_character)<suspends>:void=
     Logger.Print("Se generó la función FollowCharacter.")

Correr una carrera mientras sostiene el objetivo

Es importante pensar en lo que ocurre cuando un jugador captura el objetivo. El jugador puede hacer lo siguiente:

  • Desplazarse, en cuyo caso necesitas que los indicadores de mapa y CaptureItem se actualicen constantemente según la posición del jugador. Esto puede hacerse en bucle.
  • Capturar el objetivo, en cuyo caso necesitas que los indicadores regresen a CaptureItemSpawner en algún lugar donde no se vean, ya que no deberían ser visibles a menos que un jugador sostenga el elemento de captura.
  • Soltar el objetivo o ser eliminado, en cuyo caso los indicadores tienen que permanecer donde se soltó el elemento y regresar a CaptureItemSpawner cuando se devuelve el elemento de captura.

Para conseguirlo, vas a configurar una expresión race (carrera). Al utilizar una race entre las tres condiciones anteriores, puedes continuar la actualización de la posición de los indicadores mientras esperas a que el jugador suelte o capture el objetivo.

  1. Añade una expresión race a FollowCharacter() Configura la carrera para que se ejecute entre un loop, un Await() para ItemCapturedEvent de CaptureItemSpawner, un Await() para ItemCapturedDroppedEvent de CaptureItemSpawner y un Await() para EliminatedEvent() de FortCharacter. 
     FollowCharacter(FortCharacter:fort_character)<suspends>:void=
     Logger.Print("Se generó la función FollowCharacter.")
     race:
         loop:
         CaptureItemSpawner.ItemCapturedEvent.Await()
         CaptureItemSpawner.ItemDroppedEvent.Await()
         FortCharacter.EliminatedEvent().Await()
  2. En el loop, obtén la posición de FortCharacter y guárdala en una variable Transform. 
     loop:
     Transform := FortCharacter.GetTransform()
  3. Ahora genera MoveTo() para mover CaptureItemIndicator y MapIndicator a la traslación y la rotación de Transform más el valor de VerticalOffset que configuraste anteriormente sobre una cantidad de tiempo en UpdateRateSeconds. Deseas generar Spawn{} las dos funciones de MoveTo() porque es necesario que tanto CaptureItemIndicator como MapIndicator se muevan en el mismo momento exacto, en lugar de esperar a que se complete la expresión de cada una. Como la traslación es un vector3 que lo constituyen coordenadas X, Y y Z, tendrás que colocar VerticalOffset dentro de un nuevo vector3. Dado que VerticalOffset es la distancia vertical por encima de la cabeza de un jugador, establécelo como el valor Z del vector3. 
    loop:
     Transform := FortCharacter.GetTransform()
     spawn{CaptureItemIndicator.MoveTo(Transform.Translation + vector3{Z := VerticalOffset}, Transform.Rotation, UpdateRateSeconds)}
     spawn{MapIndicator.MoveTo(Transform.Translation + vector3{Z := VerticalOffset}, Transform.Rotation, UpdateRateSeconds)}
  4. Por último, pon en pausa el proceso durante 0.0 segundos. Esto garantiza que el bucle se ejecute una sola vez por actualización de simulación y no se salga de control al generar las funciones MoveTo(). El código FollowCharacter() ahora debería verse de la siguiente manera: 
     # Hace que CaptureItemIndicator siga continuamente a un jugador encima de su cabeza.
 # Hace una carrera entre el bucle de actualización para CaptureItemIndictator, y si el jugador
 # captura el elemento, suelta el elemento o es eliminado.
 FollowCharacter(FortCharacter:fort_character)<suspends>:void=
     Logger.Print("Se generó la función FollowCharacter.")
     race:
         loop:
             Transform := FortCharacter.GetTransform()
             spawn{CaptureItemIndicator.MoveTo(Transform.Translation + vector3{Z := VerticalOffset}, Transform.Rotation, UpdateRateSeconds)}
             spawn{MapIndicator.MoveTo(Transform.Translation + vector3{Z := VerticalOffset}, Transform.Rotation, UpdateRateSeconds)}
             # Es conveniente asegurarnos de que este bucle se ejecute una sola vez por actualización de simulación, así que pausamos el proceso durante un solo tic de juego.
             Sleep(0.0)
         CaptureItemSpawner.ItemCapturedEvent.Await()
         CaptureItemSpawner.ItemDroppedEvent.Await()
         FortCharacter.EliminatedEvent().Await()
     Logger.Print("Objectivo soltado o capturado.")

    Cómo restablecer los indicadores

  5. Cuando el elemento de captura se captura o devuelve, es necesario que devuelvas los indicadores a CaptureItemSpawner en algún lugar donde no se vean. En este caso, los teletransportarás a una altura sobre CaptureItemSpawner. Para hacer esto, agrega una función denominada ReturnIndicators() a la definición de clase item_capture_manager. 
     # Vuelve a colocar los indicadores de mapa y de elemento de captura en sus posiciones iniciales encima de los generadores.
 ReturnIndicators(InAgent:agent):void=
  6. Obtén la transformación de CaptureItemSpawner y guárdala en una variable SpawnerTransform. Luego, genera la variable MoveTo() para CaptureItemIndicator y MapIndicator en la transformación y rotación de CaptureItemSpawner, y agrega VerticalOffset de la misma forma que hiciste en loop para ponerlos encima de CaptuerItemSpawnwer. Si quieres que tu utilería no se vea, puedes multiplicar el valor de VerticalOffset por un número grande, en este caso, 10. El método ReturnIndicators() completado debería verse de la siguiente manera: 
    # Vuelve a colocar los indicadores de mapa y de elemento de captura en sus posiciones iniciales encima de los generadores.
ReturnIndicators():void=
 SpawnerTransform := CaptureItemSpawner.GetTransform()
 # Vuelve a teletransportar al generador y oculta CaptureItemIndicator y MapIndicator encima del mapa fuera del sitio.
 spawn{CaptureItemIndicator.MoveTo(SpawnerTransform.Translation + vector3{Z := VerticalOffset * 10.0}, SpawnerTransform.Rotation, UpdateRateSeconds)}
 spawn{MapIndicator.MoveTo(SpawnerTransform.Translation + vector3{Z := VerticalOffset * 10.0}, SpawnerTransform.Rotation, UpdateRateSeconds)}
 Logger.Print("Los indicadores regresaron a capture spawner.")

Cómo manejar a los jugadores que alcanzan, sueltan y capturan el objetivo

  1. Agrega un nuevo método, OnItemPickedUp(), a la definición de clase item_capture_manager. Este método toma un agent y genera una instancia de FollowCharacter() para ese personaje. 
     # Señala a cada jugador cuando un jugador alcanza el objetivo.
 OnItemPickedUp(InAgent:agent):void=
     Logger.Print("Objectivo recogido.")
  2. Obtén el FortCharacter para InAgent, y genera una función FollowCharacter() con ese FortCharacter. El método OnItemPickedUp() completado debería verse de la siguiente manera: 
     # Señala a cada jugador cuando un jugador alcanza el objetivo.
 OnItemPickedUp(InAgent:agent):void=
     Logger.Print("Objectivo recogido.")
     if(FortCharacter := InAgent.GetFortCharacter[]):
         ItemGrabbedMessageDevice.Show()
         spawn{FollowCharacter(FortCharacter)}
  3. Agrega un nuevo método, OnItemCaptured(), a la definición de clase item_capture_manager. Este método toma al agent que capturó el objetivo. 
     # Cuando se captura el elemento, otorga puntuación al equipo capturador y devuelve los indicadores.
 OnItemCaptured(CapturingAgent:agent):void=
     Logger.Print("Objectivo capturado.")
  4. En OnItemCaptured(), activa ScoreManagerDevice para otorgar el puntaje de equipo del jugador que captura, y llama a ReturnIndicators() para que se devuelvan los indicadores. 
     # Cuando se captura el elemento, otorga puntuación al equipo capturador y devuelve los indicadores.
 OnItemCaptured(CapturingAgent:agent):void=
     Logger.Print("Objectivo capturado.")
     ScoreManagerDevice.Activate()
     ReturnIndicators()
  5. Agrega un nuevo método, OnItemDropped(), a la definición de clase item_capture_manager. Este método toma al agent que soltó el elemento. 
     # Cuando un jugador suelta un elemento, genera la función WaitForReturn()
 # si el valor de ReturnTime es mayor que 0.
 OnItemDropped(InAgent:agent):void=
     Logger.Print("Objectivo soltado.")
  6. Cuando se suelta el objetivo, los indicadores deben permanecer cerca de este hasta que sea recogido o devuelto a CaptureItemSpawner. Para saber cuándo hay que devolver los indicadores, usarás la variable ReturnTime que configuraste anteriormente. Si ReturnTime es mayor o igual que 0.0, es conveniente esperar esa cantidad de tiempo y, a continuación, devolver los indicadores. Si el valor de ReturnTime es negativo, el objetivo no tiene tiempo de devolución, así que no es necesario que muevas los indicadores. Para mover los indicadores a las posiciones previas, genera una nueva función de ayuda denominada WaitForReturn(), la cual definirás en el próximo paso. 
     # Cuando un jugador suelta un elemento, genera la función WaitForReturn()
 # si el valor de ReturnTime es mayor que 0.
 OnItemDropped(InAgent:agent):void=
     Logger.Print("Objectivo soltado.")
     if(ReturnTime >= 0.0):
         spawn{WaitForReturn()}
     else:
         Logger.Print("El objetivo soltado no regresa.")
  7. Agrega un nuevo método, WaitForReturn(), a la definición de clase item_capture_manager. Esta función espera una cantidad de tiempo de ReturnTime, luego, devuelve los indicadores si el objetivo no se recogió antes de completarse la espera. Agrega el modificador <suspends> a este método para permitir que el proceso se ponga en pausa mediante Sleep(). 
     # Espera la cantidad de tiempo de ReturnTime, luego devuelve los indicadores.
 WaitForReturn()<suspends>:void=
     Logger.Print("Esperando a que regresen los indicadores…")
  8. Si es necesario o no devolver los indicadores dependerá de si el objetivo se recogió antes de que ReturnTime haya finalizado. Si así fue, no es conveniente devolver los indicadores, ya que volverían de inmediato al jugador, lo cual podría causar visuales extrañas. Para resolver esto, usarás una variable lógica donde el valor sea igual al resultado de una carrera. 
     # Espera la cantidad de tiempo de ReturnTime, luego devuelve los indicadores.
 WaitForReturn()<suspends>:void=
     Logger.Print("Esperando a que regresen los indicadores…")
     # Devuelve los indicadores de CaptureItem y de mapa si el elemento de captura
     # no se recoge antes de que se agote el tiempo.
     ShouldReturn:logic := race:
  9. Es necesario que la función WaitForReturn() ejecute una carrera entre dos condiciones. Se agota el tiempo de ReturnTime y el objetivo regresa a CaptureItemSpawner, en cuyo caso es necesario devolver los indicadores y el valor de ShouldReturn debe ser true. O si el objetivo se recoge antes de que se agote el tiempo de ReturnTime, en cuyo caso el valor de ShouldReturn debe ser false. Debido a que cada una de estas condiciones devuelve un valor, ejecutarás la carrera con dos bloques blocks distintos. 
     ShouldReturn:logic := race:
     block:
     block:
  10. En el primer bloque, se llama a Sleep() durante la cantidad de tiempo de ReturnTime; luego, se devuelve true. En el segundo bloque, se ejecuta Await() para CaptureItemSpawner.ItemPickedUpEvent y se devuelve false. La variable ShouldReturn ahora se inicializará en cualquiera de estos que se complete primero. 
     ShouldReturn:logic := race:
     block:
         Sleep(ReturnTime)
         true
     block:
         CaptureItemSpawner.ItemPickedUpEvent.Await()
         false
  11. Si ShouldReturn es verdadero, es necesario que devuelvas los indicadores. Llama a ReturnIndicators() si ShouldReturn se evalúa en true. El código WaitForReturn() completado ahora debería verse de la siguiente forma: 
     # Espera la cantidad de tiempo de ReturnTime, luego devuelve los indicadores.
 WaitForReturn()<suspends>:void=
     Logger.Print("Esperando a que regresen los indicadores…")
     # Devuelve los indicadores de CaptureItem y de mapa si el elemento de captura
     # no se recoge antes de que se agote el tiempo.
     ShouldReturn:logic := race:
         block:
             Sleep(ReturnTime)
             true
         block:
             CaptureItemSpawner.ItemPickedUpEvent.Await()
             false
        
     if(ShouldReturn?):
         ReturnIndicators()
  12. Ahora en OnBegin(), suscribe ItemPickedUpEvent de CaptureItemSpawner a OnItemPickedUp(), ItemCapturedEvent a OnItemCaptured() y ItemDroppedEvent a OnItemDropped(). 
     OnBegin<override>()<suspends>:void=
     CaptureItemSpawner.ItemPickedUpEvent.Subscribe(OnItemPickedUp)
     CaptureItemSpawner.ItemCapturedEvent.Subscribe(OnItemCaptured)
     CaptureItemSpawner.ItemDroppedEvent.Subscribe(OnItemDropped)
     SpawnerTransform := CaptureItemSpawner.GetTransform()
  13. Por último, en OnBegin(), coloca los indicadores en sus posiciones iniciales cuando se ejecute la secuencia de comandos. Para ello, llama a MoveTo() en CaptureItemIndicator y MapIndicator. El código OnBegin() debería ser similar al siguiente: 
     OnBegin<override>()<suspends>:void=
     CaptureItemSpawner.ItemPickedUpEvent.Subscribe(OnItemPickedUp)
     CaptureItemSpawner.ItemCapturedEvent.Subscribe(OnItemCaptured)
     CaptureItemSpawner.ItemDroppedEvent.Subscribe(OnItemDropped)
     SpawnerTransform := CaptureItemSpawner.GetTransform()
        
     # Vuelve a teletransportar al generador y oculta CaptureItemIndicator debajo del mapa fuera del sitio.
     CaptureItemIndicator.MoveTo(SpawnerTransform.Translation + vector3{Z := VerticalOffset * 10.0}, SpawnerTransform.Rotation, UpdateRateSeconds)
     MapIndicator.MoveTo(SpawnerTransform.Translation + vector3{Z := VerticalOffset * 10.0}, SpawnerTransform.Rotation, UpdateRateSeconds)

  14. De vuelta en el editor, guarda la secuencia de comandos, compílala y arrastra el dispositivo al nivel. Elige una utilería apropiada que quieras que sirva como CaptureItemIndicator en tu nivel. Puede ser cualquier cosa, basta con que sea lo suficientemente visible. En este ejemplo, se utilizará un diamante. En el panel de detalles, asigna CaptureItemSpawner a InfiltratorCaptureSpawner y CaptureItemIndicator a la utilería que elegiste. También asigna MapIndicator al indicador de mapa del infiltrado, ItemGrabbedMessageDevice al dispositivo de mensajes del HUD del infiltrado y ScoreManagerDevice al administrador de puntaje del infiltrado. Establece ReturnTime en un número negativo, ya que el elemento de captura del infiltrado no se devuelve.

    También tienes que configurar una instancia de item_capture_manager para los atacantes. Recuerda cambiar CaptureItemIndicator a una utilería que sea diferente de la utilería del infiltrado para evitar confusión visual en los equipos, y asegúrate de asignar todos los demás dispositivos. Establece ReturnTime en un número positivo, ya que el elemento de captura del atacante se devuelve después de un tiempo establecido.
  15. Haz clic en Comenzar sesión en la barra de herramientas de UEFN para realizar una prueba de juego del nivel. Cuando pruebes tu nivel, un jugador deberá tener una utilería sobre su cabeza al capturar un objetivo. La utilería debe moverse con el jugador y, cuando éste deje caer o capture el objetivo, la utilería debe teletransportarse al dispositivo de aparición de objetos de captura.
Cómo visualizar el objetivo

Próximo paso

En el siguiente paso de este tutorial, aprenderás a decirles con rapidez a los jugadores lo que deben hacer en un juego y en qué centrarte para mejorar la experiencia del jugador.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page