Exemplos de conjunto de regras FlexMatch - Amazônia 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á.

Exemplos de conjunto de regras FlexMatch

Os conjuntos de regras do FlexMatch cobrem uma variedade de cenários de marcação de jogos. Os exemplos a seguir estão em conformidade com a estrutura de configuração do FlexMatch e o idioma de expressão de propriedade. Copie esses conjuntos de regras em sua totalidade ou escolha componentes, se necessário.

Para obter mais informações sobre o uso e conjuntos de regras do FlexMatch, consulte os tópicos a seguir:

nota

Ao avaliar um tíquete de marcação de jogos que inclui vários jogadores, todos na solicitação precisam atender às exigências da correspondência.

Exemplo 1: Crie duas equipes com jogadores uniformemente combinados

Este exemplo ilustra como configurar duas equipes com correspondência igual de jogadores com as instruções a seguir.

  • Crie duas equipes de jogadores.

    • Inclua entre quatro e oito jogadores em cada equipe.

    • As equipes finais devem ter o mesmo número de jogadores.

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

  • Escolha jogadores baseado em se o nível de habilidade deles é semelhante a outros jogadores. Verifique se ambas as equipes têm um nível de habilidade médio por jogador de 10 pontos entre si.

  • Se a correspondência não for preenchida rapidamente, atenue a exigência de habilidade do jogador para concluir uma correspondência em tempo razoável.

    • Depois de 5 segundos, expanda a pesquisa para permitir equipes com habilidades de jogador médias de 50 pontos.

    • Depois de 15 segundos, expanda a pesquisa para permitir equipes com habilidades de jogador médias de 100 pontos.

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

  • Este exemplo permite equipes de qualquer tamanho entre quatro e oito jogadores (embora elas precisem ser do mesmo tamanho). Para equipes com uma faixa de tamanhos válida, o marcador de jogos faz uma tentativa de melhor esforço para corresponder ao número máximo de jogadores permitidos.

  • A regra FairTeamSkill garante que as equipes sejam uniformemente correlacionadas com base na habilidade do jogador. Para avaliar essa regra para cada novo jogador em potencial, o FlexMatch adiciona o jogador a uma equipe provisoriamente e calcula as médias. Se a regra falhar, o jogador em potencial não será adicionado à correspondência.

  • Como ambas as equipes têm estruturas idênticas, você pode optar por criar apenas uma definição de equipe e definir a quantidade da equipe como "2". Nesse cenário, se você nomeou a equipe como "aliens", suas equipes recebem os nomes "aliens_1" e "aliens_2".

