4. Monitorowanie graczy za pomocą map

Chcesz wykorzystać mapę do monitorowania liczby likwidacji zaliczonych przez gracza. Mapy pozwalają tworzyć praktyczne powiązania kluczy z wartościami, a w tym samouczku gracz będzie pełnił funkcję klucza, natomiast powiązany poziom broni (reprezentowany w formie liczby całkowitej) będzie stanowił wartość. To umożliwi pobranie bieżącego poziomu gracza przez samo odwołanie do gracza. Poniżej przedstawiono przykładową mapę powiązań między graczem a stopniem broni.

Aby skonfigurować i uzupełnić mapę graczy, wykonaj następujące instrukcje:

1. Dodaj mapę [player]int o nazwie PlayerMap do klasy team_elimination_game. Spowoduje to zapisanie odwołania do każdego gracza i poziomu jego broni.

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

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

2. Dodaj nową metodę PopulateTeamsAndPlayers() do klasy team_elimination_game. Metoda ta uzupełni mapę PlayerMap i będzie wywoływana z metody OnBegin().

    PopulateTeamsAndPlayers() : void=
    Print("Rozpoczęcie uzupełniania graczy")
   Copy full snippet

   PopulateTeamsAndPlayers() : void= Print("Rozpoczęcie uzupełniania graczy")

3. Dodaj nową metodę OnPlayerEliminated do klasy team_elimination_game. Metoda ta będzie wywoływana po każdej likwidacji gracza i będzie ustalać, kim jest gracz dokonujący likwidacji, przez uzyskanie dostępu do struktury elimination_result przekazywanej jako argument.

    OnPlayerEliminated(Result : elimination_result) : void=
        Print("Gracz został zlikwidowany!")
   Copy full snippet

   OnPlayerEliminated(Result : elimination_result) : void= Print("Gracz został zlikwidowany!")

4. Po rozpoczęciu gry musisz wykonać iterację po liście graczy i ustawić dla nich wszystkich pierwszy poziom broni. W metodzie PopulateTeamsAndPlayers pobierz wszystkich graczy za pomocą funkcji GetPlaySpace().GetPlayers() i zapisz ich w tablicy AllPlayers. Dla każdego gracza pobierz jego właściwość FortCharacter i zapisz w zmiennej FortCharacter. Na mapie PlayerMap ustaw wynik gracza na zero, aby utworzyć reprezentację dla pierwszej broni w tablicy WeaponGranters, a następnie subskrybuj zdarzenie FortCharacter.EliminatedEvent() do metody OnPlayerEliminated.

    AllPlayers := GetPlayspace().GetPlayers()
    for (Agent : AllPlayers, TeamPlayer := player[Agent], FortCharacter := TeamPlayer.GetFortCharacter[]):
        if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]):
            Print("Przypisano gracza do PlayerMap ze stopniem {WeaponTier}")
            FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated)
   Copy full snippet

   AllPlayers := GetPlayspace().GetPlayers() for (Agent : AllPlayers, TeamPlayer := player[Agent], FortCharacter := TeamPlayer.GetFortCharacter[]): if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): Print("Przypisano gracza do PlayerMap ze stopniem {WeaponTier}") FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated)

5. Za pomocą odwołania do wyniku gracza w ustawionej mapie PlayerMap możesz przyznać graczom ich pierwszą broń. Zmodyfikuj metodę OnPlayerSpawn, aby przyznać graczom ich pierwszą broń. Gdy gracz zostanie zespawnowany, pobierz jego poziom broni z mapy PlayerMap i zapisz w zmiennej WeaponTier, a następnie wywołaj metodę GrantWeapon przekazującą zmienną WeaponTier oraz odwołanie do gracza.

    OnPlayerSpawn(InPlayer : agent) : void =
        Print("Gracz właśnie się zespawnował!")
            if(WeaponTier := PlayerMap[InPlayer]):
                GrantWeapon(option{InPlayer}, WeaponTier)
                Print("Zespawnowanemu graczowi przyznano broń poziomu {WeaponTier}")
   Copy full snippet

   OnPlayerSpawn(InPlayer : agent) : void = Print("Gracz właśnie się zespawnował!") if(WeaponTier := PlayerMap[InPlayer]): GrantWeapon(option{InPlayer}, WeaponTier) Print("Zespawnowanemu graczowi przyznano broń poziomu {WeaponTier}")

