Personalize o algoritmo de correspondência para jogos grandes Declarar os atributos do jogador Definir equipes Estabeleça regras para jogos grandes Diminuir os requisitos de correspondências grandes

Projetar um conjunto de regras de jogo grande do FlexMatch

Se o conjunto de regras criar jogos que permitam 41 a 200 jogadores, é necessário fazer alguns ajustes na configuração do conjunto de regras. Esses ajustes otimizam o algoritmo de jogo para que ele possa criar grandes jogos viáveis e, ao mesmo tempo, manter os tempos de espera dos jogadores curtos. Como resultado, grandes conjuntos de regras de jogo substituem regras personalizadas demoradas por soluções padrão que são otimizadas para prioridades comuns de criação de jogos.

Veja como determinar se você precisa otimizar seu conjunto de regras para jogos grandes:

Para cada equipe definida em seu conjunto de regras, obtenha o valor de maxPlayer,
Some todos os valores de maxPlayer. Se o total exceder 40, você tem um conjunto de regras de jogo grande.

Para otimizar seu conjunto de regras para jogos grandes, faça os ajustes descritos a seguir. Consulte o esquema para ver um conjunto de regras de jogo grande em Esquema de conjunto de regras para jogos grandes e exemplos de conjuntos de regras em Exemplo 7: crie uma correspondência grande.

Personalize o algoritmo de correspondência para jogos grandes

Adicione um componente de algoritmo ao conjunto de regras, caso ainda não exista. Defina as seguintes propriedades.

strategy (obrigatório): defina a propriedade strategy como “balanceada”. Essa configuração faz com que o FlexMatch faça verificações adicionais após o jogo para encontrar o equilíbrio ideal da equipe com base em um atributo de jogador especificado, definido na propriedade balancedAttribute. A estratégia equilibrada substitui a necessidade de regras personalizadas para criar equipes uniformemente compatíveis.
balancedAttribute (obrigatório): identifique um atributo do jogador a ser usado ao equilibrar as equipes em um jogo. Esse atributo deve ter um tipo de dado numérico (duplo ou inteiro). Por exemplo, se optar por equilibrar a habilidade do jogador, o FlexMatch você tentará atribuir jogadores para que todas as equipes tenham níveis de habilidade agregados que sejam tão uniformes quanto possível. Certifique-se de declarar o atributo no balanceamento de atributos de jogador no conjunto de regras.
batchingPreference (opcional): escolha quanta ênfase você deseja colocar na formação dos jogos de menor latência possível para seus jogadores. Essa configuração afeta a forma como os tickets para jogos são classificados antes da criação de jogos. Entre as opções estão:
- População maior. O FlexMatch permite jogos usando todos os tickets no pool que tenham valores de latência aceitáveis em pelo menos um local em comum. Como resultado, o pool de tickets potenciais tende a ser grande, o que torna mais fácil preencher os jogos mais rapidamente. Os jogadores podem ser colocados em jogos com latência aceitável, mas nem sempre ideal. Se a propriedade batchingPreference não estiver definida, esse é o comportamento padrão quando strategy é definida como “balanceada”.
- Local mais rápido. O FlexMatch pré-classifica todos os tickets no pool com base em onde eles relatam os valores de latência mais baixos. Como resultado, os jogos tendem a ser formados com jogadores que relatam baixa latência nos mesmos locais. Ao mesmo tempo, o potencial de tickets para cada jogo é menor, o que pode aumentar o tempo necessário para preencher um jogo. Além disso, como a maior prioridade é dada à latência, os jogadores nos jogos podem variar mais amplamente em relação ao atributo de balanceamento.

O exemplo a seguir configura o algoritmo de jogo para se comportar da seguinte maneira: (1) pré-classifique o pool de tickets para agrupar os tickets por local onde eles tenham valores de latência aceitáveis; (2) forme lotes de tickets classificados para combinar; (3) crie jogos com tickets em um lote e equilibre as equipes para equilibrar a habilidade média do jogador.


"algorithm": {
    "strategy": "balanced",
    "balancedAttribute": "player_skill",
    "batchingPreference": "largestPopulation"
},

Declarar os atributos do jogador

No mínimo, você deve declarar o atributo de jogador usado como atributo de balanceamento de algoritmo do conjunto de regras. Esse atributo deve ser incluído para cada jogador em uma solicitação de criação de jogos. Você pode fornecer um valor padrão para o atributo do jogador, mas o balanceamento de atributos funciona melhor quando valores específicos do jogador são fornecidos.

Definir equipes

O processo de definição do tamanho da equipe e da estrutura é o mesmo que o de jogos pequenos, mas a maneira como o FlexMatch preenche as equipes é diferente. Isso afeta como os jogos serão quando estiverem somente parcialmente preenchidas. Você pode ajustar o tamanho mínimo da equipe em resposta.

O FlexMatch usa as seguintes regras ao atribuir um jogador a uma equipe. Primeiro: procura equipes que ainda não alcançaram o requisito mínimo de jogadores. Depois: dessas equipes, procura a que tem mais slots abertos.

