Exemplo: defina requisitos em nível de equipe e limites de latência - Amazon GameLift

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Exemplo: defina requisitos em nível de equipe e limites de latência

Este exemplo ilustra como configurar as equipes de jogadores e aplicar um conjunto de regras a cada equipe em vez de cada jogador individual. Ele usa uma única definição para criar três equipes correspondentes iguais. Ele também estabelece uma latência máxima para todos os jogadores. Os máximos de latência podem ser atenuados ao longo do tempo para concluir a correspondência. Este exemplo define as instruções a seguir:

  • Crie três equipes de jogadores.

    • Inclua entre três e cinco jogadores em cada equipe.

    • As equipes finais devem conter aproximadamente ou o mesmo número de jogadores (em uma equipe).

  • Inclua os atributos de jogador a seguir:

    • O nível de habilidade de um jogador (se não for fornecido, o padrão é 10).

    • A função do personagem de um jogador (se não for fornecida, o padrão é "camponês").

  • Escolha jogadores com base em se o nível de habilidade deles é semelhante a outros jogadores na correspondência.

    • Verifique se cada equipe tem uma habilidade de jogador média de 10 pontos entre si.

  • Limite as equipes ao número seguinte de personagens “médicos”:

    • Uma correspondência inteira pode ter um máximo de cinco médicos.

  • Somente faz a correspondência de jogadores que mostram latência de até 50 milissegundos.

  • Se uma correspondência não for preenchida rapidamente, atenue a exigência de latência de jogador, da seguinte forma:

    • Após 10 segundos, permita valores de latência de jogador de até 100 ms.

    • Após 20 segundos, permita valores de latência de jogador de até 150 ms.

Observações sobre como usar o conjunto de regras:

  • O conjunto de regras garante que as equipes sejam uniformemente correspondidas com base na habilidade do jogador. Para avaliar a FairTeamSkill regra, adiciona FlexMatch provisoriamente o jogador em potencial a uma equipe e calcula a habilidade média dos jogadores da equipe. Depois, ele compara com a habilidade média nas duas equipes. Se a regra falhar, o jogador em potencial não será adicionado à correspondência.

  • As exigências de nível de correspondência e da equipe (número total de médicos) são atendidas por meio de uma regra de coleção. Esse tipo de regra usa uma lista de atributos de personagem para todos os jogadores e verifica em relação às contagens máximas. Use flatten para criar uma lista de todos os jogadores em todas as equipes.

  • Ao avaliar com base na latência, observe o seguinte:

    • Os dados de latência são fornecidos na solicitação de marcação de jogos como parte do objeto Player. Não se trata de um atributo de jogador; portanto, não é preciso ser listado como tal.

    • O marcador de jogos avalia a latência de acordo com a região. Qualquer região com uma latência mais alta do que o máximo é ignorada. Para ser aceito para uma correspondência, um jogador deve ter pelo menos uma região com uma latência abaixo do máximo.

    • Se uma solicitação de marcação de jogos omitir dados de latência de um ou mais jogadores, ela será rejeitada em todas as partidas.

{
    "name": "three_team_game",
    "ruleLanguageVersion": "1.0",
    "playerAttributes": [{
        "name": "skill",
        "type": "number",
        "default": 10
    },{
        "name": "character",
        "type": "string_list",
        "default": [ "peasant" ]
    }],
    "teams": [{
        "name": "trio",
        "minPlayers": 3,
        "maxPlayers": 5,
        "quantity": 3
    }],
    "rules": [{
        "name": "FairTeamSkill",
        "description": "The average skill of players in each team is within 10 points from the average skill of players in the match",
        "type": "distance",
        // get players for each team, and average separately to produce list of 3
        "measurements": [ "avg(teams[*].players.attributes[skill])" ],
        // get players for each team, flatten into a single list, and average to produce overall average
        "referenceValue": "avg(flatten(teams[*].players.attributes[skill]))",
        "maxDistance": 10 // minDistance would achieve the opposite result
    }, {
        "name": "CloseTeamSizes",
        "description": "Only launch a game when the team sizes are within 1 of each other.  e.g. 3 v 3 v 4 is okay, but not 3 v 5 v 5",
        "type": "distance",
        "measurements": [ "max(count(teams[*].players))"],
        "referenceValue": "min(count(teams[*].players))",
        "maxDistance": 1
    }, {
        "name": "OverallMedicLimit",
        "description": "Don't allow more than 5 medics in the game",
        "type": "collection",
        // This is similar to above, but the flatten flattens everything into a single
        // list of characters in the game.
        "measurements": [ "flatten(teams[*].players.attributes[character])"],
        "operation": "contains",
        "referenceValue": "medic",
        "maxCount": 5
    }, {
        "name": "FastConnection",
        "description": "Prefer matches with fast player connections first",
        "type": "latency",
        "maxLatency": 50
    }],
    "expansions": [{
        "target": "rules[FastConnection].maxLatency",
        "steps": [{
            "waitTimeSeconds": 10,
            "value": 100
        }, {
            "waitTimeSeconds": 20,
            "value": 150
        }]
    }]
}