1. Epic GamesDeveloper
  3. 5. Spielschleife und Rundenmanagement

5. Spielschleife und Rundenmanagement

Verwende den Verse-Code in diesem Abschnitt, um eine Spielschleife und ein Rundenmanagementsystem hinzuzufügen.

5. Spielschleife und Rundenmanagement

Einrichten von Teams

In diesem Abschnitt lernst du, wie du die Hunter- und Prop-Teams zu Beginn des Spiels aufstellst und sie zu ihren Startgebieten teleportierst.

Diese Seite enthält Verse-Snippets, die zeigen, wie die in diesem Spiel benötigten Gameplay-Mechaniken ausgeführt werden. Befolge die folgenden Schritte und kopiere das vollständige Script in Schritt 6 dieses Tutorials.

Befolge diese Schritte, um deine Teams richtig einzurichten:

  1. Erstelle eine neue Funktion SetupTeams(). Hier richtest du mehrere Abonnements für Funktionen ein, die du später definierst, z. B. Funktionen für den Fall, dass ein Prop eliminiert wird, oder was zu tun ist, wenn ein Spieler dem Spiel beitritt.

     # Wenn eine Runde beginnt, abonniere die Team-Geräte, wähle zufällig die Hunter-Agents aus, aktiviere den Hunter-Timer, stelle die Prop-Agents ein und teleportiere sie in den Spielbereich.
 SetUpTeams()<suspends>:void =
     Logger.Print("Teams werden eingerichtet")

  2. Abonniere zunächst das Timer-SuccessEvent des Prop-Teams, das Eliminiert-Event des TeamManagers des Prop-Teams und lege den Punktestand der Punkteanpassung fest.

     # Wenn eine Runde beginnt, abonniere die Team-Geräte, wähle zufällig die Hunter-Agents aus, aktiviere den Hunter-Timer, stelle die Prop-Agents ein und teleportiere sie in den Spielbereich.
 SetUpTeams()<suspends>:void =
     Logger.Print("Teams werden eingerichtet")

     # Abonniere den Timer für den Punktestand des Prop-Teams, setze die Punktevergabe fest und abonniere das Event für Eliminierungen des Prop-Teams.
     PropTeam.ScoreTimer.SuccessEvent.Subscribe(PropTeam.OnPropsScore)
     PropTeam.ScoreManager.SetScoreAward(PropTeam.ScorePerSecond)
     PropTeam.TeamManager.TeamMemberEliminatedEvent.Subscribe(OnPropEliminated) # Tritt ein, wenn ein Prop-Agent eliminiert wird.

  3. Als Nächstes machst du das Gleiche für das Hunter-Team. Setze dann den Warte-Timer des Hunter-Teams auf die gewünschte Spawn-Verzögerung für die Hunter.

     # Wenn eine Runde beginnt, abonniere die Team-Geräte, wähle zufällig die Hunter-Agents aus, aktiviere den Hunter-Timer, stelle die Prop-Agents ein und teleportiere sie in den Spielbereich.
 SetUpTeams()<suspends>:void =
     Logger.Print("Teams werden eingerichtet")

     # Abonniere den Timer für den Punktestand des Prop-Teams, setze die Punktevergabe fest und abonniere das Event für Eliminierungen des Prop-Teams.
     PropTeam.ScoreTimer.SuccessEvent.Subscribe(PropTeam.OnPropsScore)
     PropTeam.ScoreManager.SetScoreAward(PropTeam.ScorePerSecond)
     PropTeam.TeamManager.TeamMemberEliminatedEvent.Subscribe(OnPropEliminated) # Tritt ein, wenn ein Prop-Agent eliminiert wird.

     # Abonniere den Warte-Timer des Hunter-Teams und lege die Dauer fest. Abonniere außerdem das Eliminierungsevent des Hunter-Teams.
     HunterTeam.WaitTimer.SuccessEvent.Subscribe(HuntersGo)
     HunterTeam.WaitTimer.SetMaxDuration(HunterTeam.SpawnDelay)
     HunterTeam.TeamManager.EnemyEliminatedEvent.Subscribe(OnHunterEliminated) # Tritt ein, wenn ein Hunter-Agent einen Prop-Agent eliminiert.

  4. Initialisiere noch innerhalb von SetupTeams() die anfänglichen Hunter- und Prop-Agent-Arrays, dann aktiviere das wartende HUD, während du prüfst, ob genug Spieler da sind, um das Spiel zu starten. Wenn dies der Fall ist, deaktiviere das Warte-HUD.

     # Initialisiere die Arrays der anfänglichen Hunter- und Prop-Agents. Hole die Spieler und die Anzahl der Spieler auf dem Server
 var StartingHunterAgents:[]agent = array{}
 var StartingPropAgents:[]agent = array{}
 var Players:[]player = GetPlayspace().GetPlayers()

 # Aktiviere das HUD für das Warten auf Spieler.
 HUDControllerWaiting.Enable()

 # Überprüfe, ob es genug Spieler gibt, um die Runde zu beginnen.
 set Players = WaitingForMorePlayers.WaitForMinimumNumberOfPlayers(Players)
 Logger.Print("Runde gestartet")

 # Deaktiviere das Warte-HUD, um das HUD mit der nächsthöheren Priorität zu verwenden.
 HUDControllerWaiting.Disable()

  5. Nun, da die Runde begonnen hat, musst du dich darum kümmern, was passiert, wenn ein Spieler dem Match beitritt oder aus dem Match ausscheidet. Hier richtest du die Abonnements ein und definierst diese Funktionen später.

     # Nachdem die Runde begonnen hat, müssen wir nun Spieler hinzufügen oder aus dem Spiel entfernen. Abonniere diese Events.
 GetPlayspace().PlayerAddedEvent().Subscribe(OnPlayerAdded)
 GetPlayspace().PlayerRemovedEvent().Subscribe(OnPlayerRemoved)

  6. Die Startzahl der Hunter richtet sich nach der Anzahl der Spieler in deinem Spiel. Du willst nicht, dass sich ein Hunter mit zehn Spielern herumschlagen muss, also richtest du eine Funktion ein, welche die Anzahl der Hunter auf der Grundlage einer Formel festlegt. Konvertiere die Anzahl der Spieler in einen Float-Wert zur Verwendung in der Formel.

     # Berechne die Anzahl der anfänglichen Hunter-Agents für das Spiel basierend auf der Spieleranzahl und der Anzahl der Hunter-Agents pro Spieleranzahl.
 NumberOfPlayers:float = 1.0 * Players.Length # Konvertiert Players.Length in einen Float, damit er in der nächsten Ceil-Funktion verwendet werden kann.

  7. Setze nun die Anzahl der startenden Hunter auf die Obergrenze der folgenden Formel. Dann mischst du das Array aller Spieler, da die anfänglichen Hunter zufällig aus der Spielerliste ausgewählt werden sollen.

     # Berechne die Anzahl der anfänglichen Hunter-Agents für das Spiel basierend auf der Spieleranzahl und der Anzahl der Hunter-Agents pro Spieleranzahl.
 NumberOfPlayers:float = 1.0 * Players.Length # Konvertiert Players.Length in einen Float, damit er in der nächsten Ceil-Funktion verwendet werden kann.

 if (NumberOfStartingHunters:int = Ceil[NumberOfPlayers / Max(1.1, HunterTeam.HunterAgentPerNumberOfPlayers)]):
     # Mische die Spieler und zerteile dann das Array, um die anfänglichen Hunter-Agents zu erhalten. Die übrigen Spieler sind die anfänglichen Prop-Agents. 
     var RandomizedPlayers:[]agent = Shuffle(Players)

  8. Teile das randomisierte Array auf eine Größe zwischen 0 und deiner Startzahl an Hunters. Dies wird das anfängliche Hunter-Team sein, also lege es auf StartingHunterAgents fest. Die übrigen Spieler bilden das anfängliche Prop-Team, also lege sie auf StartingPropAgents fest.

     # Berechne die Anzahl der anfänglichen Hunter-Agents für das Spiel basierend auf der Spieleranzahl und der Anzahl der Hunter-Agents pro Spieleranzahl.
 NumberOfPlayers:float = 1.0 * Players.Length # Konvertiert Players.Length in einen Float, damit er in der nächsten Ceil-Funktion verwendet werden kann.

 if (NumberOfStartingHunters:int = Ceil[NumberOfPlayers / Max(1.1, HunterTeam.HunterAgentPerNumberOfPlayers)]):
     # Mische die Spieler und zerteile dann das Array, um die anfänglichen Hunter-Agents zu erhalten. Die übrigen Spieler sind die anfänglichen Prop-Agents. 

     var RandomizedPlayers:[]agent = Shuffle(Players)
     if (set StartingHunterAgents = RandomizedPlayers.Slice[0,NumberOfStartingHunters]) {}

     if (set StartingPropAgents = RandomizedPlayers.Slice[NumberOfStartingHunters,RandomizedPlayers.Length]) {}
     # Iteriere durch die anfänglichen Hunter-Agents und weise sie dem Hunter-Team zu. Starte dann den Hunter-Warte-Timer.
     Logger.Print("{StartingHunterAgents.Length} Hunter-Agent(s) eingestellt.")

     for (StartingHunterAgent : StartingHunterAgents): HunterTeam.InitializeAgent(StartingHunterAgent)
         HunterTeam.WaitTimer.Start()

         # Iteriere durch die anfänglichen Prop-Agents und weise sie dem Prop-Team zu. Teleportiere sie in den Spielbereich.
         Logger.Print("{StartingPropAgents.Length} Prop-Agent(s) eingestellt.")

  9. Wenn die Teams aufgestellt sind, aktiviere den Lobby-Teleporter, um die Props aus dem Startraum zu teleportieren, und aktiviere ihren HeartBeat. Dann deaktiviere den Lobby-Teleporter, da du ihn danach nicht mehr brauchst. Schließlich setzt du die Anzahl der verbleibenden Props im PropsRemainingTracker auf die Größe des Prop-Teams.

     LobbyTeleporter.Enable()

 for (StartingPropAgent : StartingPropAgents):
     PropTeam.InitializeAgent(StartingPropAgent)

     PropTeam.HeartBeat.SetUpUI(StartingPropAgent)

     LobbyTeleporter.Activate(StartingPropAgent)

     LobbyTeleporter.Disable()

     # Setze Target und Value des Trackers für die verbleibenden Props auf die aktuelle Anzahl der Props.
     # In Zukunft werden wir Value nur noch aktualisieren, wenn Props eliminiert werden.
     PropTeam.PropsRemainingTracker.SetTarget(PropTeam.Count())
     PropTeam.UpdatePropsRemainingTracker()