Para vários jogos que definem o mesmo tamanho, os jogadores são adicionados sequencialmente para cada equipe até encher. Como resultado, as equipes em um jogo sempre têm um número quase igual de jogadores, mesmo quando o jogo não está cheio. Atualmente, não há como forçar o mesmo tamanho em jogos grandes. Para jogos com equipes de tamanho assimétrico, o processo é um pouco mais complexo. Nesse cenário, os jogadores são inicialmente atribuídos às equipes maiores que têm a maioria dos slots abertos. Conforme número de slots abertos se torna mais uniformemente distribuído em todas as equipes, os jogadores são inscritos em equipes menores.

Por exemplo, digamos que você tem uma regra definida com três equipes. As equipes vermelha e azul são definidas como maxPlayers=10, minPlayers=5. A equipe verde está configurada para maxPlayers =3, minPlayers =2. Aqui está a sequência de preenchimento:

Nenhuma equipe chegou minPlayers. As equipes vermelha e azul têm 10 slots abertos, enquanto a verde tem 3. Os primeiros 10 jogadores são atribuídos (5 cada) para as equipes vermelha e azul. Ambas as equipes atingiram minPlayers.
A equipe verde ainda não atingiu minPlayers. Os próximos dois jogadores são atribuídos à equipe verde. A equipe verde já atingiu minPlayers.
Com todas as equipes em minPlayers, jogadores adicionais agora são atribuídos com base no número de vagas abertas. As equipes vermelha e azul têm cinco slots abertos cada, enquanto a verde tem um. Os 8 próximo jogadores são atribuídos (4 cada) para as equipes vermelha e azul. Todas as equipes agora têm uma vaga aberta.
As vagas restantes para três jogadores são atribuídas (uma cada) às equipes em nenhuma ordem específica.

Estabeleça regras para jogos grandes

O criação de jogos para jogos grandes depende principalmente da estratégia de balanceamento e das otimizações de latência em lotes. A maioria das regras personalizadas não está disponível. No entanto, é possível incorporar os seguintes tipos de regras:

Regra que define um limite rígido na latência do jogador. Use o tipo de regra latency com a propriedade maxLatency. Consulte a referência de Regra de latência. Aqui está um exemplo que define a latência de jogador máximo de 200 milissegundos:
```
"rules": [{
        "name": "player-latency",
        "type": "latency",
        "maxLatency": 200
    }],
```
Regra para agrupar jogadores com base na proximidade de um atributo de jogador especificado. Isso é diferente de definir um atributo de balanceamento como parte do algoritmo de jogos grandes, que se concentra em criar equipes uniformemente combinadas. Essa regra agrupa os tickets de criação de jogos com base na semelhança nos valores dos atributos especificados, como habilidade de iniciante ou especialista, o que tende a levar a jogos de jogadores que estão estreitamente alinhados com o atributo especificado. Use o tipo de regra batchDistance, identifique um atributo com base numérica e especifique o intervalo mais amplo a ser permitido. Consulte a referência de Regra de distância em lote. Aqui está um exemplo que exige que os jogadores de um jogo estejam dentro de um nível de habilidade um do outro:
```
"rules": [{
        "name": "batch-skill",
        "type": "batchDistance",
        "batchAttribute": "skill",
        "maxDistance": 1
```

Diminuir os requisitos de correspondências grandes

Assim como ocorre com as jogos pequenas, você pode usar as expansões para diminuir os requisitos de jogos ao longo do tempo, quando não há jogos válidos possíveis. Nas correspondências grandes, você tem a opção de diminuir as regras de latência do jogador ou as contagens.

Se você estiver usando o preenchimento automático de jogos para jogos grandes, evite relaxar a contagem de jogadores da sua equipe muito rapidamente. O FlexMatch começa a gerar solicitações de preenchimento somente após o início de uma sessão de jogo, o que pode não acontecer por vários segundos após a criação de um jogo. Durante esse tempo, o FlexMatch pode criar várias novas sessões de jogos preenchidas, principalmente quando as regras de contagem são diminuídas. Como resultado, você obtém mais sessões de jogos do que precisa e jogadores em todas elas. A prática recomendada é permitir mais tempo para a primeira contagem de jogadores, suficiente para a sessão ser iniciada. Uma vez que as solicitações de alocação de prioridade mais alta são fornecidas com jogos grandes, os jogadores recebidos serão inscritos em jogos existentes antes de novo jogo iniciar. Talvez você precise experimentar para localizar o tempo de espera ideal para seu jogo.

Aqui está um exemplo que gradualmente reduz a contagem de jogadores da equipe amarela, com um tempo de espera inicial mais longo. Lembre-se de que os tempos de nas expansões do conjunto de regras são absolutos, e não compostos. Portanto, a primeira expansão ocorre em cinco segundos, e a segunda ocorre cinco segundos mais tarde, em dez segundos.


"expansions": [{
        "target": "teams[Yellow].minPlayers",
        "steps": [{
            "waitTimeSeconds": 5,
            "value": 8
        }, {
            "waitTimeSeconds": 10,
            "value": 5
        }]
    }]

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Criar um conjunto de regras

Criar conjuntos de regras