{ "name": "aliens_vs_cowboys", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "skill", "type": "number", "default": 10 }], "teams": [{ "name": "cowboys", "maxPlayers": 8, "minPlayers": 4 }, { "name": "aliens", "maxPlayers": 8, "minPlayers": 4 }], "rules": [{ "name": "FairTeamSkill", "description": "The average skill of players in each team is within 10 points from the average skill of all players in the match", "type": "distance", // get skill values for players in each team and average separately to produce list of two numbers "measurements": [ "avg(teams[*].players.attributes[skill])" ], // get skill values for players in each team, flatten into a single list, and average to produce an overall average "referenceValue": "avg(flatten(teams[*].players.attributes[skill]))", "maxDistance": 10 // minDistance would achieve the opposite result }, { "name": "EqualTeamSizes", "description": "Only launch a game when the number of players in each team matches, e.g. 4v4, 5v5, 6v6, 7v7, 8v8", "type": "comparison", "measurements": [ "count(teams[cowboys].players)" ], "referenceValue": "count(teams[aliens].players)", "operation": "=" // other operations: !=, <, <=, >, >= }], "expansions": [{ "target": "rules[FairTeamSkill].maxDistance", "steps": [{ "waitTimeSeconds": 5, "value": 50 }, { "waitTimeSeconds": 15, "value": 100 }] }] }

Exemplo 2: Crie equipes irregulares (caçadores x monstro)

Este exemplo descreve um modo de jogo em que um grupo de jogadores caça um único monstro. As pessoas escolhem a função de um caçador ou de um monstro. Os caçadores especificam o nível de habilidade mínimo para o monstro que eles querem enfrentar. O tamanho mínimo da equipe do caçador pode ser atenuado ao longo do tempo para concluir a correspondência. Este cenário define as instruções a seguir:

  • Crie uma equipe de exatamente cinco caçadores.

  • Crie uma equipe separada de exatamente um monstro.

  • Inclua os atributos de jogador a seguir:

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

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

    • Se o jogador deseja ser o monstro (se não for fornecido, o padrão é 0 ou falso).

  • Escolha um jogador para ser o monstro com base nos seguintes critérios:

    • O jogador deve solicitar a função do monstro.

    • O jogador deve atender ou exceder o nível mais alto de habilidade preferido pelos jogadores que já foram adicionados à equipe do caçador.

  • Escolha jogadores para a equipe do caçador com base nos seguintes critérios:

    • Os jogadores que solicitam a função do monstro não podem entrar na equipe do caçador.

    • Se a função do monstro já tiver sido preenchida, o jogador poderá querer um nível de habilidade de monstro que seja inferior à habilidade do monstro proposto.

  • Se uma correspondência não for preenchida rapidamente, atenue o tamanho mínimo da equipe do caçador da seguinte forma:

    • Após 30 segundos, permita que um jogo inicie com apenas quatro jogadores na equipe do caçador.

    • Após 60 segundos, permita que um jogo inicie com apenas três pessoas na equipe do caçador.

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

  • Usando duas equipes separadas para caçadores e monstro, você pode avaliar a associação com base em conjuntos diferentes de critérios.

{ "name": "players_vs_monster_5_vs_1", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "skill", "type": "number", "default": 10 },{ "name": "desiredSkillOfMonster", "type": "number", "default": 10 },{ "name": "wantsToBeMonster", "type": "number", "default": 0 }], "teams": [{ "name": "players", "maxPlayers": 5, "minPlayers": 5 }, { "name": "monster", "maxPlayers": 1, "minPlayers": 1 }], "rules": [{ "name": "MonsterSelection", "description": "Only users that request playing as monster are assigned to the monster team", "type": "comparison", "measurements": ["teams[monster].players.attributes[wantsToBeMonster]"], "referenceValue": 1, "operation": "=" },{ "name": "PlayerSelection", "description": "Do not place people who want to be monsters in the players team", "type": "comparison", "measurements": ["teams[players].players.attributes[wantsToBeMonster]"], "referenceValue": 0, "operation": "=" },{ "name": "MonsterSkill", "description": "Monsters must meet the skill requested by all players", "type": "comparison", "measurements": ["avg(teams[monster].players.attributes[skill])"], "referenceValue": "max(teams[players].players.attributes[desiredSkillOfMonster])", "operation": ">=" }], "expansions": [{ "target": "teams[players].minPlayers", "steps": [{ "waitTimeSeconds": 30, "value": 4 },{ "waitTimeSeconds": 60, "value": 3 }] }] }

Exemplo 3: Definir requisitos de 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 cenário 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. Como avaliar oFairTeamSkillRegra, o FlexMatch adiciona o jogador em potencial a uma equipe e calcula a habilidade média dos jogadores na 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 }] }] }

Exemplo 4: Use a classificação explícita para encontrar as melhores correspondências

Este exemplo configura uma correspondência simples com duas equipes de três jogadores. Ele ilustra como usar as regras de classificação explícitas para ajudar a encontrar as melhores correspondências o mais rápido possível. Essas regras classificam todos os tíquetes de matchmaking ativos para criar as melhores correspondências com base em determinados requisitos principais. Este cenário é implementado com as seguintes instruções:

  • Crie duas equipes de jogadores.

  • Inclua exatamente três jogadores em cada equipe.

  • Inclua os atributos de jogador a seguir:

    • Nível de experiência (se não for fornecido, o padrão é 50).

    • Modos de jogo preferidos (pode listar vários valores) (se não forem fornecidos, os padrões são “cooperação” e “combate mortal”).

    • Mapas de jogo preferidos, incluindo o nome do mapa e ponderação preferida (se não for fornecido, o padrão é "defaultMap" com um peso 100).

  • Configurar pré-classificação:

    • Classifique os jogadores com base na preferência pelo mesmo mapa de jogo que o jogador âncora. Os jogadores podem ter vários mapas de jogo favoritos, portanto, este exemplo usa um valor preferencial.

    • Classifique os jogadores com base na proximidade do nível de experiência deles com a do jogador âncora. Com essa classificação, todos os jogadores em todas as equipes terão níveis de experiência o mais próximos possíveis.

  • Todos os jogadores em todas as equipes precisam ter selecionado pelo menos um modo de jogo em comum.

  • Todos os jogadores em todas as equipes precisam ter selecionado pelo menos um mapa de jogo em comum.

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

  • A classificação do mapa de jogo usa uma classificação absoluta que compara o valor do atributo mapPreference. Como é o primeiro no conjunto de regras, esse tipo é realizado primeiro.

  • A classificação da experiência usa uma classificação de distância para comparar um nível de habilidade do jogador em potencial com a habilidade do jogador âncora.

  • As classificações são feitas na ordem que são listadas em um conjunto de regras. Neste cenário, os jogadores são classificados pela preferência de mapa de jogo e depois pelo nível de experiência.

