Team-Multiplayer-Balancing

In Multiplayer-Spielen treten Teams von Spielern gegeneinander an oder arbeiten zusammen, um ein bestimmtes Ziel zu erreichen. Die Anzahl der Spieler in jedem Team kann radikale Auswirkungen auf das Gameplay haben, und viele Entwickler wählen ein bestimmtes Verhältnis von Spielern, um ein angenehmes Erlebnis zu schaffen.

Beim Team-Balancing werden die Spieler in Teams aufgeteilt, die einem bestimmten Verhältnis folgen. Bei den meisten Multiplayer-Spielen sind die Teams gleichmäßig aufgeteilt, so dass kein Team einen Vorteil hat. Manche Spiele schaffen absichtlich unausgewogene Szenarien, indem sie beispielsweise vier Spieler gegen einen übermächtigen Spieler antreten lassen. Unabhängig von der Art des Spiels ist die Ausgewogenheit der Teams entscheidend für die Schaffung interessanter Erlebnisse für mehrere Spielerteams.

In diesem Leitfaden erfährst du, wie du Teams von Spielern zur Laufzeit dynamisch ausbalancieren kannst, und immer dann, wenn ein neuer Spieler dem Spiel beitritt. Das vollständige Script ist am Ende dieses Leitfadens als Referenz enthalten.

Verwendete Sprachfunktionen in Verse

• array: Dieses Gerät verwendet Arrays, um einen Verweis auf jedes Team zu speichern.

• option: Dieses Gerät verwendet Optionen, um festzustellen, ob es ein Team mit weniger Spielern gibt als das Team, in dem ein Spieler gerade spielt.

• for: Mit dem Ausdruck „for“ kannst du über die Arrays iterieren, die das Gerät verwendet.

• if: Der if-Ausdruck wird verwendet, um zu prüfen, ob Spieler aufgrund der Teamgrößen in ein neues Team wechseln sollten.

• failure: Fehlerkontexte werden verwendet, um auf Arrays zuzugreifen und den Programmablauf zu steuern.

Verwendete APIs in Verse

• Abonnierbar: Du abonnierst PlayerAddedEvent(), um die Teams dynamisch neu zusammenzustellen, wenn ein neuer Spieler einem laufenden Spiel beitritt.

• Teams: Die Team-Klasse fügt Spieler hinzu, entfernt sie und ruft sie aus Teams ab. In diesem Tutorial wirst du die Teamklasse verwenden, um Spieler und ihre Teamzuordnungen direkt zu bearbeiten.

• Spielbereich: Der Spielbereich verfolgt abonnierbare Events im Zusammenhang mit Spielern, die das Spiel betreten und verlassen. Außerdem kannst du Listen von Spielern und Teams abrufen und die Mannschaft eines bestimmten Spielers finden. In diesem Tutorial wirst du mehrere Spielbereich-Events abonnieren und Spieler und Teams mit Spielbereich-Methoden abrufen, damit du sie direkt bearbeiten kannst.

Level einrichten

In diesem Beispiel wird das folgende Gerät verwendet.

4 x Spieler-Spawnflächen-Gerät: Dieses Gerät legt fest, wo der Spieler zu Beginn des Spiels spawnen wird.

Befolge diese Schritte, um dein Level einzurichten:

1. Füge dem Level eine Spieler-Spawnfläche hinzu.

2. Wähle die Spawnfläche im Outliner aus, um ihr Details-Panel zu öffnen.

3. Im Details-Panel, unter Nutzeroptionen:

   • Setze Spieler-Team auf Team-Index mit einem Wert von 1

   • Aktiviere Im Spiel sichtbar

     

     Klicke auf das Bild, um es zu vergrößern.

4. Dupliziere die Spawnfläche und platziere sie neben der ersten Spawnfläche.

5. Dupliziere beide Spawnflächen und platziere sie weiter entfernt von der ersten Gruppe von Spawnflächen. Hier werden die Spieler von Team 2 spawnen.

6. Wähle die doppelten Spawnflächen aus und ändere im Details-Panel unter Benutzeroptionen den Wert von Team-Index für beide auf 2.

7. Wähle im Outliner das Gerät Insel-Einstellungen aus, um dessen Details-Panel zu öffnen. Unter Benutzeroptionen – Spielregeln:

   • Setze Teams auf Team-Index mit einem Wert von 2. In diesem Beispiel werden zwei Teams verwendet, aber du kannst eine beliebige Anzahl von Teams haben.

   • Setze Teamgröße auf Dynamisch. Das bedeutet, dass dein Verse-Code das Team-Balancing übernehmen kann.

   • Setze Bei laufendem Spiel beitreten auf Spawnen, damit neue Spieler dem Spiel beitreten können, während es läuft.

     

     Klicke auf das Bild, um es zu vergrößern.