Verwaltung von Spieler-Eliminierungen

Die Hunters gewinnen, indem sie alle Props eliminieren und sie in Hunters umwandeln. Befolge diese Schritte, um den Hunters eine Punktzahl zu geben, wenn ein Prop ausgeschieden ist, und um ausgeschiedene Props in das Hunter-Team zu übertragen.

  1. Erstelle eine Funktion mit dem Namen OnHunterEliminated(). Du hast das Gerät „EnemyEliminatedEvent“ des Hunter-Team-Managers zuvor hierauf abonniert, sodass dies immer aktiviert wird, wenn ein Hunter ein Prop eliminiert.

     # Wenn ein Hunter-Agent einen Prop-Agent eliminiert, gibt es Punkte. Die Punktzahl wird durch die Anzahl der verbleibenden Prop-Agents geteilt.
 OnHunterEliminated(HunterAgent:agent):void =
 Logger.Print("Hunter-Agent hat Prop-Agent eliminiert.")

  2. Zunächst musst du den Hunters eine Punktzahl zuweisen, die sich nach der Anzahl der verbleibenden Prop-Agents richtet. Erstelle eine Variable EliminationAward, die gleich der MaxEliminationScore geteilt durch die PropTeamSize ist. Setze den Hunter-Team-Score-Manager auf diese Punktzahl und vergib dann den Preis an den Hunter, der die Elimination erzielt hat.

     # Wenn ein Hunter-Agent einen Prop-Agent eliminiert, gibt es Punkte. Die Punktzahl wird durch die Anzahl der verbleibenden Prop-Agents geteilt.
 OnHunterEliminated(HunterAgent:agent):void =
     Logger.Print("Hunter-Agent hat Prop-Agent eliminiert.")

     PropTeamSize := PropTeam.Count()

     if (EliminationAward := Floor(HunterTeam.MaxEliminationScore / PropTeamSize)):
         Logger.Print("Vergabe von {EliminationAward} Punkten.")
         HunterTeam.ScoreManager.SetScoreAward(EliminationAward)
         HunterTeam.ScoreManager.Activate(HunterAgent)

  3. Du musst auch festlegen, was mit dem Prop-Team passiert, wenn ein Prop eliminiert wird. Erstelle eine Funktion namens OnPropEliminated(). Wie bei OnHunterEliminated() hast du diese Funktion bereits abonniert. Wenn ein Prop eliminiert wird, musst du ihn mit der Funktion EliminateAgent() des PropTeams aus dem Prop-Team entfernen und ihn dann mit der Funktion InitializeAgent() des HunterTeams als Hunter initialisieren.

     # Wenn ein Prop-Agent eliminiert wird, entferne den Prop aus dem Prop-Team, prüfe, ob die Runde beendet ist, und setze ihn als Hunter ein.
 OnPropEliminated(PropAgent:agent):void =
     Logger.Print("Prop-Agent eliminiert.")
     spawn{ PropTeam.EliminateAgent(PropAgent) }

     HunterTeam.InitializeAgent(PropAgent)

