Administrador de juego reutilizable

Este tutorial utiliza Verse para hacer posibles determinadas funciones. Mediante el uso de Verse en este tutorial, puedes:

• Activar y reproducir animaciones de forma intermitente para crear una mecánica de juego.

• Actualizar la información de puntuación de todos los jugadores de un minijuego.

• Crear retrasos en la aparición de jugadores y tiempos de aparición de objetos intermitentes.

Puedes reutilizar este código para realizar las siguientes tareas:

• Cambiar los dispositivos que están activados y desactivados mientras el juego pasa de la central a la partida y de nuevo a la central.

• Comprobar las puntuaciones de los jugadores para encontrar la puntuación ganadora y mostrarla en la central.

• Finalizar el juego y teletransportar a los jugadores de vuelta a la central al final del minijuego.

Cómo configurar el dispositivo de Verse y los objetos editables

Sigue estos pasos para configurar tu dispositivo Verse y los objetos editables:

1. Crea un nuevo dispositivo Verse nombrado tiltnboom y añádelo al nivel. Consulta Cómo crear tu propio dispositivo con Verse para ver los pasos.

2. Añade los siguientes módulos en la parte superior del archivo:

   Verse

        using { /Fortnite.com/Characters }
        using { /Fortnite.com/Devices }
        using { /Fortnite.com/Game }
        using { /UnrealEngine.com/Temporary/Diagnostics }
        using { /Verse.org/Random }
        using { /Verse.org/Simulation }
   

   Copy full snippet(6 lines long)

3. Añade los siguientes campos a la definición de la clase tiltnboom:

   1. Dos dispositivos trigger editables; ActivateGameTrigger y EndGameTrigger. ActivateGameTrigger se utiliza para activar este juego. El activador puede activarse por cualquier cosa, como un teletransporte al juego o después de una cinemática de introducción.

      El EndGameTrigger se utiliza para finalizar el minijuego y retirar todos los dispositivos de cámara y control de los jugadores una vez finalizada la partida.

   Verse

        @editable
        ActivateGameTrigger:trigger_device = trigger_device{}
   
        @editable
        EndGameTrigger:trigger_device = trigger_device{}
   

   Copy full snippet(5 lines long)

   1. Un dispositivo de temporizador editable nombrado GameTimer. Esto finaliza la partida después de una cierta cantidad de tiempo.

   2. Un array de dispositivos de secuencia cinemática nombrada CannonballSequences. Cada dispositivo de la matriz reproduce una posición de aterrizaje diferente de bala de cañón.

   3. Una matriz de volúmenes de daño nombrada DamageVolumes que se activan y desactivan en función del estado del juego.

   4. Una matriz de generadores de objetos nombrada ItemSpawners que aleatoriamente generan un número aleatorio de objetos durante la partida.

   5. Un dispositivo de área de captura nombrado CaptureArea. Esto da puntos a los jugadores por estar en la balsa y se activa o desactiva en función del estado del juego.

   6. Un dispositivo de administrador de puntuación nombrado ScoreManager, que restablece la puntuación de los jugadores cuando comienza una partida y determina el jugador ganador al final de la partida.

   7. Un teletransportador nombrado HUBTeleporter que devuelve a todo el mundo a la central una vez finalizada la partida.

   8. Un dispositivo de referencia de jugador denominado PlayerReference, que muestra al jugador ganador en la central entre partidas.

      Verse

                                   @editable
                                   GameTimer:timer_device = timer_device{}
      								        
                                   @editable
                                   CannonballSequences:[]cinematic_sequence_device = array{}
      								        
                                   @editable
                                   DamageVolumes:[]damage_volume_device = array{}
      								
                                   @editable
      
      Expand code Copy full snippet(23 lines long)

4. Dos matrices editables de plataformas de aparición de jugadores nombradas PlayerSpawners y HUBSpawners. Estas deshabilitan la aparición cuando termina el minijuego y devuelven a los jugadores a la central después del minijuego.

   Verse

            @editable
            PlayerSpawners:[]player_spawner_device = array{}
   		
            @editable
            HUBSpawners:[]player_spawner_device = array{}
   

   Copy full snippet(5 lines long)

5. Dos floats editables nombrados MinimumItemSpawnTime y MaximumItemSpawnTime. Estos son los tiempos mínimo y máximo de espera entre la aparición de objetos en la balsa.

   Verse

            @editable
            MinimumItemSpawnTime:float = 5.0
   		
            @editable
            MaximumItemSpawnTime:float = 10.0
   

   Copy full snippet(5 lines long)

6. Un float editable nombrado DelayAfterGame. Este es el retraso para teletransportar a los jugadores de vuelta a la central una vez que la partida ha terminado.

   Verse

            @editable
            DelayAfterGame:float = 5.0
   

   Copy full snippet(2 lines long)

7. Un float nombrado DelayBetweenCannonballSequences. Este es el retraso para la aparición de balas de cañón entre secuencias a lo largo de la duración del minijuego.

   Verse

        DelayBetweenCannonballSequences:float = 8.0
   

   Copy full snippet(1 line long)

