Menedżer gry wielokrotnego użytku

Ten samouczek wykorzystuje Verse, aby można było skorzystać z niektórych funkcji. Dzięki wykorzystaniu Verse w tym samouczku, możesz:

• Co pewien czas aktywuj i odtwarzaj animacje, aby utworzyć mechanikę rozgrywki.

• Aktualizuj informacje o wyniku gracza dla wszystkich graczy w minigrze.

• Twórz opóźnienia spawnu gracza i losowe czasy spawnu przedmiotów.

Możesz ponownie wykorzystać kod, aby wykonać następujące zadania:

• Przełączaj urządzenia, które są włączone i wyłączone w momencie, gdy gra przechodzi z HUB-u do rozgrywki i z powrotem do HUB-u.

• Sprawdzaj wyniki graczy, aby wyszukać najlepszy wynik i wyświetlić go w HUB-ie.

• Zakończ grę i teleportuj graczy z powrotem do HUB-u po zakończeniu minigry.

Konfiguracja urządzenia Verse i edytowalnych obiektów

Postępuj zgodnie z poniższą instrukcją, aby skonfigurować urządzenie Verse i edytowalne obiekty:

1. Utwórz nowe urządzenie Verse o nazwie tiltnboom i dodaj je do poziomu. Aby uzyskać informacje na ten temat, patrz: Tworzenie własnego urządzenia przy użyciu Verse.

2. Na początku pliku dodaj następujące moduły:

   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. Dodaj następujące pola do definicji klasy tiltnboom:

   1. Dwa edytowalne urządzenia trigger; ActivateGameTrigger i EndGameTrigger. ActivateGameTrigger służy do aktywacji gry. Ten aktywator może zostać aktywowany przez cokolwiek, np. przez teleporter do gry lub po filmiku otwierającym.

      EndGameTrigger służy do zakończenia minigry i usunięcia wszystkich kamer i urządzeń sterujących z graczy, gdy gra się skończy.

   Verse

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

   Copy full snippet(5 lines long)

   1. Edytowalne urządzenie licznika czasu o nazwie GameTimer. Kończy grę po upływie określonego czasu.

   2. Tablica array urządzeń sekwencji filmowej o nazwie CannonballSequences, każde urządzenie w tablicy odtwarza inną pozycję lądowania kuli armatniej.

   3. Tablica przestrzeni obrażeń o nazwie DamageVolumes, które są włączane i wyłączane na podstawie stanu gry.

   4. Tablica generatorów przedmiotów o nazwie ItemSpawners, która losowo spawnuje losową liczbę przedmiotów w trakcie gry.

   5. Urządzenie strefy punktowanej o nazwie CaptureArea. Przyznaje graczom punkty za przebywanie na tratwie, jest włączane i wyłączane na podstawie stanu gry.

   6. Urządzenie menedżera wyników o nazwie ScoreManager, które resetuje wyniki graczy, gdy gra się rozpoczyna, a w momencie zakończenia gry określa, który gracz wygrał.

   7. Teleporter o nazwie HUBTeleporter, który po zakończeniu gry przenosi wszystkich z powrotem do HUB-u.

   8. Urządzenie odwołania do gracza o nazwie PlayerReference, które wyświetla zwycięskiego gracza w HUB-ie między grami.

      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. Dwie edytowalne tablice paneli startowych gracza o nazwach PlayerSpawners i HUBSpawners. Wyłączają spawnowanie, gdy minigra się zakończy, i zabierają graczy z powrotem do HUB-u po minigrze.

   Verse

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

   Copy full snippet(5 lines long)

5. Dwie edytowalne wartości float o nazwach MinimumItemSpawnTime i MaximumItemSpawnTime. Są to minimalne i maksymalne czasy oczekiwania na spawnowanie kolejnych przedmiotów na tratwie.

   Verse

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

   Copy full snippet(5 lines long)

6. Edytowalna wartość float o nazwie DelayAfterGame. Opóźnienie teleportowania graczy z powrotem do HUB-u po zakończeniu gry.

   Verse

            @editable
            DelayAfterGame:float = 5.0
   

   Copy full snippet(2 lines long)

7. Wartość float o nazwie DelayBetweenCannonballSequences. Opóźnienie spawnowania kul armatnich między sekwencjami przez cały czas trwania minigry.

   Verse

        DelayBetweenCannonballSequences:float = 8.0
   

   Copy full snippet(1 line long)

8. Logiczna zmienna o nazwie GameActive służąca do określania, czy gra jest aktywna.

   Verse

            var GameActive:logic = false
   

   Copy full snippet(1 line long)

Rozpoczynanie gry

Gdy minigra się rozpoczyna, zostaje uruchomionych kilka urządzeń, a wynik gracza resetuje się do 0.

1. Nad definicją klasy tiltnboom dodaj kanał dziennika, aby zapisywać komunikaty charakterystyczne dla minigry. Następnie do definicji klasy dodaj rejestrator, który będzie używany z kanałem dziennika.

   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. Dodaj nową metodę OnTriggered do definicji klasy tiltnboom, która przyjmuje InitiatingAgent i uruchamia grę. Do metody dodaj wyrażenie if, które zwraca, czy gra jest już aktywna, aby uniknąć rozpoczęcia gry, gdy inna gra jest już uruchomiona.

   Verse

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

   Copy full snippet(5 lines long)

3. W OnBegin() zasubskrybuj TriggeredEvent aktywatora ActivateGameTrigger do funkcji OnTriggered, aby rozpocząć grę. Każde urządzenie, które musi zostać włączone na początku minigry, zasubskrybuje to zdarzenie i włączy się po aktywowaniu zdarzenia OnTrigger.

   Verse

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

   Copy full snippet(3 lines long)