{ "name": "multi_map_game", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "experience", "type": "number", "default": 50 }, { "name": "gameMode", "type": "string_list", "default": [ "deathmatch", "coop" ] }, { "name": "mapPreference", "type": "string_number_map", "default": { "defaultMap": 100 } }, { "name": "acceptableMaps", "type": "string_list", "default": [ "defaultMap" ] }], "teams": [{ "name": "red", "maxPlayers": 3, "minPlayers": 3 }, { "name": "blue", "maxPlayers": 3, "minPlayers": 3 }], "rules": [{ // We placed this rule first since we want to prioritize players preferring the same map "name": "MapPreference", "description": "Favor grouping players that have the highest map preference aligned with the anchor's favorite", // This rule is just for sorting potential matches. We sort by the absolute value of a field. "type": "absoluteSort", // Highest values go first "sortDirection": "descending", // Sort is based on the mapPreference attribute. "sortAttribute": "mapPreference", // We find the key in the anchor's mapPreference attribute that has the highest value. // That's the key that we use for all players when sorting. "mapKey": "maxValue" }, { // This rule is second because any tie-breakers should be ordered by similar experience values "name": "ExperienceAffinity", "description": "Favor players with similar experience", // This rule is just for sorting potential matches. We sort by the distance from the anchor. "type": "distanceSort", // Lowest distance goes first "sortDirection": "ascending", "sortAttribute": "experience" }, { "name": "SharedMode", "description": "The players must have at least one game mode in common", "type": "collection", "operation": "intersection", "measurements": [ "flatten(teams[*].players.attributes[gameMode])"], "minCount": 1 }, { "name": "MapOverlap", "description": "The players must have at least one map in common", "type": "collection", "operation": "intersection", "measurements": [ "flatten(teams[*].players.attributes[acceptableMaps])"], "minCount": 1 }] }

Exemplo 5: Encontre interseções em vários atributos de jogador

Este exemplo ilustra como usar uma regra de coleta para encontrar interseções em dois ou mais atributos do jogador. Ao trabalhar com coleções, você pode usar a operação intersection para um único atributo e a operação reference_intersection_count para vários atributos.

Para ilustrar essa abordagem, o exemplo avalia os jogadores em uma partida com base nas preferências dos seus personagens. O jogo de exemplo é um estilo "gratuito para todos", em que todos os jogadores em uma partida são oponentes. Cada jogador deve (1) escolher um personagem para si e (2) escolher os personagens adversários. Precisamos de uma regra que garanta que todos os jogadores em uma partida estejam usando um personagem na lista de oponentes preferidos de todos os outros jogadores.

O conjunto de regras de exemplo descreve uma correspondência com as seguintes características:

  • Estrutura da equipe: Uma equipe de cinco jogadores

  • Atributos do jogador:

    • MyCharacter: O personagem escolhido pelo jogador.

    • preferredOpponents: Lista de personagens contra os quais o jogador quer jogar.

  • Regras de correspondência: Uma correspondência potencial é aceitável se cada personagem em uso estiver na lista de oponentes preferidos de todos os jogadores.

Para implementar a regra de correspondência, este exemplo usa uma regra de coleta com os seguintes valores de propriedade:

  • Operação — Usosreference_intersection_countOperação para avaliar como cada lista de strings no valor de medição intercepta a lista de strings no valor de referência.

  • Medição — Usa oflattenExpressão de propriedade para criar uma lista de listas de strings, cada uma delas contendo um jogadorMyCharacterValor de atributo.

  • Valor de referência — Usa oset_intersectionexpressão de propriedade para criar uma lista de cadeias de caracteres de todospreferredOpponentsValores de atributo comuns a todos os jogadores na correspondência.

  • Restrições —minCountÉ definido como 1 para garantir que o personagem escolhido de cada jogador (uma lista strings na medição) corresponda a pelo menos um dos oponentes preferidos comuns a todos os jogadores. (uma string no valor de referência).

  • Expansão — se uma correspondência não for feita em 15 segundos, ajuste o requisito mínimo de interseção.

O fluxo do processo para esta regra é o seguinte:

  1. Um jogador é adicionado ao jogo em potencial. O valor de referência (uma lista de strings) é recalculado para incluir interseções com a lista de oponentes preferidos do novo jogador. O valor de medição (uma lista das listas de strings) é recalculado para adicionar o caractere escolhido do novo jogador como uma nova lista de strings.

  2. O Amazon GameLift verifica se cada lista de strings no valor de medição (caracteres escolhidos pelos jogadores) faz intersecção com pelo menos uma string no valor de referência (oponentes preferidos dos jogadores). Neste exemplo, como cada lista de strings na medição contém apenas um valor, a interseção é 0 ou 1.

  3. Se alguma lista de strings na medição não fizer interseção com a lista de strings dos valores de referência, a regra falhará e o novo jogador será removido da correspondência em potencial.

  4. Se uma partida não for preenchida em 15 segundos, elimine o requisito de correspondência do oponente para preencher os slots restantes do jogador na partida.

{ "name": "preferred_characters", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "myCharacter", "type": "string_list" }, { "name": "preferredOpponents", "type": "string_list" }], "teams": [{ "name": "red", "minPlayers": 5, "maxPlayers": 5 }], "rules": [{ "description": "Make sure that all players in the match are using a character that is on all other players' preferred opponents list.", "name": "OpponentMatch", "type": "collection", "operation": "reference_intersection_count", "measurements": ["flatten(teams[*].players.attributes[myCharacter])"], "referenceValue": "set_intersection(flatten(teams[*].players.attributes[preferredOpponents]))", "minCount":1 }], "expansions": [{ "target": "rules[OpponentMatch].minCount", "steps": [{ "waitTimeSeconds": 15, "value": 0 }] }] }