8. Una variable de lógica nombrada GameActive para determinar si el juego está activo o no.

   Verse

            var GameActive:logic = false
   

   Copy full snippet(1 line long)

Cómo iniciar el juego

Cuando comienza el minijuego, se activan varios dispositivos y la puntuación del jugador se reinicia a 0.

1. Encima de la definición de la clase tiltnboom, añade un canal de registro para imprimir mensajes específicos del minijuego. A continuación, añade un registrador a la definición de la clase para utilizarlo con el canal de registro.

   Verse

        tiltnboom_log_channel := class(log_channel){}
   		
        # A Verse-authored creative device that can be placed in a level
        tiltnboom := class(creative_device):
   		
            Logger:log = log{Channel := tiltnboom_log_channel}
   

   Copy full snippet(6 lines long)

2. Añade un nuevo método OnTriggered a la definición de la clase titnboom que toma un InitiatingAgent e inicia el juego. Añade una expresión if al método que se devuelve si el juego ya está activo, para que no se inicie el juego mientras hay otro en ejecución.

   Verse

            OnTriggered(InitiatingAgent:?agent):void=
                if (GameActive?):
                    return
   		
                spawn{StartGame()}
   

   Copy full snippet(5 lines long)

3. En OnBegin(), suscribe el TriggeredEvent de ActivateGameTrigger a la función OnTriggered para iniciar el juego. Cualquier dispositivo que deba activarse al comienzo del minijuego se suscribirá a este evento y se activará cuando se active el evento OnTrigger.

   Verse

            OnBegin<override>()<suspends>:void=
   
                ActivateGameTrigger.TriggeredEvent.Subscribe(OnTriggered)

   Copy full snippet(3 lines long)

4. Añade un nuevo método StartGame() que gestione la lógica para iniciar el juego. Añade el modificador <suspends> a esta función para que pueda ejecutarse de forma asíncrona.

   En primer lugar, activa GameActive para indicar que el juego está activo. A continuación, activa CaptureArea y cada DamageVolume en la matriz DamageVolumes.

   En cada jugador, si tiene una puntuación superior a 0, restablece su puntuación y otórgale la inversa de su puntuación actual, para establecer su puntuación en 0.

   A continuación, en una expresión race, compite entre el temporizador que termina, la secuencia de la bala de cañón que se ejecuta y los objetos aleatorios que aparecen. La secuencia de la bala de cañón y la aparición de objetos aleatorios son bucles infinitos, pero se cancelan en cuanto termina el temporizador.

   Cuando el juego termine, llama a la función OnGameFinished() para gestionar la limpieza al final del juego.

   Verse

        StartGame()<suspends>:void=
            Logger.Print("Starting game.")
            set GameActive = true
   
            CaptureArea.Enable()
   
            for (DamageVolume : DamageVolumes):
                DamageVolume.Enable()
   
            for:
   
   Expand code Copy full snippet(23 lines long)

Cómo crear un bucle de bala de cañón

En esta sección se explica cómo añadir una función que reproduzca las secuencias cinemáticas de la bala de cañón.

1. Añade un nuevo método StartCannonSequence() a la definición de la clase tiltnboom que reproduzca las secuencias de nivel de las balas de cañón y utilice un bucle para reproducir la expresión de retraso. A continuación, añade un retraso entre las balas de cañón. Añade el modificador <suspends> a esta función para que pueda ejecutarse de forma asíncrona.

   En un bucle, elige una secuencia aleatoria en la matriz CannonballSequences al indexarla con GetRandomInt(). Reproduce la secuencia y, a continuación, envía a reposo durante un tiempo DelayBetweenCannonballSequences antes de reproducir otra secuencia.

   Verse

        StartCannonSequence()<suspends>:void=
            loop:
   
                RandomCannonballSequence:int = GetRandomInt(0, CannonballSequences.Length - 1)
   
                if (CannonballSequence := CannonballSequences[RandomCannonballSequence]):
                    Logger.Print("Set CannonballSequence to {RandomCannonballSequence}")
   
                    CannonballSequence.Play()
   
   
   Expand code Copy full snippet(11 lines long)

Cómo crear bucles de generación aleatoria de elementos

En esta sección se explica cómo crear una función que genere elementos aleatorios en lugares aleatorios de la balsa, lo que puede ayudar o perjudicar a los jugadores a ganar el minijuego.

1. Añade un nuevo método denominado SpawnRandomItems a la definición de la clase titlnboom. Este método controla los objetos que aparecen en la balsa.

2. Obtén el número de elementos de la matriz ItemSpawners y, a continuación, recorre la matriz en bucle. Usa un int aleatorio para obtener un generador de objetos aleatorios de la matriz y, a continuación, actívalo. Envíalo a reposo durante un tiempo aleatorio entre la aparición de objetos.