6. Zapisz skrypt w Visual Studio Code, skompiluj go, a następnie na pasku narzędzi UEFN kliknij opcję Uruchom sesję, aby przetestować poziom w grze. W trakcie testu poziomu w grze gracz powinien pojawiać się z pierwszą bronią z tablicy WeaponGranters. Sprawdź to zachowanie w dzienniku.

Mapowanie drużyn graczy

Po skonfigurowaniu mapy graczy dobrze jest przemyśleć sposób sprawdzania wyniku gracza. Utworzony skrypt będzie automatycznie awansował gracza z drużyny o najmniejszej liczbie likwidacji, dlatego sprawdzanie poziomu broni graczy wrogiej drużyny nie jest przydatne. Na tym etapie już możesz zauważyć powstały problem. Mapa PlayerMap nie rozróżnia drużyn.

Aby obejść ten problem, można użyć kolejnej mapy. W tym celu włączysz skonfigurowaną wcześniej mapę PlayerMap do układu map zagnieżdżonych. Pary klucz-wartość w mapie mogą być dowolnymi parami typów, dlatego dobrym rozwiązaniem jest sparowanie klucza drużyny z inną mapą stanowiącą jego wartość. Pierwsza mapa będzie kojarzyć drużyny (klucz) z inną mapą graczy należących do tej drużyny (wartość). Mapa wewnętrzna będzie kojarzyć graczy (klucz) z ich wynikiem (wartość).

Wówczas możesz sprawdzić, do której drużyny należy gracz, za pomocą funkcji GetTeam(). Dysponując takimi informacjami, możesz pobrać listę członków danej drużyny w celu porównania ze sobą liczby likwidacji.

Składnia mapy zagnieżdżonej [team][player]int może być niejasna. Aby łatwiej ją było zrozumieć, możesz wykorzystać aliasing typów w celu utworzenia prostszej nazwy do odwoływania się do mapy. W tym samouczku składnię [player]int zastąpisz aliasem player_map. Dzięki temu nazwy player_map będzie można użyć w każdym przypadku wymagającym wprowadzenia [player]int, a zagnieżdżoną mapę można zapisać kodem [team]player_map, lub w odniesieniu do mapy kojarzącej drużyny z mapami graczy.

Aby włączyć mapę w układ map zagnieżdżonych, wykonaj następujące instrukcje:

1. Nad definicją klasy team_elimination_game dodaj alias typu [player]int o nazwie player_map.

    player_map := [player]int # To jest alias typu!
    team_elimination_game := class(creative_device):
   Copy full snippet

   player_map := [player]int # To jest alias typu! team_elimination_game := class(creative_device):

2. Zastąp zmienną PlayerMap skonfigurowaną wcześniej w klasie team_elimination_game nową zmienną TeamMap typu [team]player_map.

    # Mapa obejmująca mapy drużyn, w której kluczem jest drużyna, a wartością jest mapa
    # gracz->liczba całkowita, i składają się one w pary klucz-wartość
    var TeamMap : [team]player_map = map{}
   Copy full snippet

   # Mapa obejmująca mapy drużyn, w której kluczem jest drużyna, a wartością jest mapa # gracz->liczba całkowita, i składają się one w pary klucz-wartość var TeamMap : [team]player_map = map{}

