1. Epic GamesDeveloper
  3. 7. Ausbalancieren der Spieler während des Spiels

7. Ausbalancieren der Spieler während des Spiels

Ausgleichen von Spielern, die während eines laufenden Spiels hinzukommen.

7. Ausbalancieren der Spieler während des Spiels
Prerequisite topics

In order to understand and use the content on this page, make sure you are familiar with the following topics:

Wenn ein neuer Spieler dem Spiel beitritt, muss er asymmetrisch in das richtige Team eingeteilt werden. Wenn es sich bei diesem Team um die Infiltratoren handelt, muss ihnen auch eine Instanz von OnInfiltratorDamaged() zugeordnet werden.

Befolge die nachstehenden Schritte, um zu erfahren, wie du Spieler dem richtigen Team zuordnest, wenn sie dem laufenden Spiel beitreten.

Einrichten von Spielerbeitrittsfunktionen

  1. Füge eine neue Funktion OnInfiltratorJoined() in die Klassendefinition von invisibility_manager ein. Diese Funktion nimmt einen Agenten und erzeugt eine Instanz von OnInfiltratorDamaged() mit dem angegebenen Agenten. Füge den ` -Bezeichner zu dieser Funktion hinzu, da du sie von triad_infiltration_game` aus aufrufen wirst. 
     # Spawnt eine OnInfiltratorDamaged-Funktion, wenn ein neuer Infiltrator dem Spiel beitritt
 OnInfiltratorJoined<public>(InAgent:agent):void=
     spawn{OnInfiltratorDamaged(InAgent)}
  2. Füge eine neue Funktion OnPlayerAdded() zur Definition der Klasse triad_infiltration_game hinzu. Diese Funktion nimmt einen Spieler, gleicht ihn mit dem richtigen Team ab und ruft OnInfiltratorJoined() auf, wenn der neue Spieler ein Infiltrator ist. 
     # Behandelt einen neuen Spieler, der dem Spiel beitritt.
 OnPlayerAdded(InPlayer:player):void=
  3. Hole die fort_team_collection für den aktuellen Spielraum und speichere sie in einer Variablen FortTeamCollection. 
     # Behandelt einen neuen Spieler, der dem Spiel beitritt.
 OnPlayerAdded(InPlayer:player):void=
     Logger.Print("Ein neuer Spieler ist beigetreten, Zuweisung zu Team erfolgt!")
     FortTeamCollection := GetPlayspace().GetTeamCollection()

    Refactoring der Team-Balance

  4. Du musst den neuen Spieler in das richtige Team einordnen, aber wenn du BalanceTeams() aufrufst, wirst du am Ende jeden Spieler in ein neues Team einordnen. Anstatt den Code neu zu schreiben, um das kleinste Team für den neuen Spieler zu finden und zu balancieren, ist dies eine gute Gelegenheit für ein Refactoring.
    1. Füge eine neue Methode BalancePlayer() zur Definition der Klasse triad_infiltration_game hinzu. Diese Methode nimmt einen Spieler und teilt ihn asymmetrisch in das richtige Team ein. 
       # Iteriere für jeden Spieler durch die Liste der Teams und weise ihn 
 # dem Team mit den wenigsten Spielern zu, oder bei Gleichstand dem Start-Team.
 BalancePlayer(InPlayer:player):void=
     Logger.Print("Ausgleich der Spieler begonnen")
    2. Extrahiere den Code innerhalb der for-Schleife in BalanceTeams() und platziere ihn innerhalb von BalancePlayer() und benenne TeamPlayer in InPlayer um. Dein BalancePlayer()-Code sollte wie folgt aussehen: 
       # Iteriere für jeden Spieler durch die Liste der Teams und weise ihn 
 # dem Team mit den wenigsten Spielern zu, oder bei Gleichstand dem Start-Team.
 BalancePlayer(InPlayer:player):void=
     Logger.Print("Ausgleich der Spieler begonnen")
     var TeamToAssign:?team = false
     set TeamToAssign = FindTeamWithLargestDifference()
     if (AssignedTeam := TeamToAssign?, GetPlayspace().GetTeamCollection().AddToTeam[InPlayer, AssignedTeam]):
         Logger.Print("Versuch, neu beigetretenen Spieler einem neuen Team zuzuweisen")
     else:
         Logger.Print("Der Spieler war bereits im kleinsten Team")
    3. Füge nun in BalanceTeams() einen Aufruf zu BalancePlayer() innerhalb der for-Schleife hinzu. Dadurch wird die Funktionalität von BalanceTeams() beibehalten, während du gleichzeitig die Möglichkeit hast, einen Spieler individuell zu balancieren. Dein BalanceTeams()-Code sollte wie folgt aussehen: 
       # Gleicht alle Spieler in allen Teams im Spiel aus.
 BalanceTeams():void=
     Logger.Print("Teams werden ausgeglichen")
     var AllPlayers:[]player := GetPlayspace().GetPlayers()
     set AllPlayers = Shuffle(AllPlayers)
     Logger.Print("Länge von AllPlayers ist {AllPlayers.Length}")
     for(TeamPlayer:AllPlayers):
         BalancePlayer(TeamPlayer)
  5. Zurück in OnPlayerAdded(), füge einen Aufruf von BalancePlayer() hinzu, der den Spieler übergibt, der gerade beigetreten ist. 
     # Behandelt einen neuen Spieler, der dem Spiel beitritt.
 OnPlayerAdded(InPlayer:player):void=
     Logger.Print("Ein neuer Spieler ist beigetreten, Zuweisung zu Team erfolgt!")
     FortTeamCollection := GetPlayspace().GetTeamCollection()
     set AllPlayers = GetPlayspace().GetPlayers()
     # Weise den neuen Spieler dem kleinsten Team zu
     BalancePlayer(InPlayer)
  6. Finde den Index der Mannschaft des Spielers nach dem Ausgleich, indem du durch jede Mannschaft im Array Teams iterierst und GetTeam[] als Filter verwendest, um zu prüfen, ob es gleich PlayerTeam ist. 
      # Behandelt einen neuen Spieler, der dem Spiel beitritt.
 OnPlayerAdded(InPlayer:player):void=
     Logger.Print("Ein neuer Spieler ist beigetreten, Zuweisung zu Team erfolgt!")
     FortTeamCollection := GetPlayspace().GetTeamCollection()
        
     # Weist den neuen Spieler dem kleinsten Team zu, asymmetrisch.
     BalancePlayer(InPlayer)

     for:
         TeamIndex -> PlayerTeam:Teams
         PlayerTeam = FortTeamCollection.GetTeam[InPlayer]
  7. Hole den Teleporter, der mit dem Team des Spielers assoziiert ist, indem du mit TeamIndex in das Array Teleporters indizierst und es in einer Variablen TeamTeleporter speicherst. Speichere die Transformation dieses Teleporters in einer Variablen Transform. Respawne dann den neuen Spieler am Start-Teleporter seines Teams. 
     for:
     TeamIndex -> PlayerTeam:Teams
     PlayerTeam = FortTeamCollection.GetTeam[InPlayer]
     TeamTeleporter := Teleporters[TeamIndex]
     Transform := TeamTeleporter.GetTransform()
 do:
     InPlayer.Respawn(Transform.Translation, Transform.Rotation)
     Logger.Print("Der gespawnte Spieler wurde an seine Startposition teleportiert")
  8. Abschließend solltest du überprüfen, ob der Spieler, der gerade beigetreten ist, ein Infiltrator ist, indem du sein Team mit der Infiltrators-Option vergleichst, die du zuvor eingerichtet hast. Wenn dies der Fall ist, rufe OnInfiltratorJoined() von der Klasse invisibility_manager für den neuen Spieler auf, damit er zu flackern beginnt. Dein OnPlayerAdded()-Code sollte wie folgt aussehen: 
     # Behandelt einen neuen Spieler, der dem Spiel beitritt.
 OnPlayerAdded(InPlayer:player):void=
     Logger.Print("Ein neuer Spieler ist beigetreten, Zuweisung zu Team erfolgt!")
     FortTeamCollection := GetPlayspace().GetTeamCollection()
        
     # Weist den neuen Spieler dem kleinsten Team zu, asymmetrisch.
     BalancePlayer(InPlayer)

     for:
         TeamIndex -> PlayerTeam:Teams
         PlayerTeam = FortTeamCollection.GetTeam[InPlayer]
         TeamTeleporter := Teleporters[TeamIndex]
         Transform := TeamTeleporter.GetTransform()
     do:
         InPlayer.Respawn(Transform.Translation, Transform.Rotation)
         Logger.Print("Der gespawnte Spieler wurde an seine Startposition teleportiert")
         # Wenn der Spieler ein Infiltrator war, rufe OnInfiltratorJoined auf.
         # InvisibilityManager.
         if(PlayerTeam = MaybeInfiltrators?):
             InvisibilityManager.OnInfiltratorJoined(InPlayer)
  9. Speichere das Script, erstelle es und klicke auf Sitzung starten in der UEFN-Symbolleiste, um das Level zu testen. Wenn du dein Level testest, sollten die Spieler dem richtigen Team zugeordnet werden, wenn sie einem laufenden Spiel beitreten. Wenn dieser Spieler ein Infiltrator ist, sollte er unsichtbar spawnen und flackern, wenn er Schaden nimmt.

Nächster Schritt

Im nächsten Schritt dieses Tutorials lernst du, wie du einen visuellen Indikator für einen Spieler erstellst, wenn er ein Ziel erobert.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page