4. Dodaj nową metodę StartGame(), która obsługuje logikę, aby rozpocząć grę. Dodaj modyfikator <suspends> do tej funkcji, aby mogła działać asynchronicznie.

   Najpierw ustaw GameActive na true, aby zasygnalizować, że gra jest aktywna. Następnie włącz CaptureArea i każdą przestrzeń obrażeń DamageVolume w tablicy DamageVolumes.

   Dla każdego gracza, jeśli jego wynik jest większy niż 0, zresetuj wynik, przyznając graczowi odwrotność bieżącego wyniku, co ustawi jego wynik na 0.

   Następnie w wyrażeniu race ustaw wyścig między zakończeniem licznika czasu, wykonaniem sekwencji kuli armatniej i spawnowaniem losowych przedmiotów. Sekwencja kuli armatniej i spawnowanie losowych przedmiotów to pętle nieskończone, ale są anulowane natychmiast po zakończeniu licznika czasu.

   Gdy gra się skończy, wywołaj funkcję OnGameFinished(), aby obsłużyć czyszczenie na koniec gry.

   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)

Tworzenie pętli kuli armatniej

W tej sekcji opisano dodawanie funkcji, która odtwarza sekwencje filmowe kuli armatniej.

1. Dodaj nową metodę StartCannonSequence() do definicji klasy tiltnboom, która odtwarza sekwencje poziomu kuli armatniej i używa pętli, aby odtwarzać wyrażenie opóźnienia i wstawiać opóźnienie między kulami armatnimi. Dodaj modyfikator <suspends> do tej funkcji, aby mogła działać asynchronicznie.

   W pętli wybierz losową sekwencję w tablicy CannonballSequences, indeksując ją przy użyciu GetRandomInt(). Odtwórz sekwencję, a następnie uśpij na czas DelayBetweenCannonballSequences przed odtworzeniem kolejnej sekwencji.

   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)

Tworzenie pętli losowego spawnowania przedmiotów

W tej sekcji opisano tworzenie funkcji, która zapętla spawnowanie losowych przedmiotów w losowych lokalizacjach na tratwie, co może zarówno pomóc, jak i przeszkodzić graczom w wygraniu minigry.

1. Dodaj nową metodę o nazwie SpawnRandomItems do definicji klasy tiltnboom. Ta metoda kontroluje przedmioty, które spawnują się na tratwie.

2. Pobierz liczbę przedmiotów w tablicy ItemSpawners, a następnie zapętl przejście przez tablicę. Użyj losowej wartości int, aby pobrać losowy generator przedmiotów z tablicy, następnie go aktywuj. Uśpij na losowy czas między spawnowaniem przedmiotów.

3. Pętla losowo decyduje, ile przedmiotów zespawnować, i losowo wybiera przedmiot do zespawnowania, tyle razy, ile wynosi NumberOfItemsToSpawn. DelayBetweenItemSpawns generuje nieustaloną z góry długość czasu oczekiwania między spawnami.

   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)

Kończenie gry

Na koniec minigry musisz wysłać wynik zwycięzcy do HUB-u, wyłączyć urządzenia i teleportować graczy z powrotem do HUB-u.

1. Dodaj nową metodę OnGameFinished do definicji klasy tiltnboom. Gdy gra się skończy, ta funkcja ustawi grę na nieaktywną i wyłączy odnośne urządzenia.

   ~~~(verse) OnGameFinished()<suspends>:void= Logger.Print("Koniec gry.") set GameActive = false

   CaptureArea.Disable()

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

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

2. Dodaj zmienną int o nazwie HighestScore, aby śledzić gracza z najwyższym wynikiem, a także odwołanie do zmiennej opcji do tego gracza WinningPlayer.

   Verse

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

   Copy full snippet(2 lines long)

3. W wyrażeniu for/do pobierz wszystkich graczy w przestrzeni gry, następnie dla każdego z nich pobierz FortCharacter. Unieruchom postać w miejscu za pomocą PutInStasis(), przekazując nowy zestaw stasis_args, aby umożliwić wstawianie emotek i obracanie się, dzięki czemu gracze będą mogli świętować zakończenie gry.

   Verse

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

   Copy full snippet(5 lines long)

4. W instrukcji if sprawdź wynik każdego gracza, aby wyszukać i przechować zwycięski wynik w urządzeniu odwołania do gracza w HUB-ie.

   Verse

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

   Copy full snippet(4 lines long)

5. Na koniec, w innej instrukcji if, wywołaj TeleportPlayersToHUB(), aby po wyszukaniu zwycięskiego wyniku teleportować wszystkich z powrotem do HUB-u.

   Verse

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

   Copy full snippet(4 lines long)

Teleportowanie graczy z powrotem do HUB-u

Po obliczeniu wyników i ogłoszeniu zwycięzcy wszyscy gracze powinni się teleportować z powrotem do HUB-u.

1. Dodaj nową metodę TeleportPlayersToHUB() do definicji klasy tiltnboom. Ta metoda włącza wszystkie punkty spawnu gracza w HUB-ie, następnie odczekuje kilka sekund, zanim przeteleportuje wszystkich z powrotem do HUB-u. Ta metoda powinna też aktywować EndGameTrigger, aby usunąć kamerę i urządzenia sterujące z graczy.

   Verse

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

   Copy full snippet(8 lines long)

2. W wyrażeniu for teleportuj każdego gracza z powrotem do HUBTeleporter i zwolnij go z trybu bezruchu.

   Verse

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

   Copy full snippet(9 lines long)

Praca własna

Zmodyfikuj kod, aby utworzyć różne zadania do wykonania przez urządzenie licznika czasu. Zamiast określania czasu trwania minigry, możesz użyć urządzenia licznika czasu, aby odmierzyć czas wyścigu.

    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