1. Epic GamesDeveloper
  3. 4. Como rastrear jogadores com mapas

4. Como rastrear jogadores com mapas

Use Verse para criar um modo de jogo competitivo multijogador que avança equipes por meio de uma série de armas.

4. Como rastrear jogadores com mapas
Prerequisite topics

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

Você usará um mapa para acompanhar o número de eliminações que um jogador marcou. Mapas fornecem uma associação útil de chaves a valores e, neste tutorial, você usará o jogador como chave e o nível de arma associado (representado como um int) como valor. Dessa forma, poderá recuperar o nível atual de um jogador com apenas uma referência a esse jogador. Um exemplo de aparência de um mapa de associações de níveis entre jogadores e armas é fornecido abaixo.

Chave jogador 1 jogador 2 jogador 3
Valor 1 2 2
Arma no Jogo Pistola de Combate L1 Pistola Repulsora L1 Pistola Repulsora L1

Siga estas etapas para configurar e preencher seu mapa de jogadores:

  1. Adicione o mapa [player]int chamado PlayerMap à classe team_elimination_game. Isso armazena uma referência para cada jogador e seu nível de arma.

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

  2. Adicione um novo método PopulateTeamsAndPlayers() à classe team_elimination_game. Esse método preenche seu PlayerMap e será chamado de OnBegin().

    ~~~(verse) PopulateTeamsAndPlayers() : void= Print("Começando a preencher jogadores") ~~~

  3. Adicione um novo método, OnPlayerEliminated, à classe team_elimination_game. Ele é chamado sempre que um jogador é eliminado e determinará quem é o jogador eliminador, acessando o struct elimination_result passado como um argumento.

     OnPlayerEliminated(Result : elimination_result) : void=
     Print("Um jogador foi eliminado!")

  4. Quando o jogo começa, você precisa percorrer a lista de jogadores e defini-los todos para o primeiro nível de arma. Dentro de PopulateTeamsAndPlayers, obtenha todos os jogadores usando GetPlaySpace().GetPlayers() e salve-os em uma matriz AllPlayers. Para cada jogador, recupere o respectivo FortCharacter e salve-o em uma variável FortCharacter. Defina a pontuação desse jogador em PlayerMap como 0 para representar a primeira arma na matriz WeaponGranters, em seguida registre FortCharacter.EliminatedEvent() para OnPlayerEliminated.

    ~~~(verse) AllPlayers := GetPlayspace().GetPlayers() for (Agent : AllPlayers, TeamPlayer := player[Agent], FortCharacter := TeamPlayer.GetFortCharacter[]): if(set PlayerMap[TeamPlayer] = 0, WeaponTier := PlayerMap[TeamPlayer]): Print("Jogador atribuído ao PlayerMap com Nível {WeaponTier}") FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated) ~~~

  5. Com uma referência à pontuação do jogador no conjunto PlayerMap, você pode conceder aos jogadores suas primeiras armas. Modifique OnPlayerSpawn para conceder aos jogadores suas primeiras armas. Quando um jogador surgir, recupere seu nível de arma de PlayerMap e armazene-o em uma variável WeaponTier. Em seguida, chame GrantWeapon passando WeaponTier e uma referência ao jogador.

    ~~~(verse) OnPlayerSpawn(InPlayer : agent) : void = Print("Um jogador acabou de surgir!") if(WeaponTier := PlayerMap[InPlayer]): GrantWeapon(option{InPlayer}, WeaponTier) Print("O jogador que surgiu recebeu uma arma de nível {WeaponTier}") ~~~

  6. Salve o código no Visual Studio Code, compile-o e clique em Iniciar sessão na barra de ferramentas do UEFN para testar o nível. Ao testar seu nível, você deve surgir com a primeira arma na matriz WeaponGranters. Verifique esse comportamento com o log.

Assingning Player to PlayerMap

Como mapear equipes de jogadores

Com seu mapa de jogadores configurado, é útil pensar em como você verifica a pontuação de um jogador. Como seu script promoverá automaticamente o jogador da equipe com menos eliminações, não é útil verificar o nível de arma dos jogadores da equipe inimiga. Você já pode ver um problema surgindo, já que PlayerMap não diferencia entre as equipes.

Para contornar esse problema, você pode usar outro mapa. Para isso, você adaptará PlayerMap que configurou anteriormente em um sistema de mapas aninhados. Como os pares chave/valor em um mapa podem ser quaisquer pares de tipos, faz sentido que uma chave de equipe possa ter outro mapa como valor. O primeiro mapa associará equipes (chave) a outro mapa de jogadores daquela equipe (valor). O mapa interno associará jogadores (chave) à sua pontuação (valor).

