Równoważenie drużyn w trybie wieloosobowym

W grach wieloosobowych drużyny graczy współzawodniczą lub współpracują, aby osiągnąć jakiś cel. Liczba graczy w każdej drużynie może mieć decydujący wpływ na rozgrywkę. Wielu twórców wybiera konkretny stosunek liczby graczy, aby przygoda z grą była bardziej wciągająca.

Równoważenie drużyn przydziela graczy do drużyn według zadanego stosunku. W większości gier wieloosobowych gracze są przydzielani po równo, aby żadna drużyna nie miała przewagi. W niektórych grach proporcje liczby graczy są celowo nierówne, np. wystawianie czwórki graczy przeciwko jednemu graczowi o znacznie większych mocach, z lepszym wyposażeniem itp. Niezależnie od konfiguracji, równowaga drużyny ma decydujące znaczenie przy tworzeniu lepszych, fascynujących przygód dla wieloosobowych drużyn.

Po ukończeniu tego samouczka dowiesz się, jak dynamicznie równoważyć drużyny graczy w trakcie gry oraz za każdym razem, gdy dołączy nowy gracz. Do celów odniesienia, na końcu tego przewodnika znajduje się kompletny skrypt.

Używane funkcje języka Verse

• array: To urządzenie używa tablic do przechowywania odwołania do każdej drużyny.

• option: To urządzenie używa opcji, aby określić, czy istnieje drużyna, w której jest mniej graczy niż w drużynie, w której jest aktualnie dany gracz.

• for: Wyrażenie for umożliwia iterację po tablicach używanych przez urządzenie.

• if: Wyrażenie if służy do sprawdzania, czy gracze powinni zostać przeniesieni do nowej drużyny na podstawie wielkości drużyn.

• failure: Konteksty niepowodzenia wykorzystuje się w celu uzyskania dostępu do tablic oraz sterowania przepływem programu.

Używane interfejsy API Verse

• Subskrybowalne: Będziesz subskrybować PlayerAddedEvent(), aby dynamicznie zmieniać równowagę drużyn, gdy do trwającej gry dołączy nowy gracz.

• Drużyny: Klasa drużyn umożliwia dodawanie graczy do drużyn oraz ich usuwanie i pobieranie. W samouczku będziesz używać klasy drużyny, aby bezpośrednio manipulować graczami i ich przypisaniem do drużyny.

• Przestrzeń gry: Przestrzeń gry pozwala śledzić zdarzenia, które można subskrybować, związane z dołączaniem graczy do gry oraz opuszczaniem gry przez graczy. Obsługuje też pobieranie list graczy i drużyn oraz znajdowanie drużyny dla danego gracza. W tym samouczku zasubskrybujesz wiele zdarzeń przestrzeni gry oraz pobierzesz graczy i drużyny przy użyciu metod przestrzeni gry, aby nimi bezpośrednio manipulować.

Ustawianie poziomu

W tym przykładzie wykorzystano następujące urządzenie.

4 x urządzenie Panelu startowego gracza: To urządzenie określa, w którym miejscu na początku gry spawnuje się gracz.

Postępuj zgodnie z poniższą instrukcją, aby skonfigurować swój poziom:

1. Dodaj do poziomu Panel startowy gracza.

2. W Outlinerze wybierz panel startowy, aby otworzyć dla niego panel Szczegóły.

3. W Opcjach użytkownika w panelu Szczegóły:

   • W pozycji Drużyna graczy wybierz opcję Indeks drużyny i ustaw dla niej wartość 1

   • Włącz Widoczność podczas gry

     

     Kliknij obraz, aby go powiększyć.

4. Zduplikuj panel startowy i umieść go obok pierwszego panelu startowego.

5. Zduplikuj oba panele startowe i umieść je w dalszej odległości od pierwszej grupy paneli startowych. W tym miejscu będą się spawnowali gracze z Drużyny 2.

6. Wybierz zduplikowane panele startowe. W panelu Szczegóły, w Opcjach użytkownika zmień wartość Indeks drużyny na 2 dla obu paneli.

7. W Outlinerze wybierz urządzenie Ustawienia wyspy, aby otworzyć jego panel Szczegóły. W sekcji Opcje użytkownika – zasady gry:

   • W pozycji Drużyny wybierz opcję Indeks drużyny i ustaw dla niej wartość 2. W tym przykładzie używa się dwóch drużyn, ale możesz ich ustawić tyle, ile chcesz.

   • W pozycji Liczebność drużyn wybierz ustawienie Dynamiczna. Dzięki temu kod Verse może przejąć zadania równoważenia drużyn.

   • W pozycji Dołączanie w toku wybierz ustawienie Spawn, aby nowi gracze mogli dołączać do gry w trakcie jej trwania.

     

     Kliknij obraz, aby go powiększyć.

