Gerenciador de jogos reutilizável

Esse tutorial usa o Verse para possibilitar certas funcionalidades. Ao usar Verse neste tutorial, você pode:

• Acione e reproduza animações de maneira intermitente para criar uma mecânica de jogabilidade.

• Atualiza as informações de pontuação do jogador para todos os jogadores em um minijogo.

• Crie atrasos de surgimento de jogadores e tempos intermitentes de surgimento de itens.

É possível reutilizar esse código para realizar as seguintes tarefas:

• Alterne os dispositivos que estão habilitados e desabilitados enquanto o jogo faz a transição do HUB para a jogabilidade e de volta para o HUB.

• Verifique as pontuações dos jogadores para encontrar a vencedora e exibi-la no HUB.

• Termine o jogo e teletransportar os jogadores de volta ao HUB no final do minijogo.

Configurar o dispositivo Verse e objetos editáveis

Siga estas etapas para configurar seu dispositivo Verse e objetos editáveis:

1. Crie um novo dispositivo Verse chamado tiltnboom e adicione-o ao nível. Consulte Criar o próprio dispositivo usando Verse para ver as etapas.

2. Adicione os seguintes módulos na parte superior do arquivo:

   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. Adicione os seguintes campos à definição de classe tiltnboom:

   1. Dois dispositivos Gatilho editáveis; ActivateGameTrigger e EndGameTrigger. ActivateGameTrigger é usado para ativar esse jogo. O gatilho pode ser acionado por qualquer coisa, como um Teletransportador para o jogo ou após uma cinematografia de introdução.

      O EndGameTrigger é usado para encerrar o minijogo e remover todas as câmeras e dispositivos de controle dos jogadores após o término do jogo.

   Verse

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

   Copy full snippet(5 lines long)

   1. Um dispositivo Temporizador editável chamado GameTimer. Ele encerra o jogo após um certo período de tempo.

   2. Uma matriz CannonballSequences de dispositivos de Sequência cinematográfica que reproduzem uma posição de pouso de bala de canhão diferente.

   3. Uma matriz DamageVolumes de Volumes de dano que são ativados e desativados com base no estado do jogo.

   4. Uma matriz ItemSpawners de Geradores de itens que geram aleatoriamente um número aleatório de itens durante o jogo.

   5. Um dispositivo de Área de captura denominado CaptureArea. Isso dá pontos aos jogadores por estarem na jangada e pode ser habilitado ou desabilitado com base no estado do jogo.

   6. Um dispositivo Gerenciador de pontuação denominado ScoreManager, que restaura a pontuação dos jogadores quando o jogo começa e determina o jogador vencedor no final do jogo.

   7. Um Teletransportador chamado HUBTeleporter que traz todos de volta ao HUB após o término do jogo.

   8. Um dispositivo de Referência de jogador denominado PlayerReference, que exibe o jogador vencedor no HUB entre os jogos.

      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. Duas matrizes editáveis de Plataformas de surgimento de jogadores denominadas PlayerSpawners e HUBSpawners. Elas desabilitam o surgimento quando o minijogo termina e retornam os jogadores ao HUB em seguida.

   Verse

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

   Copy full snippet(5 lines long)

5. Dois floats editáveis chamados MinimumItemSpawnTime e MaximumItemSpawnTime. Estes são os tempos mínimo e máximo de espera entre o surgimento dos itens na jangada.

   Verse

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

   Copy full snippet(5 lines long)

6. Um float editável chamado DelayAfterGame. Este é o atraso para teletransportar os jogadores de volta ao HUB quando o jogo termina.

   Verse

            @editable
            DelayAfterGame:float = 5.0
   

   Copy full snippet(2 lines long)

7. Um float chamado DelayBetweenCannonballSequences. Este é o atraso para o surgimento de balas de canhão entre as sequências durante o minijogo.

   Verse

        DelayBetweenCannonballSequences:float = 8.0
   

   Copy full snippet(1 line long)

8. Uma variável lógica chamada GameActive para determinar se o jogo está ativo ou não.

   Verse

            var GameActive:logic = false
   

   Copy full snippet(1 line long)

Iniciar o jogo

Quando o minijogo começa, vários dispositivos são habilitados, e a pontuação do jogador é zerada.

1. Acima da definição da classe tiltnboom, adicione um canal de log para imprimir mensagens específicas do minijogo. Em seguida, adicione um Logger à definição de classe para usar com o canal de log.

   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. Adicione um novo método OnTriggered à definição de classe titnboom que usa um InitiatingAgent e inicia o jogo. Adicione ao método uma expressão if que retornará se o jogo já está ativo, pois você não deseja iniciar esse jogo enquanto outro já está em execução.

   Verse

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

   Copy full snippet(5 lines long)

3. Em OnBegin(), inscreva o TriggeredEvent de ActivateGameTrigger na função OnTriggered para iniciar o jogo. Qualquer dispositivo que precisar ser habilitado no início do minijogo se inscreverá nesse evento e será habilitado quando o evento OnTrigger for acionado.

   Verse

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

   Copy full snippet(3 lines long)