3. El bucle decide aleatoriamente cuántos objetos generar y selecciona aleatoriamente un objeto que generar, tantas veces como NumberOfItemsToSpawn. El DelayBetweenItemSpawns genera una cantidad de tiempo indeterminada para esperar entre las apariciones.

   Verse

            SpawnRandomItems()<suspends>:void=
                ItemSpawnerCount:int = ItemSpawners.Length - 1
   
                loop:
   
                    NumberOfItemsToSpawn:int = GetRandomInt(0, ItemSpawnerCount)
   
                    # Spawn a randomly selected item, as many times as NumberOfItemsToSpawn.
                    for:
                        CurrentItemSpawnNumber := 0..NumberOfItemsToSpawn
   
   Expand code Copy full snippet(17 lines long)

Cómo finalizar el juego

Al final del minijuego, tendrás que enviar la puntuación del ganador a la central, deshabilitar los dispositivos y teletransportar a los jugadores de vuelta a la central.

1. Añade un nuevo método OnGameFinished a la definición de la clase tiltnboom. Cuando termina el juego, esta función lo deja inactivo y deshabilita los dispositivos correspondientes.

   ~~~(verse) OnGameFinished()<suspends>:void= Logger.Print("La partida ha terminado.") set GameActive = false

   CaptureArea.Disable()

   for (PlayerSpawner : PlayerSpawners): PlayerSpawner.Disable()

   for (DamageVolume : DamageVolumes): DamageVolume.Disable() ~~~

2. Añade la variable int HighestScore para rastrear al jugador con la puntuación más alta, así como una variable de opción de referencia a ese jugador WinningPlayer.

   Verse

                var HighestScore:int = -1
                var WinningPlayer:?agent = false
   

   Copy full snippet(2 lines long)

3. En una expresión for/do, obtén todos los jugadores en el espacio de juego y, a continuación, obtén el FortCharacter de cada uno de ellos. Congela al personaje en su lugar mediante PutInStasis() al pasar un nuevo conjunto de stasis_args para permitir el uso de gestos y girar para que los jugadores puedan celebrar la partida.

   Verse

                for:
                    Player : GetPlayspace().GetPlayers()
                    FortCharacter := Player.GetFortCharacter[]
                do:
                    FortCharacter.PutInStasis(stasis_args{AllowTurning := true, AllowEmotes := true})
   

   Copy full snippet(5 lines long)

4. En una instrucción if, comprueba la puntuación de cada jugador para encontrar y almacenar la puntuación ganadora en el dispositivo de referencia del jugador en la central.

   Verse

                    if (ScoreManager.GetCurrentScore(Player) > HighestScore):
   		                
                        set HighestScore = ScoreManager.GetCurrentScore(Player)
                        set WinningPlayer = option{Player}
   

   Copy full snippet(4 lines long)

5. Por último, en otra instrucción if, llama a TeleportPlayersToHUB() para teletransportar a todos de vuelta a la central cuando se encuentre una puntuación ganadora.

   Verse

                if(Winner := WinningPlayer?):
                    PlayerReference.Register(Winner)
   		
                TeleportPlayersToHUB()
   

   Copy full snippet(4 lines long)

Cómo teletransportar a los jugadores de vuelta a la central

Cuando se hayan calculado las puntuaciones y se haya declarado un ganador, todos los jugadores deberán teletransportarse de vuelta a la central.

1. Añade un nuevo método TeleportPlayersToHUB() a la definición de la clase tiltnboom. Este método habilita todos los generadores de jugadores en la central y, a continuación, espera unos segundos antes de teletransportar a todos de vuelta a la central. Este método también debería activar el EndGameTrigger para eliminar la cámara y los dispositivos de control de los jugadores.

   Verse

            TeleportPlayersToHUB()<suspends>:void=
   
                for (HUBSpawner : HUBSpawners):
                    HUBSpawner.Enable()
   
                Sleep(DelayAfterGame)
   
                EndGameTrigger.Trigger()

   Copy full snippet(8 lines long)

2. En una expresión for, teletransporta a cada jugador de vuelta al HUBTeleporter y vuelve a permitir que se muevan libremente.

   Verse

                for:
                    Player : GetPlayspace().GetPlayers()
                    FortCharacter := Player.GetFortCharacter[]
                do:
                    HUBTeleporter.Teleport(Player)
   		
                    Sleep(1.0)
   		
                    FortCharacter.ReleaseFromStasis()
   

   Copy full snippet(9 lines long)

Por tu cuenta

Modifica este código y crea diferentes tareas para que las realice el dispositivo Temporizador. En lugar de determinar la duración de un minijuego, puedes utilizar el dispositivo Temporizador para cronometrar una carrera.

    using { /Fortnite.com/Characters }
    using { /Fortnite.com/Devices }
    using { /Fortnite.com/Game }
    using { /UnrealEngine.com/Temporary/Diagnostics }
    using { /Verse.org/Random }
    using { /Verse.org/Simulation }

    tiltnboom_log_channel := class(log_channel){}

    # A Verse-authored creative device that can be placed in a level