1. Epic GamesDeveloper
  3. 4. Verfolgung von Spielern mithilfe von Karten

4. Verfolgung von Spielern mithilfe von Karten

Erstelle mit Verse einen kompetitiven Mehrspielermodus, in dem sich Teams durch eine Reihe von Waffen weiterentwickeln.

4. Verfolgung von Spielern mithilfe von Karten
Prerequisite topics

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

Du wirst eine Karte verwenden, um die Anzahl der Eliminierungen zu verfolgen, die ein Spieler erzielt hat. Karten bieten eine praktische Verknüpfung von Schlüsseln mit Werten, und in diesem Tutorial wirst du den Spieler als Schlüssel und die zugehörige Waffenstufe (dargestellt als Ganzzahl) als Wert verwenden. So kannst du die aktuelle Stufe eines Spielers abrufen, wenn du nur einen Verweis auf den Spieler hast. Nachfolgend ein Beispiel, wie eine Karte der Spieler-Waffen-Stufen-Zuordnungen aussehen könnte.

Schlüssel Spieler 1 Spieler 2 Spieler 3
Wert 1 2 2
Waffe im Spiel Kampfpistole L1 Steinstoßpistole L1 Steinstoßpistole L1

Folge diesen Schritten, um deine Spielerkarte einzurichten und zu füllen:

  1. Füge die Karte [player]int mit dem Namen PlayerMap zur Klasse team_elimination_game hinzu. Hier wird ein Verweis auf jeden Spieler und seine Waffenstufe gespeichert.

     team_elimination_game := class(creative_device):
     var PlayerMap : [player]int = map{}

  2. Füge eine neue Methode PopulateTeamsAndPlayers() zur Klasse team_elimination_game hinzu. Diese Methode füllt deine PlayerMap auf und wird von OnBegin() aufgerufen.

     PopulateTeamsAndPlayers() : void=
 Print("Karte wird bevölkert")

  3. Füge eine neue Methode, OnPlayerEliminated, zur Klasse team_elimination_game hinzu. Diese wird immer dann aufgerufen, wenn ein Spieler ausscheidet, und bestimmt, wer der eliminierende Spieler ist, indem auf die als Argument übergebene Struktur elimination_result zugegriffen wird.

     OnPlayerEliminated(Result : elimination_result) : void=
     Print("Ein Spieler wurde eliminiert!")

  4. Wenn das Spiel beginnt, musst du die Liste der Spieler durchgehen und sie alle auf die erste Waffenstufe setzen. In PopulateTeamsAndPlayers werden alle Spieler mit GetPlaySpace().GetPlayers() abgerufen und in einem Array AllPlayers gespeichert. Finde für jeden Spieler den FortCharacter für diesen Spieler und speichere ihn in einer Variablen FortCharacter. Setze den Punktestand dieses Spielers in der PlayerMap auf 0, um die erste Waffe im WeaponGranters-Array darzustellen, und abonniere dann FortCharacter.EliminatedEvent() auf OnPlayerEliminated.

     AllPlayers := GetPlayspace().GetPlayers()
 für (Agent : AllPlayers, TeamPlayer := player[Agent], FortCharacter := TeamPlayer.GetFortCharacter[]):
     if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]):
         Print("Spieler der PlayerMap mit Stufe {WeaponTier} zugewiesen ")
         FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated)

  5. Mit einem Verweis auf den Punktestand des Spielers in der PlayerMap kannst du Spielern ihre erste Waffe geben. Modifiziere OnPlayerSpawn, um Spielern ihre erste Waffe zu geben. Wenn ein Spieler spawnt, hole seine Waffenstufe aus der PlayerMap und speichere sie in der Variablen WeaponTier, dann rufe GrantWeapon auf und übergebe WeaponTier und eine Referenz auf den Spieler.

     OnPlayerSpawn(InPlayer : agent) : void =
     Print("Ein Spieler ist gespawnt!")
         if(WeaponTier := PlayerMap[InPlayer]):
             GrantWeapon(option{InPlayer}, WeaponTier)
             Print("Der gespawnte Spieler hat eine Waffe der Stufe {WeaponTier} erhalten")

  6. Speichere das Script in Visual Studio Code, kompiliere es und klicke in der UEFN-Symbolleiste auf Sitzung starten, um den Level zu testen. Wenn du dein Level testest, solltest du mit der ersten Waffe aus dem Array WeaponGranters spawnen. Dies lässt sich anhand des Logs überprüfen.

Assingning Player to PlayerMap

Kartierung von Spielerteams

Wenn du deine Spielerkarte erstellt hast, solltest du dir überlegen, wie du den Punktestand eines Spielers überprüfen willst. Da dein Script automatisch den Spieler des Teams mit den wenigsten Eliminierungen befördert, ist es nicht sinnvoll, die Waffenstufe der Spieler des gegnerischen Teams zu überprüfen. Du siehst vielleicht schon ein Problem auftauchen, da PlayerMap nicht zwischen den Teams unterscheidet.

Um dieses Problem zu umgehen, kannst du eine andere Karte verwenden. Hierfür wird die zuvor erstellte PlayerMap in ein geschachteltes Kartensystem umgewandelt. Da Schlüssel-Wert-Paare in einer Karte beliebige Paare von Typen sein können, ist es sinnvoll, dass ein Teamschlüssel eine andere Karte als Wert haben kann. Die erste Karte ordnet Teams (Schlüssel) einer anderen Karte mit Spielern dieses Teams (Wert) zu. Die innere Karte ordnet den Spielern (Schlüssel) ihre Punkte (Wert) zu.