Exemplo 6: Compare atributos em todos os jogadores

Este exemplo ilustra como comparar os atributos do jogador em um grupo de jogadores.

O conjunto de regras de exemplo descreve uma correspondência com as seguintes características:

  • Estrutura da equipe: Duas equipes de jogador único

  • Atributos do jogador:

    • gameMode: Tipo de jogo escolhido pelo jogador (se não for fornecido, o valor padrão será “turn-based”).

    • gameMap: Mundo do jogo escolhido pelo jogador (se não for fornecido, o valor padrão será 1).

    • personagem: Personagem escolhido pelo jogador (se não houver nenhum valor padrão significa que os jogadores precisarão especificar um personagem).

  • Regras de correspondência: Os jogadores correspondentes precisam atender aos seguintes requisitos:

    • Os jogadores devem escolher o mesmo modo de jogo.

    • Os jogadores devem escolher o mesmo mapa de jogo.

    • Os jogadores precisam escolher personagens diferentes.

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

  • Para implementar a regra de correspondência, este exemplo usa regras de comparação de modo a verificar os valores de atributos de todos os jogadores. Para modo de jogo e mapa, a regra verifica se os valores são os mesmos. Para caractere, a regra verifica se os valores são diferentes.

  • Este exemplo usa uma definição de jogador com uma propriedade de quantidade para criar as duas equipes de jogadores. Eles recebem os nomes: "jogador_1" e "jogador_2".