8. Erstelle mit Verse Explorer ein neues Verse-Gerät mit dem Namen team_multiplayer_balancing und ziehe das Gerät in das Level. (Wie du ein neues Gerät in Verse erstellen kannst, erfährst du unter Erstelle dein eigenes Gerät mit Verse.)

Dein Level sollte so ähnlich aussehen wie diese Konfiguration:

Gleichmäßige Aufteilung der Teams

Balance der Teams zu Beginn des Spiels

In diesem Schritt wird gezeigt, wie die Spieler zu Beginn eines Spiels und bei Beitritt eines neuen Spielers gleichmäßig in Teams aufgeteilt werden.

1. Öffne Verse-Explorer und doppelklicke auf team_multiplayer_balancing.verse, um das Script in Visual Studio Code zu öffnen.

2. In der Klassendefinition von team_multiplayer_balancing füge ein variables Team-Array mit dem Namen Teams hinzu, das Verweise auf jedes Team speichert, dem die Spieler angehören.

   Verse

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

   Copy full snippet(3 lines long)

3. Aktualisiere in der OnBegin()- Funktion das Array Teams, um die Teams zuzuordnen, die du zuvor in den Inseleinstellungen eingerichtet hast. Rufe die Funktion GetTeams() aus der API fort_team_collection auf, um alle Teams im Spielbereich zu erhalten.

   Verse

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

   Copy full snippet(3 lines long)

4. Finde alle Spieler im Spiel, indem du die Funktion GetPlayers() aufrufst, und speichere sie in einem Spieler-Array namens 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. Gehe die Liste aller Spieler durch und bilde Teams mit der gleichen Anzahl von Spielern. Du vergleichst das Team, in dem ein Spieler derzeit spielt, mit allen anderen Teams und stellst fest, ob es am besten zu diesem Spieler passt. In diesem Fall kannst du das Team verwenden, dem ein Spieler automatisch zugewiesen wird, wenn das Spiel beginnt, indem du GetTeam[] verwendest (da Spieler in Spielmodi mit mehreren Teams einem Team angehören müssen). Beachte, dass GetTeam[] einen Parameter vom Typ „agent“ benötigt, aber da „player“ eine Subklasse von „agent“ ist, kannst du einen „player“ ohne Typ-Casting übergeben.

   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)

   Da `team` eine interne Klasse ist, kann sie nicht initialisiert werden und nur als Verweis auf ein bestehendes `team`-Objekt verwendet werden.

6. Du solltest die Spieler dem Team mit den wenigsten Spielern zuweisen, bis alle Teams ausgeglichen sind. Dazu musst du jeden Spieler und dann jedes Team mit einer for- Schleife überprüfen. Du könntest zwei for-Schleifen verwenden, eine für die Iteration durch Spieler und eine für die Iteration durch Teams, aber in diesem Beispiel wirst du die for-Schleife für das Team in eine eigene Methode extrahieren. Richte die Spieler-Schleife ein, indem du eine Referenz auf jeden Spieler und dann eine Referenz auf jedes Team, in dem sie sind, in einer Konstante namens CurrentTeam abrufst.

   • Erstelle eine neue Ganzzahl-Variable TeamSize, initialisiere sie auf 0 und setze sie dann gleich der Größe des Teams, in dem sich der Spieler gerade befindet. Da GetAgents[] ein fehlbarer Ausdruck ist, musst du diesen Satz in eine if-Anweisung einschließen.

     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)

   • Erstelle eine Methode namens FindSmallestTeam(). Dies gibt ein optionales Team (?team) zurück, wenn TeamSize als Argument übergeben wird, und handhabt das Suchen und die Rückgabe des Teams mit den wenigsten Spielern. Initialisiere eine neue Team-Option mit dem Namen SmallestTeam innerhalb von FindSmallestTeam(). Du verwendest hier eine Option, weil ein Spieler bereits im kleinsten Team sein kann, wenn du FindSmallestTeam() aufrufst.

   • Da deine Option SmallestTeam standardmäßig auf false gesetzt ist, bleibt sie false, wenn kein kleineres Team gefunden wird. Wenn FindSmallestTeam() den Wert false zurückgibt, weißt du definitiv, dass der angegebene Spieler bereits in dem kleinsten Team war. Außerdem musst du eine Variable int CurrentTeamSize mit dem Wert von TeamSize initialisieren. Du musst CurrentTeamSize variabel gestalten, damit du es auf die Größe jedes anderen Teams aktualisieren kannst, das du mit weniger Spielern findest.

     Verse

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

     Copy full snippet(3 lines long)

   • Da TeamSize die Größe von SmallestTeam verfolgt, musst du sie mit der Größe jedes Teams vergleichen. Iteriere durch jedes Team und rufe ihre Größe in einer lokalen int CandidateTeamSize ab. Wenn CandidateTeamSize kleiner ist als TeamSize, wird SmallestTeam auf dieses Team und TeamSize auf die Größe dieses Teams gesetzt.

     Die Bedingung TeamSize > CandidateTeamSize ist eine Filterbedingung, da sie innerhalb der Klammern der for-Schleife geprüft wird. Die Verwendung einer Filterbedingung garantiert, dass der Code in deiner Schleife nur dann ausgeführt wird, wenn die Filterbedingung erfolgreich ist. Dies garantiert, dass SmallestTeam auf das Team mit den wenigsten Spielern gesetzt wird, wenn eines gefunden wird. Wenn kein Team mit weniger Spielern gefunden wird, bleibt SmallestTeam False.

     Schließlich wird SmallestTeam zurückgegeben, wenn alle Teams überprüft worden sind.

     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)

   • Erstelle in OnBegin() eine neue Team-Option namens SmallestTeam innerhalb der for-Schleife und initialisiere sie mit dem Wert von FindSmallestTeam(), wenn TeamSize als Argument übergeben wird.

     Verse

       SmallestTeam : ?team = FindSmallestTeam(TeamSize)
     

     Copy full snippet(1 line long)

   • Versuche als Nächstes, auf den Wert in der optionalen Variable SmallestTeam zuzugreifen. Wenn der Wert false ist, war der Spieler bereits im kleinsten Team, und es ist keine Zuordnung erforderlich. Andernfalls musst du den Spieler seinem neuen Team zuordnen. Da viele Methoden es nicht erlauben, eine Option direkt als Argument zu übergeben, musst du den Wert in eine lokale Variable TeamToAssign extrahieren. Du kannst versuchen, einen Spieler mit AddToTeam[player, team] diesem Team zuzuweisen. Beachte, dass diese Zuweisung fehlschlägt, wenn du versuchst, einen Spieler einem Team zuzuweisen, zu dem er bereits gehört. Dies hat jedoch keine negativen Effekte, da die for-Schleife einfach zum nächsten Spieler iterieren wird und den ersten Spieler in seinem ursprünglichen Team belässt.

     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() sollte wie der folgende Code-Block aussehen.

   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)