Verwaltung von Spielern, die dem Spiel beitreten und es verlassen

Wenn ein Spieler mitten in der Runde dem Spiel beitritt, soll er als Hunter spawnen.

  1. Erstelle eine Funktion OnPlayerAdded(), um dies zu handhaben. Diese Funktion initialisiert nur den Spieler, der als Hunter beitritt.

     # Wenn ein Spieler mitten in der Runde dem Spiel beitritt, wird er zum Hunter.
 OnPlayerAdded(Player:player):void =
     Logger.Print("Ein Spieler ist dem Spiel beigetreten.")
     HunterTeam.InitializeAgent(Player)

  2. Spieler, die das Match verlassen, ist etwas komplizierter. Wenn ein Spieler das Match verlässt, müssen wir ihn aus dem Team, in dem er spielt, entfernen und außerdem überprüfen, ob sein Ausscheiden das Spiel beendet. Dies könnte entweder daran liegen, dass der ausscheidende Spieler der letzte Prop oder der einzige Hunter war. Diese Logik wird von den EliminateAgent()-Funktionen jedes Teams gehandhabt, so dass du eine Instanz davon spawnen wirst, je nachdem, von welchem Team der entfernte Spieler war.

     # Wenn ein Spieler das Spiel verlässt, prüfe, in welchem Team er war, und prüfe dann das Rundenende.
 OnPlayerRemoved(Player:player):void=
     Logger.Print("Ein Spieler hat das Spiel verlassen.")

     if (PropTeam.FindOnTeam[Player]):
         Logger.Print("Der Spieler war ein Prop.")
         spawn{ PropTeam.EliminateAgent(Player) }

     if (HunterTeam.FindOnTeam[Player]):
         Logger.Print("Der Spieler war ein Hunter.")
         spawn{ HunterTeam.EliminateAgent(Player) }