{ "name": "", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "gameMode", "type": "string", "default": "turn-based" }, { "name": "gameMap", "type": "number", "default": 1 }, { "name": "character", "type": "number" }], "teams": [{ "name": "player", "minPlayers": 1, "maxPlayers": 1, "quantity": 2 }], "rules": [{ "name": "SameGameMode", "description": "Only match players when they choose the same game type", "type": "comparison", "operation": "=", "measurements": ["flatten(teams[*].players.attributes[gameMode])"] }, { "name": "SameGameMap", "description": "Only match players when they're in the same map", "type": "comparison", "operation": "=", "measurements": ["flatten(teams[*].players.attributes[gameMap])"] }, { "name": "DifferentCharacter", "description": "Only match players when they're using different characters", "type": "comparison", "operation": "!=", "measurements": ["flatten(teams[*].players.attributes[character])"] }] }

Exemplo 7: Crie uma correspondência grande

Este exemplo ilustra como configurar um conjunto de regras para correspondências que podem exceder 40 jogadores. Quando um conjunto de regras descreve as equipes com uma contagem total de maxPlayer maior que 40, ele é processado como uma correspondência grande. Saiba mais em Projetar um conjunto de regras de correspondência grande FlexMatch.

O exemplo cria um conjunto de regras de correspondências usando as seguintes instruções:

  • Crie uma equipe com até 200 jogadores, com um requisito mínimo de 175 jogadores.

  • Os critérios de balanceamento: Selecione jogadores com base no nível de habilidade semelhantes. Todos os jogadores devem informar o nível de habilidade deles para a correspondência ser feita.

  • Preferência de lotes: Agrupe jogadores por critérios de balanceamento semelhantes ao criar correspondências.

  • Regras de latência: Defina a latência máxima aceitável do jogador como 150 milissegundos.

  • Se a correspondência não for preenchida rapidamente, atenue a exigência para concluir uma correspondência em tempo razoável.

    • Após 10 segundos, aceite uma equipe com 150 jogadores.

    • Após 12 segundos, eleve a latência aceitável para 200 milissegundos.

    • Depois de 15 segundos, aceite uma equipe com 100 jogadores.

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

  • Como o algoritmo usa a preferência de processamento em grupos "maior população" primeiro, os jogadores são classificados com base nos critérios de balanceamento. Como resultado, as correspondências tendem a ser mais completas e conter jogadores mais semelhantes em relação à habilidade. Todos os jogadores atendem aos requisitos de latência aceitáveis, mas podem não ter a melhor latência possível para sua localização.

  • A estratégia de algoritmo usada neste conjunto de regras, "maior população", é a configuração padrão. Para usar o padrão, você pode optar por omitir a configuração.

  • Se você tiver habilitado a alocação de correspondência, não diminua os requisitos de contagem de jogadores muito rapidamente, ou você pode acabar com muitas sessões de jogos parcialmente preenchidas. Saiba mais em Relaxe requisitos de correspondência grande.

{ "name": "free-for-all", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "skill", "type": "number" }], "algorithm": { "balancedAttribute": "skill", "strategy": "balanced", "batchingPreference": "largestPopulation" }, "teams": [{ "name": "Marauders", "maxPlayers": 200, "minPlayers": 175 }], "rules": [{ "name": "low-latency", "description": "Sets maximum acceptable latency", "type": "latency", "maxLatency": 150 }], "expansions": [{ "target": "rules[low-latency].maxLatency", "steps": [{ "waitTimeSeconds": 12, "value": 200 }], "target": "teams[Marauders].minPlayers", "steps": [{ "waitTimeSeconds": 10, "value": 150 }, { "waitTimeSeconds": 15, "value": 100 }] }] }

Exemplo 8: Crie uma partida grande com várias equipes

Este exemplo ilustra como configurar um conjunto de regras para correspondências de várias equipes que podem exceder 40 jogadores. Este exemplo ilustra como criar várias equipes idênticas com uma definição e como as equipes de tamanho assimétrico são preenchidas durante a criação de correspondência.