3. Typem wartości mapy TeamMap jest player_map, dlatego dla każdej drużyny musisz zainicjować mapę graczy, uzupełnić ją, ustawić wynik 0 dla każdego gracza, a następnie przypisać mapę graczy do mapy TeamMap. Zmodyfikuj metodę PopulateTeamsAndPlayers() o zaktualizowany kod.

   • Dla każdej drużyny pobierz należących do niej graczy i zapisz ich w zmiennej TeamPlayers. Zainicjuj nową zmienną PlayerMap typu player_map, aby utworzyć mapę kojarzącą graczy z ich wynikiem.

    PopulateTeamsAndPlayers() : void=
        Print("Rozpoczęcie uzupełniania graczy")
        for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
            var PlayerMap : player_map = map {}
   Copy full snippet

   PopulateTeamsAndPlayers() : void= Print("Rozpoczęcie uzupełniania graczy") for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]): var PlayerMap : player_map = map {}
   • Dla każdego gracza w tablicy TeamPlayers pobierz jego właściwość FortCharacter i zapisz w zmiennej FortCharacter. Na mapie PlayerMap ustaw wynik gracza na 0, aby utworzyć reprezentację dla pierwszej broni w tablicy WeaponGranters, a następnie subskrybuj zdarzenie FortCharacter.EliminatedEvent() do metody OnPlayerEliminated.

    PopulateTeamsAndPlayers() : void =
        Print("Rozpoczęcie uzupełniania graczy")
        for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
            var PlayerMap : player_map = map {}
            for (Agent : TeamPlayers, TeamPlayer := player[Agent], FortCharacter := Agent.GetFortCharacter[]): 
                if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): 
                    Print("Przypisano gracza do PlayerMap ze stopniem {WeaponTier}")
                FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated) 
   Copy full snippet

   PopulateTeamsAndPlayers() : void = Print("Rozpoczęcie uzupełniania graczy") for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]): var PlayerMap : player_map = map {} for (Agent : TeamPlayers, TeamPlayer := player[Agent], FortCharacter := Agent.GetFortCharacter[]): if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): Print("Przypisano gracza do PlayerMap ze stopniem {WeaponTier}") FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated)
   • Na końcu ustaw PlayerMap jako wartość bieżącego klucza Team w mapie TeamMap. Kod metody PopulateTeamsAndPlayers powinien wyglądać następująco:

    PopulateTeamsAndPlayers() : void =
        Print("Rozpoczęcie uzupełniania graczy")
        for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
            var PlayerMap : player_map = map {}
            for (Agent : TeamPlayers, TeamPlayer := player[Agent], FortCharacter := Agent.GetFortCharacter[]): 
                if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): 
                    Print("Przypisano gracza do PlayerMap ze stopniem {WeaponTier}")
                FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated) 
            if(set TeamMap[Team] = PlayerMap):
                Print("Ustawiono tę drużynę w TeamMap")
   Copy full snippet

   PopulateTeamsAndPlayers() : void = Print("Rozpoczęcie uzupełniania graczy") for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]): var PlayerMap : player_map = map {} for (Agent : TeamPlayers, TeamPlayer := player[Agent], FortCharacter := Agent.GetFortCharacter[]): if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): Print("Przypisano gracza do PlayerMap ze stopniem {WeaponTier}") FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated) if(set TeamMap[Team] = PlayerMap): Print("Ustawiono tę drużynę w TeamMap")

4. Po ustawieniu mapy TeamMap zaktualizuj metodę OnPlayerSpawn tak, aby uzyskać dostęp do drużyny gracza za pomocą funkcji GetTeam[] i zapisać ją w zmiennej lokalnej PlayerTeam. Ustaw wartość WeaponTier, pobierając bieżący wynik gracza z mapy TeamMap za pomocą zmiennej PlayerTeam i odwołania do gracza. Kod zaktualizowanej metody OnPlayerSpawn() powinien wyglądać następująco:

    OnPlayerSpawn(InPlayer : agent) : void =
         Print("Gracz właśnie się zespawnował!")
        if:
            PlayerTeam := GetPlayspace().GetTeamCollection().GetTeam[InPlayer]
            WeaponTier:int := TeamMap[PlayerTeam][InPlayer]
        then:
            GrantWeapon(option{InPlayer}, WeaponTier)
            Print("Zespawnowanemu graczowi przyznano broń poziomu {WeaponTier}")
   Copy full snippet

   OnPlayerSpawn(InPlayer : agent) : void = Print("Gracz właśnie się zespawnował!") if: PlayerTeam := GetPlayspace().GetTeamCollection().GetTeam[InPlayer] WeaponTier:int := TeamMap[PlayerTeam][InPlayer] then: GrantWeapon(option{InPlayer}, WeaponTier) Print("Zespawnowanemu graczowi przyznano broń poziomu {WeaponTier}")

Zapisz skrypt w Visual Studio Code, skompiluj go, a następnie na pasku narzędzi UEFN kliknij opcję Uruchom sesję, aby przetestować poziom w grze. W trakcie testu poziomu w grze gracz powinien ponownie spawnować się z pierwszą bronią z tablicy WeaponGranters. Sprawdź to zachowanie w dzienniku.

Następny krok

W kolejnym kroku tego samouczka dowiesz się, jak przyznawać graczom bronie, gdy zaliczają likwidację.