4. Adicione um novo método StartGame() que lida com a lógica para iniciar o jogo. Adicione o modificador <suspends> a essa função para que ela possa ser executada de forma assíncrona.

   Primeiro, defina GameActive como true para sinalizar que o jogo está ativo. Em seguida, habilite CaptureArea e cada DamageVolume na matriz DamageVolumes.

   Para cada jogador, se esse jogador tiver uma pontuação superior a 0, restaure-a concedendo a ele o inverso de sua pontuação atual, o que define a pontuação como 0.

   Em seguida, em uma expressão race, corra entre o término do temporizador, a sequência de bala de canhão em execução e o surgimento de itens aleatórios. A sequência de bala de canhão e o surgimento de itens aleatórios são loops infinitos, mas são cancelados assim que o temporizador termina.

   Quando o jogo terminar, chame a função OnGameFinished() para lidar com a limpeza no final do jogo.

   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)

Criar um loop de bala de canhão

Esta seção aborda como adicionar uma função que reproduz as Sequências cinematográficas de bala de canhão.

1. Adicione um novo método StartCannonSequence() à definição de classe tiltnboom que reproduz as Sequências de nível de bala de canhão e usa um loop para reproduzir a expressão "delay" e inserir um atraso entre balas de canhão. Adicione o modificador <suspends> a essa função para que ela possa ser executada de forma assíncrona.

   Em um loop, escolha uma sequência aleatória na matriz CannonballSequences, indexando-a com GetRandomInt(). Reproduza a sequência e aguarde um período de tempo DelayBetweenCannonballSequences antes de reproduzir outra sequência.

   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)

Criar loops de itens de geração aleatória

Esta seção aborda a criação de uma função que gera itens aleatórios em locais aleatórios na jangada, o que pode aumentar ou diminuir as chances dos jogadores de ganhar o minijogo.

1. Adicione um novo método chamado SpawnRandomItems à definição de classe titlnboom. Esse método controla os itens que aparecem na jangada.

2. Obtenha o número de itens na matriz ItemSpawners e, em seguida, faça loop na matriz. Use um int aleatório para obter um gerador de itens aleatório da matriz e ative-o em seguida. Aguarde um período de tempo aleatório entre o surgimento dos itens.

3. O loop decide aleatoriamente quantos itens gerar e seleciona também aleatoriamente um item para gerar, conforme definido em NumberOfItemsToSpawn. O DelayBetweenItemSpawns gera uma quantidade indeterminada de tempo para esperar entre os surgimentos.

   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)

Encerrar o jogo

Ao final do minijogo, você precisará enviar a pontuação do vencedor para o HUB, desabilitar dispositivos e teletransportar os jogadores de volta para o HUB.

1. Adicione um novo método OnGameFinished à definição de classe tiltnboom. Quando o jogo terminar, essa função deixará o jogo inativo e desabilitará os dispositivos relevantes.

   ~~~(verse) OnGameFinished()<suspends>:void= Logger.Print("O jogo terminou.") set GameActive = false

   CaptureArea.Disable()

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

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

2. Adicione a variable int HighestScore para rastrear o jogador com a pontuação mais alta, além de uma referência de variável de opção para esse jogador WinningPlayer.

   Verse

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

   Copy full snippet(2 lines long)

3. Em uma expressão for/do, obtenha todos os jogadores no espaço de jogo e, em seguida, obtenha o FortCharacter para cada um deles. Congele o personagem no lugar usando PutInStasis(), passando um novo conjunto de stasis_args para permitir gestos e giros, de forma que os jogadores possam comemorar o jogo.

   Verse

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

   Copy full snippet(5 lines long)

4. Em uma declaração if, verifique a pontuação de cada jogador para encontrar e armazenar a pontuação vencedora no dispositivo de Referência de jogador no HUB.

   Verse

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

   Copy full snippet(4 lines long)

5. Por último, em outra instrução if, chame TeleportPlayersToHUB() para teletransportar todos de volta ao HUB quando uma pontuação vencedora for encontrada.

   Verse

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

   Copy full snippet(4 lines long)

Teletransportar jogadores de volta ao HUB

Quando as pontuações forem calculadas e o vencedor for declarado, todos os jogadores deverão se teletransportar de volta para o HUB.

1. Adicione um novo método TeleportPlayersToHUB() à definição da classe tiltnboom. Este método habilita todos os geradores de jogadores no HUB e espera alguns segundos antes de teletransportar todos de volta ao HUB. Esse método também deve acionar o EndGameTrigger para remover câmeras e dispositivos de controle dos jogadores.

   Verse

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

   Copy full snippet(8 lines long)

2. Em uma expressão for, teletransporte cada jogador de volta ao HUBTeleporter e libere-os do congelamento.

   Verse

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

   Copy full snippet(9 lines long)

Por si só

Modifique esse código para criar tarefas diferentes para o dispositivo de Temporizador executar. Em vez de determinar a duração de um minijogo, você pode usar o dispositivo de Temporizador para cronometrar uma corrida.

    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