Wenn du einen Spieler hast, kannst du mit GetTeam() überprüfen, in welchem Team er ist. Von dort aus kannst du eine Liste von Mitspielern abrufen, mit denen du die Anzahl der Ausscheidungen vergleichen kannst.

Die Syntax der verschachtelten Karte [team][player]int ist möglicherweise nicht klar. Um dies verständlicher zu machen, kannst du die Vorteile von Typ-Aliasing nutzen, um einen einfacheren Namen für den Verweis auf die Karte zu erstellen. In diesem Tutorial wirst du [player]int den Alias player_map geben. Das bedeutet, dass du den Namen player_map immer dann verwenden kannst, wenn du [player]int brauchst, und die verschachtelte Karte kann als [team]player_map umgeschrieben werden, oder eine Karte, die Teams mit Karten von Spielern verbindet.

Folge diesen Schritten, um deine Karte in ein verschachteltes Kartensystem zu verwandeln:

  1. Füge oberhalb der Definition der Klasse team_elimination_game einen Alias für [player]int mit dem Namen player_map hinzu.

     player_map := [player]int # Dies ist ein Typ-Alias!
 team_elimination_game := class(creative_device):

  2. Ersetze die Variable PlayerMap, die du zuvor in team_elimination_game angelegt hast, durch eine neue Variable TeamMap vom Typ [team]player_map.

     # Karte von Teamkarten, wobei der Schlüssel das Team und der Wert eine Karte von
 # Spieler->Ganzzahl-Schlüssel-Werte-Paaren ist
 var TeamMap : [team]player_map = map{}

  3. Da der Wert von TeamMap vom Typ player_map ist, musst du eine Karte der Spieler initialisieren, sie auffüllen und die Punktzahl jedes Spielers auf 0 setzen und die Karte dann den Spielern für TeamMap zuweisen. Modifiziere PopulateTeamsAndPlayers() mit dem aktualisierten Code.

    • Für jedes Team werden die Spieler dieses Teams abgerufen und in einer Variablen TeamPlayers gespeichert. Initialisiere eine neue Variable PlayerMap des Typs player_map, um Spielern ihrer Punktzahl zuzuordnen.
     PopulateTeamsAndPlayers() : void=
     Print("Karte wird bevölkert")
     für (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
         var PlayerMap : player_map = map {}
    • Für jeden Spieler in TeamPlayers wird der FortCharacter für diesen Spieler abgerufen und in einer Variablen FortCharacter gespeichert. Setze den Punktestand dieses Spielers in der PlayerMap auf 0, um die erste Waffe im WeaponGranters-Array darzustellen, und abonniere dann FortCharacter.EliminatedEvent() auf OnPlayerEliminated.
     PopulateTeamsAndPlayers() : void =
     Print("Karte wird bevölkert")
     für (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
         var PlayerMap : player_map = map {}
         für (Agent : TeamPlayers, TeamPlayer := player[Agent], FortCharacter := Agent.GetFortCharacter[]): 
             if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): 
                 Print("Spieler der PlayerMap mit Stufe {WeaponTier} zugewiesen ")
             FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated)
    • Lege schließlich PlayerMap als Wert des aktuellen Schlüssels Team in TeamMap fest. Der Code PopulateTeamsAndPlayers sollte wie folgt aussehen.
     PopulateTeamsAndPlayers() : void =
     Print("Karte wird bevölkert")
     für (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
         var PlayerMap : player_map = map {}
         für (Agent : TeamPlayers, TeamPlayer := player[Agent], FortCharacter := Agent.GetFortCharacter[]): 
             if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): 
                 Print("Spieler der PlayerMap mit Stufe {WeaponTier} zugewiesen ")
             FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated) 
         if(set TeamMap[Team] = PlayerMap):
             Print("Dieses Team erfolgreich in der Teamkarte festgelegt")

  4. Nachdem du die TeamMap festgelegt hast, aktualisiere OnPlayerSpawn, um mit GetTeam[] auf das Team eines Spielers zuzugreifen und es in einer lokalen Variable PlayerTeam zu speichern. Lege WeaponTier fest, indem du den aktuellen Punktestand des Spielers aus TeamMap abrufst, indem du sowohl PlayerTeam als auch einen Verweis auf den Spieler benutzt. Das aktualisierte OnPlayerSpawn() sollte wie der folgende Code aussehen.

     OnPlayerSpawn(InPlayer : agent) : void =
      Print("Ein Spieler ist gespawnt!")
     if:
         PlayerTeam := GetPlayspace().GetTeamCollection().GetTeam[InPlayer]
         WeaponTier:int := TeamMap[PlayerTeam][InPlayer]
     then:
         GrantWeapon(option{InPlayer}, WeaponTier)
         Print("Der gespawnte Spieler hat eine Waffe der Stufe {WeaponTier} erhalten")

Speichere das Script in Visual Studio Code, kompiliere es und klicke in der UEFN-Symbolleiste auf Sitzung starten, um das Level zu testen. Wenn du dein Level testest, solltest du wieder mit der ersten Waffe aus dem Array WeaponGranters spawnen. Dies lässt sich anhand des Logs überprüfen.

Assigning Player to Team Map

Nächster Schritt

Im nächsten Schritt dieses Tutorials lernst du, wie du Spielern Waffen gibst, wenn sie eine Eliminierung erzielen.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page