Agora, com um jogador especificado, você pode verificar em qual equipe ele está usando GetTeam(). A partir daí, é possível recuperar uma lista de companheiros de equipe para comparar o número de eliminações.

A sintaxe do mapa aninhado [team][player]int pode não ser clara. Para tornar isso mais fácil de entender, você pode aproveitar o serrilhado de tipo para criar um nome mais simples para referenciar o mapa. Neste tutorial, você dará a [player]int o alias de player_map. Ou seja, você pode usar o nome player_map sempre que precisar de [player]int, e o mapa aninhado pode ser reescrito como [team]player_map ou um mapa que associa equipes a mapas de jogadores.

Siga estas etapas para adaptar seu mapa em um sistema de mapas aninhados:

  1. Acima da definição da classe team_elimination_game, adicione um alias para [player]int chamado player_map.

    ~~~(verse) player_map := [player]int # Este é um alias de tipo! team_elimination_game := class(creative_device): ~~~

  2. Substitua a variável PlayerMap que você configurou anteriormente em team_elimination_game por uma nova variável TeamMap do tipo [team]player_map.

    ~~~(verse) # Mapa dos Mapas da Equipe, em que a chave é a equipe e o valor é um mapa de # player->int key-value pairs var TeamMap : [team]player_map = map{} ~~~

  3. Como o valor de TeamMap é do tipo player_map, para cada equipe, você precisa inicializar um mapa de jogadores, preenchê-los, definir a pontuação de cada jogador como 0 e, em seguida, atribuir o mapa de jogadores a TeamMap . Modifique PopulateTeamsAndPlayers() com o código atualizado.

    • Para cada equipe, recupere os jogadores dessa equipe e armazene-os em uma variável TeamPlayers. Inicialize uma nova variável PlayerMap do tipo player_map para mapear jogadores para sua pontuação.
     PopulateTeamsAndPlayers() : void=
     Print("Começando a preencher jogadores")
     for (Team : Teams, TeamPlayers := GetPlayspace().GetTeamCollection().GetAgents[Team]):
         var PlayerMap : player_map = map {}
     ~~~

 *Para cada jogador em `TeamPlayers`, recupere o respectivo `FortCharacter` e salve-o em uma variável `FortCharacter`. Defina a pontuação desse jogador em `PlayerMap` como `0` para representar a primeira arma na matriz `WeaponGranters`, em seguida registre `FortCharacter.EliminatedEvent()` para `OnPlayerEliminated`. 

         ~~~(verse)
 PopulateTeamsAndPlayers() : void =
     Print("Começando a preencher jogadores")
     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("Jogador atribuído ao PlayerMap com Nível {WeaponTier}")
             FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated)
    • Por fim, defina PlayerMap como o valor da chave atual Team no TeamMap. Seu código PopulateTeamsAndPlayers deve ficar como mostrado abaixo.
     PopulateTeamsAndPlayers() : void =
     Print("Começando a preencher jogadores")
     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("Jogador atribuído ao PlayerMap com Nível {WeaponTier}")
             FortCharacter.EliminatedEvent().Subscribe(OnPlayerEliminated) 
         if(set TeamMap[Team] = PlayerMap):
             Print(“Equipe definida com sucesso no TeamMap")

  4. Depois de definir TeamMap, atualize OnPlayerSpawn para acessar a equipe de um jogador usando GetTeam[] e armazene-a em uma variável local PlayerTeam. Defina WeaponTier recuperando a pontuação atual do jogador em TeamMap, usando PlayerTeam e uma referência ao jogador. O OnPlayerSpawn() atualizado deve se parecer com o seguinte código.

    ~~~(verse) OnPlayerSpawn(InPlayer : agent) : void = Print("Um jogador acabou de surgir!") if: PlayerTeam := GetPlayspace().GetTeamCollection().GetTeam[InPlayer] WeaponTier:int := TeamMap[PlayerTeam][InPlayer] then: GrantWeapon(option{InPlayer}, WeaponTier) Print("O jogador que surgiu recebeu uma arma de nível {WeaponTier}") ~~~

Salve o script no Visual Studio Code, compile-o e clique em Iniciar sessão na barra de ferramentas do UEFN para reproduzir o teste do nível. Ao testar seu nível, você deve surgir novamente com a primeira arma na matriz WeaponGranters. Verifique esse comportamento com o log.

Assigning Player to Team Map

Próxima etapa

Na próxima etapa deste tutorial, você aprenderá a conceder armas aos jogadores quando eles marcarem uma eliminação.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page