O exemplo cria um conjunto de regras de correspondências usando as seguintes instruções:

  • Crie dez idênticas equipes idênticas de "caçadores" com até 15 jogadores, e uma equipe de "monstros" com exatamente 5 jogadores.

  • Os critérios de balanceamento: Selecione jogadores com base no número de mortes de monstros. Se os jogadores não relatarem a contagem de mortes, use um valor padrão de 5.

  • Preferência de lotes: Jogadores de grupo com base nas regiões em que relatam a latência mais rápida.

  • Regra de latência: Define uma latência máxima aceitável do jogador como 200 milissegundos.

  • Se a correspondência não for preenchida rapidamente, atenue a exigência para concluir uma correspondência em tempo razoável.

    • Depois de 15 segundos, aceite equipes com 10 jogadores.

    • Após 20 segundos, aceite equipes com 8 jogadores.

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

  • Este conjunto de regras define equipes que podem ter até 155 jogadores, o que faz a correspondência ser grande (10 x 15 caçadores + 5 monstros = 155)

  • Como o algoritmo usa a preferência de agrupamento por "região mais rápida", os jogadores tendem a ser colocados em regiões onde mostram latência mais rápida e não em regiões de latência mas alta (mas é aceitável). Ao mesmo tempo, as correspondências podem ter um número menor de jogadores, e os critérios de balanceamento de monstros (número de habilidades) pode variar mais.

  • Quando uma expansão é definida para uma definição de várias equipes (quantidade > 1), ela se aplica a todas as equipes criadas com essa definição. Portanto, diminuir o tamanho mínimo da equipe de caçadores faz com que todas as dez equipes de caçadores sejam impactadas igualmente.

  • Como esse conjunto de regras é otimizado para minimizar a latência do jogador, a latência atua como uma regra genérica para excluir os jogadores que não têm opções de conexão aceitáveis. Não precisamos diminuir essa exigência.

  • Veja como o FlexMatch preenche correspondências para esse conjunto de regras antes de qualquer expansão entrar em vigor:

    • Nenhuma equipe atingiu a contagem minPlayers até agora. As equipes de caçadores têm 15 slots abertos, enquanto a equipe de monstros tem 5 slots abertos.

      • Os primeiros 100 jogadores são atribuídos (10 cada) às 10 equipes de caçadores.

      • Os próximos 22 jogadores são atribuídos sequencialmente (2 para cada) às equipes de caçadores e à equipe de monstros.

    • As equipes de caçadores atingiram a contagem minPlayers de 12 jogadores cada. A equipe de monstros tem dois jogadores e não atingiu a contagem minPlayers.

      • Os próximos três jogadores são atribuídos à equipe de monstros.

    • Todas as equipes atingiram a contagem minPlayers. As equipes de caçadores têm três slots abertos cada uma. A equipe de monstros está cheia.

      • Os últimos 30 jogadores são atribuídos sequencialmente às equipes de caçadores, garantindo que todas as equipes têm praticamente o mesmo tamanho (um jogador a mais ou a menos).

  • Se você tiver habilitado a alocação para correspondências criadas dentro desse conjunto de regras, não diminua os requisitos de contagem de jogadores muito rapidamente, ou você pode acabar com muitas sessões de jogos parcialmente preenchidas. Saiba mais em Relaxe requisitos de correspondência grande.

{ "name": "monster-hunters", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "monster-kills", "type": "number", "default": 5 }], "algorithm": { "balancedAttribute": "monster-kills", "strategy": "balanced", "batchingPreference": "fastestRegion" }, "teams": [{ "name": "Monsters", "maxPlayers": 5, "minPlayers": 5 }, { "name": "Hunters", "maxPlayers": 15, "minPlayers": 12, "quantity": 10 }], "rules": [{ "name": "latency-catchall", "description": "Sets maximum acceptable latency", "type": "latency", "maxLatency": 150 }], "expansions": [{ "target": "teams[Hunters].minPlayers", "steps": [{ "waitTimeSeconds": 15, "value": 10 }, { "waitTimeSeconds": 20, "value": 8 }] }] }

Exemplo 9: Crie uma partida grande com jogadores com atributos semelhantes

Este exemplo ilustra como configurar um conjunto de regras para correspondências de duas equipes usandobatchDistance. No exemplo:

  • OSimilarLeagueRegra garante que todos os jogadores em uma correspondência tenham umleaguedentro de 2 de outros jogadores.

  • OSimilarSkillRegra garante que todos os jogadores em uma correspondência tenham umskilldentro de 10 de outros jogadores. Se um jogador estiver esperando 10 segundos, a distância será expandida para 20. Se um jogador estiver esperando 20 segundos, a distância será expandida para 40.

  • OSameMapRegra garante que todos os jogadores em uma correspondência tenham solicitado o mesmomap.

  • OSameModeRegra garante que todos os jogadores em uma correspondência tenham solicitado o mesmomode.