Rundenende

Sobald alle Teams aufgestellt sind, musst du die Größe der einzelnen Teams überwachen, um das Rundenende zu überprüfen. Das Spiel endet, wenn eines der beiden Teams leer ausgeht, oder wenn die Rundenzeit abgelaufen ist, so dass du einen "Race"-Ausdruck verwendest, um zu sehen, was zuerst kommt.

  1. Am Ende deiner OnBegin()-Funktion, in einem Race-Ausdruck, Await() sowohl das TeamEmptyEvent des Hunter- und Prop-Teams, als auch die AwaitEnd()-Funktion des RoundTimers. Sobald das Rennen beendet ist, rufst du die Funktion EndRound() auf, die du im nächsten Schritt definieren wirst.

     # Wenn es keine Prop- oder Hunter-Agents mehr gibt (je nachdem, was zuerst eintritt), oder der Runden-Timer abläuft, oder die Runde endet
 race: 
     PropTeam.TeamEmptyEvent.Await()
     HunterTeam.TeamEmptyEvent.Await()
     RoundTimer.AwaitEnd()
 Logger.Print("Runde beendet")
 EndRound()

  2. In der Funktion EndRound() musst du den Heartbeat-Sensor für jeden Spieler des Prop-Teams deaktivieren und EndRound() auf dem RoundSettings-Gerät aufrufen. Da die Funktion EndRound() auf dem RoundSettings-Gerät die Übergabe eines Spielers erfordert, wird der erste Spieler aus dem Array Players als Anstifter übergeben.

     # Bereinigt die Herzschlag-VFX und beendet dann die Runde.
 EndRound():void=
     PropTeam.HeartBeat.DisableAll()
    
     # Holt einen beliebigen Spieler, um ihn an EndRound zu übergeben
     Players:[]player = GetPlayspace().GetPlayers()
    
     if (RoundEndInstigator := Players[0]):
         Logger.Print("Runde beendet")
         RoundSettings.EndRound(RoundEndInstigator)

Nächster Abschnitt

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page