8. Utwórz nowe urządzenie Verse o nazwie team_multiplayer_balancing za pomocą Eksploratora Verse i przeciągnij je do poziomu. (Aby dowiedzieć się, jak utworzyć nowe urządzenie w Verse, patrz: Tworzenie własnego urządzenia przy użyciu Verse).

Poziom powinien wyglądać mniej więcej następująco:

Rozdzielanie drużyn po równo

Równoważenie drużyn na początku gry

Ten krok pokazuje, jak rozdzielić graczy po równo na początku gry oraz gdy dołączy nowy gracz.

1. Otwórz Eksplorator Verse i kliknij dwukrotnie team_multiplayer_balancing.verse, aby otworzyć skrypt w Visual Studio Code.

2. W definicji klasy team_multiplayer_balancing dodaj tablicę zmiennych team o nazwie Teams, będzie ona przechowywała odwołania do każdej drużyny, w której są gracze.

   Verse

        team_multiplayer_balance := class(creative_device):
            # Holds the teams found with GetTeams() 
            var Teams : []team = array{}
   

   Copy full snippet(3 lines long)

3. W funkcji OnBegin() zaktualizuj tablicę Drużyn, aby pasowała do drużyn skonfigurowanych wcześniej w Ustawieniach wyspy. Wywołaj funkcję GetTeams() z interfejsu API fort_team_collection, aby pobrać wszystkie drużyny w przestrzeni gry.

   Verse

        OnBegin<override>()<suspends>:void=
            Print("Verse Device Started!")
            set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()

   Copy full snippet(3 lines long)

4. Znajdź wszystkich graczy w grze, wywołując funkcję GetPlayers(), i zapisz ich w tablicy graczy o nazwie AllPlayers.

   Verse

        OnBegin<override>()<suspends>:void=
            Print("Verse Device Started!")
            set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()
            AllPlayers := GetPlayspace().GetPlayers()

   Copy full snippet(4 lines long)

5. Przeiteruj przez listę wszystkich graczy i utwórz drużyny o tej samej liczbie graczy. Drużynę, w której jest obecnie gracz, porównasz z innymi drużynami i określisz, czy najbardziej pasuje ona do danego gracza. W tym przypadku za pomocą GetTeam[] możesz użyć drużyny, do której gracz na początku gry jest automatycznie przypisywany (ponieważ w grach z wieloma drużynami gracz musi należeć do jakiejś drużyny). Pamiętaj, że GetTeam[] wymaga agenta typu jako parametru, ale gracz jest podklasą agenta, dlatego możesz przekazać gracza bez rzutowania typu.

   Verse

        AllPlayers := GetPlayspace().GetPlayers()
        for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]):
            # Assign Players to a new team if teams are unbalanced
   

   Copy full snippet(3 lines long)

   Drużyna jest klasą wewnętrzną, dlatego nie można jej zainicjować. Można jej używać tylko jako odniesienia do istniejącego obiektu drużyny.