{ "ruleLanguageVersion": "1.0", "teams": [{ "name": "red", "minPlayers": 100, "maxPlayers": 100 }, { "name": "blue", "minPlayers": 100, "maxPlayers": 100 }], "algorithm": { "strategy":"balanced", "balancedAttribute": "skill", "batchingPreference":"fastestRegion" }, "playerAttributes": [{ "name": "league", "type": "number" },{ "name": "skill", "type": "number" },{ "name": "map", "type": "string" },{ "name": "mode", "type": "string" }], "rules": [{ "name": "SimilarLeague", "type": "batchDistance", "batchAttribute": "league", "maxDistance": 2 }, { "name": "SimilarSkill", "type": "batchDistance", "batchAttribute": "skill", "maxDistance": 10 }, { "name": "SameMap", "type": "batchDistance", "batchAttribute": "map" }, { "name": "SameMode", "type": "batchDistance", "batchAttribute": "mode" }], "expansions": [{ "target": "rules[SimilarSkill].maxDistance", "steps": [{ "waitTimeSeconds": 10, "value": 20 }, { "waitTimeSeconds": 20, "value": 40 }] }] }

Exemplo 10: Use uma regra composta para criar uma partida com jogadores com atributos semelhantes ou seleções semelhantes

Este exemplo ilustra como configurar um conjunto de regras para correspondências de duas equipes usandocompound. No exemplo:

  • OSimilarLeagueDistanceRegra garante que todos os jogadores em uma correspondência tenham umleaguedentro de 2 de outros jogadores.

  • OSimilarSkillDistanceRegra garante que todos os jogadores em uma correspondência tenham umskilldentro de 10 de outros jogadores. Se um jogador estiver esperando 10 segundos, a distância será expandida para 20. Se um jogador estiver esperando 20 segundos, a distância será expandida para 40.

  • OSameMapComparisonRegra garante que todos os jogadores em uma correspondência tenham solicitado o mesmomap.

  • OSameModeComparisonRegra garante que todos os jogadores em uma correspondência tenham solicitado o mesmomode.

  • OCompoundRuleMatchmakerUma regra garante uma correspondência se pelo menos uma das seguintes condições for true:

    • Jogadores em uma partida solicitaram o mesmomapE o mesmomode.

    • Jogadores em uma partida têm comparávelskilleleagueatributos.

{ "ruleLanguageVersion": "1.0", "teams": [{ "name": "red", "minPlayers": 10, "maxPlayers": 20 }, { "name": "blue", "minPlayers": 10, "maxPlayers": 20 }], "algorithm": { "strategy":"balanced", "balancedAttribute": "skill", "batchingPreference":"fastestRegion" }, "playerAttributes": [{ "name": "league", "type": "number" },{ "name": "skill", "type": "number" },{ "name": "map", "type": "string" },{ "name": "mode", "type": "string" }], "rules": [{ "name": "SimilarLeagueDistance", "type": "distance", "measurements": ["max(flatten(teams[*].players.attributes[league]))"], "referenceValue": "min(flatten(teams[*].players.attributes[league]))", "maxDistance": 2 }, { "name": "SimilarSkillDistance", "type": "distance", "measurements": ["max(flatten(teams[*].players.attributes[skill]))"], "referenceValue": "min(flatten(teams[*].players.attributes[skill]))", "maxDistance": 10 }, { "name": "SameMapComparison", "type": "comparison", "operation": "=", "measurements": ["flatten(teams[*].players.attributes[map])"] }, { "name": "SameModeComparison", "type": "comparison", "operation": "=", "measurements": ["flatten(teams[*].players.attributes[mode])"] }, { "name": "CompoundRuleMatchmaker", "type": "compound", "statement": "or(and(SameMapComparison, SameModeComparison), and(SimilarSkillDistance, SimilarLeagueDistance))" }], "expansions": [{ "target": "rules[SimilarSkillDistance].maxDistance", "steps": [{ "waitTimeSeconds": 10, "value": 20 }, { "waitTimeSeconds": 20, "value": 40 }] }] }