Umgang mit einem Spieler, der einem laufenden Spiel beitritt

Da du auch in der Lage sein willst, Teams für ein laufendes Spiel automatisch auszugleichen, musst du das Event abonnieren, das ausgelöst wird, wenn ein neuer Spieler beitritt. Da du den gesamten Code, den du gerade geschrieben hast, nicht wiederholen willst, kannst du ihn in eine gemeinsame Methode umstrukturieren.

1. Erstelle eine Methode namens BalanceTeams() und verschiebe den gesamten Code hinter die Stelle, an der du die Variable Teams mit GetTeams() gesetzt hast. Dies wird in der Methode OnBegin() aufgerufen, damit die Teams ausgeglichen sind, wenn das Spiel beginnt. BalanceTeams() sollte ungefähr so aussehen.

   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. Erstelle eine weitere Methode namens OnPlayerAdded(), die einen Aufruf von BalanceTeams() enthält. Obwohl du die player-Variable nicht verwendest, ist sie in der Methodendefinition erforderlich, da du dich mit dieser Methode bei PlayerAddedEvent() anmeldest. Weitere Einzelheiten zu abonnierbaren Events findest du auf der Seite Geräteinteraktionen programmieren.

   Verse

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

   Copy full snippet(3 lines long)

3. Abonniere in OnBegin() das PlayerAddedEvent() mit OnPlayerAdded. Wenn nun ein Spieler dem Spiel beitritt, ruft OnPlayerAdded BalanceTeams() auf, um die Teams automatisch auszugleichen.

   Verse

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

   Copy full snippet(4 lines long)

4. Speichere das Script in Visual Studio Code und klicke auf Verse Code erstellen, um dein Script zu kompilieren.

5. Klicke auf Sitzung starten in der UEFN-Symbolleiste, um den Level einen Spieltest durchzuführen.

Wenn du dein Level testest, solltest du die Größe der einzelnen Teams sowie alle kleineren Teams, die das Script findet, im Output-Log sehen. Die Spieler sollten gleichmäßig auf die Teams verteilt sein, und wenn ein neuer Spieler dem Spiel beitritt, sollte diese Ausgewogenheit beibehalten werden.

Vollständiges Script

Der folgende Code ist das vollständige Script für ein Gerät, das automatisch Teams von Spielern ausbalanciert.

    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!")

Du bist am Zug

Wenn du diese Anleitung abgeschlossen hast, hast du gelernt, wie du mit Verse ein Gerät erstellst, das automatisch Teams von Spielern ausbalanciert.

Versuche, mit dem Gelernten absichtlich unausgewogene Teams für asymmetrische Spielmodi zu bilden, z. B. ein Spieler gegen vier Spieler.