6. Chcesz przypisywać graczy do drużyny, w której jest najmniej graczy, aż wszystkie drużyny będą zrównoważone. W tym celu musisz sprawdzić każdego gracza, a potem każdą drużynę za pomocą pętli for. Możesz użyć dwóch pętli, jednej do iterowania przez graczy, a drugiej do iterowania przez drużyny, ale w tym przykładzie wyodrębnisz drużynę, aby weszła do pętli własnej metody. Utwórz gracza dla pętli, uzyskując odwołanie do każdego gracza, a następnie odwołanie do każdej drużyny, w której są gracze, w stałej o nazwie CurrentTeam.

   • Utwórz nową zmienną liczby całkowitej TeamSize i zainicjuj ją z wartością 0, następnie ustaw ją tak, aby była równa liczebności drużyny, do której aktualnie należy gracz. Wyrażenie GetAgents[] może się zakończyć niepowodzeniem, więc musisz zamknąć to ustawienie w instrukcji if.

     Verse

       for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]):
           # Assign Players to a new team if teams are unbalanced
           var TeamSize : int = 0
           if(set TeamSize = GetPlayspace().GetTeamCollection().GetAgents[CurrentTeam].Length):
               Print("Size of this player's starting team is {TeamSize}")
     

     Copy full snippet(5 lines long)

   • Utwórz metodę o nazwie FindSmallestTeam(). Po przekazaniu jej TeamSize jako argumentu, zwróci ona opcjonalną drużynę (?team) i obsłuży znalezienie i zwrócenie drużyny, w której jest najmniej graczy. Zainicjuj nową opcję drużyny o nazwie SmallestTeam wewnątrz FindSmallestTeam(). W tym miejscu użyjesz opcji, ponieważ w momencie wywołania FindSmallestTeam() gracz może już należeć do najmniejszej drużyny.

   • Domyślnie twoja opcja SmallestTeam ma wartość false i pozostanie false, jeśli nie zostanie znaleziona mniejsza drużyna. Gdy FindSmallestTeam() zwróci false, wiesz na pewno, że gracz należy do najmniejszej drużyny. Musisz też zainicjować zmienną typu całkowitego CurrentTeamSize na wartość TeamSize. CurrentTeamSize musi być zmienną, aby można ją było uaktualnić do liczebności innej znalezionej najmniejszej drużyny.

     Verse

                               FindSmallestTeam(CurrentTeamSize : int) : ?team=
                                   var SmallestTeam : ?team = false     
                                   var TeamSize : int = CurrentTeamSize
     

     Copy full snippet(3 lines long)

   • Ponieważ TeamSize śledzi liczebność SmallestTeam, musisz ją porównać z liczebnością każdej drużyny. Przeiteruj przez każdą drużynę i pobierz jej liczebność do lokalnej zmiennej typu całkowitego CandidateTeamSize. Jeśli CandidateTeamSize jest mniejsza niż TeamSize, ustaw SmallestTeam na tę drużynę, a TeamSize na liczebność tamtej drużyny.

     Warunek TeamSize > CandidateTeamSize to warunek filtra, ponieważ jest sprawdzany w nawiasach pętli for. Zastosowanie warunku filtra gwarantuje, że kod w pętli wykona się tylko, gdy warunek filtra zostanie spełniony. To gwarantuje, że SmallestTeam zostanie ustawiona na drużynę, w której jest najmniej graczy, o ile taka drużyna zostanie znaleziona. Jeśli nie znajdzie się drużyna, w której jest mniej graczy, SmallestTeam będzie miała dalej wartość false.

     Na koniec zwróć wartość SmallestTeam po sprawdzeniu wszystkich drużyn.

     Verse

      for(Team : Teams, CandidateTeamSize := GetPlayspace().GetTeamCollection().GetAgents[Team].Length, TeamSize > CandidateTeamSize):
       set SmallestTeam = option{Team}
       set TeamSize = CandidateTeamSize
       Print("Found a team with less players: {CandidateTeamSize}")               
      return SmallestTeam
     

     Copy full snippet(5 lines long)

   • W OnBegin() utwórz nową opcję drużyny o nazwie SmallestTeam wewnątrz pętli for i zainicjuj ją wartością FindSmallestTeam(), przekazując TeamSize jako argument.

     Verse

       SmallestTeam : ?team = FindSmallestTeam(TeamSize)
     

     Copy full snippet(1 line long)

   • Następnie spróbuj uzyskać dostęp do wartości w opcjonalnej zmiennej SmallestTeam. Jeśli wartość to false, gracz jest już w najmniejszej drużynie i nie trzeba wykonywać przypisania. W przeciwnym razie przypisz gracza do nowej drużyny. Wiele metod nie pozwala nam na bezpośrednie przekazywanie opcji jako argumentu, dlatego musisz wyodrębnić wartość do lokalnej zmiennej TeamToAssign. Możesz spróbować przypisać gracza do tej drużyny przy użyciu AddToTeam[player, team]. Zwróć uwagę, że to przypisanie się nie uda, jeśli spróbujesz przypisać gracza do drużyny, do której już należy. Nie będzie to miało żadnych negatywnych konsekwencji, ponieważ pętla for po prostu przejdzie do kolejnego gracza, a pierwszego zostawi w oryginalnej drużynie.

     Verse

       if (TeamToAssign := SmallestTeam?, GetPlayspace().GetTeamCollection().AddToTeam[TeamPlayer, TeamToAssign]):
           Print("Attempting to assign player to a new team")
     

     Copy full snippet(2 lines long)

7. OnBegin() powinna wyglądać tak, jak poniższy blok kodu.

   Verse

        OnBegin<override>()<suspends> : void =
            Print("Verse Device Started!")
            set Teams = Self.GetPlayspace().GetTeamCollection().GetTeams()
            Print("Beginning to Assign Players")
            Playspace := GetPlayspace()
            AllPlayers := Playspace.GetPlayers()
            for (TeamPlayer : AllPlayers, CurrentTeam := Playspace.GetTeamCollection().GetTeam[TeamPlayer]):
                var TeamSize : int = 0
                if(set TeamSize = Playspace.GetTeamCollection().GetAgents[CurrentTeam].Length):
                    Print("Size of this player's starting team is {TeamSize}")
   
   Expand code Copy full snippet(13 lines long)

Postępowanie z graczem dołączającym w trakcie gry

Chcesz też automatycznie równoważyć drużyny podczas trwającej gry. Dlatego musisz zasubskrybować zdarzenie, które uruchamia się w chwili, gdy dołącza nowy gracz. Nie chcesz powtarzać całego dopiero co napisanego kodu, więc możesz go przepisać na wspólną metodę.

1. Utwórz metodę o nazwie BalanceTeams() i przenieś cały kod od miejsca po ustawieniu zmiennej Teams przy użyciu GetTeams(). Jest to wywoływane w metodzie OnBegin(), dzięki czemu drużyny są zrównoważone w momencie rozpoczęcia gry. Funkcja BalanceTeams() powinna wyglądać następująco.

   Verse

        BalanceTeams() : void =
            AllPlayers := GetPlayspace().GetPlayers()
            for (TeamPlayer : AllPlayers, CurrentTeam := GetPlayspace().GetTeamCollection().GetTeam[TeamPlayer]):
                var TeamSize : int = 0
                if(set TeamSize = GetPlayspace().GetTeamCollection().GetAgents[CurrentTeam].Length):
                    Print("Size of this player's starting team is {TeamSize}")          
                SmallestTeam : ?team = FindSmallestTeam(TeamSize)
                if (TeamToAssign := SmallestTeam?, GetPlayspace().GetTeamCollection().AddToTeam[TeamPlayer, TeamToAssign]):
                    Print("Attempting to assign player to a new team")
   

   Copy full snippet(9 lines long)

2. Utwórz nową metodę o nazwie OnPlayerAdded(), która zawiera wywołanie BalanceTeams(). Nie będziesz używać zmiennej player, ale definicja tej metody jej wymaga, ponieważ przy jej użyciu subskrybujesz PlayerAddedEvent(). Więcej szczegółów na temat zdarzeń, które można subskrybować, patrz Kodowanie interakcji z urządzeniem.

   Verse

                                OnPlayerAdded(InPlayer : player) : void =
                                Print("A new Player joined, assigning them to a team!")
                                BalanceTeams()      
   

   Copy full snippet(3 lines long)

3. W metodzie OnBegin subskrybuj zdarzenie PlayerAddedEvent przestrzeni gry z użyciem metody OnPlayerAdded. Od teraz, gdy do gry dołączy gracz, OnPlayerAdded wywoła BalanceTeams(), aby automatycznie zrównoważyć drużyny.

   Verse

        OnBegin<override>()<suspends> : void =
                GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)
                Print("Beginning to balance teams")
                BalanceTeams()

   Copy full snippet(4 lines long)

4. Zapisz skrypt w Visual Studio Code i kliknij Skompiluj kod Verse, aby skompilować skrypt.

5. Na pasku narzędzi UEFN kliknij Uruchom sesję, aby przetestować poziom w grze.

W trakcie wykonywania testu gry poziomu, w dzienniku wyjściowym powinny być zapisane komunikaty o liczebności każdej drużyny i wszystkich mniejszych drużynach, które znalazł skrypt. Gracze powinni być po równo rozdzieleni po drużynach, a nowy gracz dołączający do gry powinien utrzymywać tę równowagę.

Kompletny skrypt

Poniższy kod to kompletny skrypt urządzenia, które automatycznie równoważy drużyny graczy.

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

    team_multiplayer_balance := class(creative_device):
        # Holds the teams found with GetTeams()
        var Teams : []team = array{}
        OnBegin<override>()<suspends> : void =

            Print("Verse Device Started!")

Praca własna

Dzięki tej instrukcji wiesz, jak stworzyć w Verse urządzenie, które automatycznie równoważy drużyny graczy.

Wykorzystując zdobytą wiedzę, utwórz celowo niezrównoważone drużyny dla asymetrycznych trybów gry, takich jak jeden gracz kontra wielu graczy.