FlexMatch 규칙 세트 예제

FlexMatch 규칙 세트는 다양한 매치메이킹 시나리오를 포함할 수 있습니다. 다음 예제는 FlexMatch 구성 구조 및 속성 표현식 언어를 준수합니다. 이들 규칙 전부를 복사하거나 필요한 구성 요소를 선택합니다.

FlexMatch 규칙 및 규칙 세트 사용에 대한 자세한 내용은 다음 항목을 참조하십시오.

• FlexMatch 규칙 세트 설계

• FlexMatch 규칙 세트 설계

• FlexMatch 규칙 세트 스키마

• FlexMatch 규칙 언어

참고

복수 플레이어를 포함하는 매치메이킹 티켓을 평가할 때 요청에 포함된 모든 플레이어가 매치 요건을 충족해야 합니다.

예제 1: 플레이어가 동등하게 매칭된 두 팀 생성

이 예제에서는 다음과 같은 지침을 기준으로 플레이어가 동등하게 매치된 두 팀을 설정하는 방법을 설명합니다.

• 두 개의 플레이어 팀을 생성합니다.

  • 각 팀마다 4~8 명의 플레이어를 포함합니다.

  • 최종적으로 팀들의 플레이어 수가 동일해야 합니다.

• 플레이어의 스킬 레벨을 포함합니다(제공되지 않은 경우, 기본 설정 10).

• 스킬 레벨이 다른 플레이어와 비슷한지 여부를 바탕으로 플레이어를 선택합니다. 두 팀의 평균 플레이어 스킬이 10점 이내가 되도록 합니다.

• 매치가 신속하게 성사되지 않을 경우, 플레이어의 스킬 요건을 완화하여 합리적인 시간 내에서 매치가 성사되도록 합니다.

  • 5초 후에 검색을 확장하여 팀들의 평균 플레이어 스킬 차이를 50점 이내로 완화합니다.

  • 15초 후에 검색을 확장하여 팀들의 평균 플레이어 스킬 차이를 100점 이내로 완화합니다.

이 규칙 세트 사용에 대한 참고 사항:

• 이 예제에서는 팀의 규모가 4명에서 8명 사이입니다(물론 팀 간에 플레이어 수는 동일해야 함). 유효한 규모의 범위에 속하는 팀에 대해 매치메이커는 허용되는 최대 수의 플레이어를 매치하기 위해 최선의 시도를 합니다.

• FairTeamSkill 규칙에 의해 팀들은 플레이어 스킬을 바탕으로 균등하게 매치됩니다. 새로운 각 잠재 플레이어에 대해 이 규칙을 평가하기 위해 FlexMatch 는 임시로 플레이어를 팀에 추가하고 평균을 계산합니다. 규칙에 부합하지 않은 경우 해당 잠재 플레이어는 매치에 추가되지 않습니다.

• 두 팀의 구조가 서로 일치하므로 팀 정의를 하나만 생성하고 팀 수량을 "2"로 설정하도록 선택할 수 있었습니다. 이 시나리오에서는 팀 이름을 "aliens"로 지정했으므로 팀에 "aliens_1" 및 "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
        }]
    }]
}

예제 2: 불균일 팀 생성(헌터 대 몬스터)

이 예제에서는 플레이어 그룹이 단일 몬스터를 사냥하는 게임 모드를 설명합니다. 플레이어는 헌터와 몬스터 중 하나를 선택합니다. 헌터는 사냥하고자 하는 몬스터의 최소 스킬을 지정합니다. 매치 성사를 위해 헌터 팀의 최소 규모를 시간 경과에 따라 완화할 수 있습니다. 이 시나리오에서는 다음과 같은 지침을 설정합니다.

• 정확히 5명의 헌터로 구성되는 팀을 생성합니다.

• 정확히 1명의 몬스터로 구성되는 별도의 팀을 생성합니다.

• 다음 플레이어 속성을 포함합니다.

  • 플레이어의 스킬 레벨(제공되지 않은 경우, 기본 설정 10).

  • 플레이어가 선호하는 몬스터 스킬 레벨(제공되지 않은 경우, 기본 설정 10).

  • 플레이어가 몬스터가 되고 싶은지 여부(제공되지 않은 경우, 기본 설정 0 또는 F).

• 다음 기준에 따라 몬스터가 될 플레이어를 선택합니다.

  • 플레이어가 몬스터 역할을 요청해야 합니다.

  • 플레이어가 헌터 팀에 이미 속한 플레이어가 선호하는 최고 스킬 레벨 이상을 충족해야 합니다.

• 다음 기준에 따라 헌터 팀 플레이어를 선택합니다.

  • 몬스터 역할을 요청한 플레이어는 헌터 팀에 합류할 수 없습니다.

  • 몬스터 역할이 충원된 경우 플레이어가 원하는 몬스터의 스킬 레벨이 제안된 몬스터의 스킬보다 낮아야 합니다.

• 매치가 신속하게 이루어지지 않는 경우, 다음과 같이 헌터 팀의 최소 규모를 완화합니다.

  • 30초 후에는 네 명의 플레이어만 헌터 팀에 속해도 게임이 시작될 수 있도록 합니다.

  • 60초 후에는 세 명의 플레이어만 헌터 팀에 속해도 게임이 시작될 수 있도록 합니다.

이 규칙 세트 사용에 대한 참고 사항:

• 헌터와 몬스터 두 개의 별도 팀을 사용함으로써 각기 다른 일단의 기준으로 바탕으로 회원을 평가할 수 있습니다.

{
    "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 
        }]
    }]
}

예제 3: 팀 레벨 요구 사항 및 지연 시간 제한 설정

이 예제에서는 플레이어 팀을 설정하고 각 개별 플레이어 대신 각 팀에 규칙 세트를 적용하는 방법을 설명합니다. 여기서는 단일 정의를 사용하여 동등하게 매칭된 3개의 팀을 생성합니다. 또한 모든 플레이어에 대해 최대 지연 시간을 설정해 봅니다. 매치 성사를 위해 시간 경과에 따라 최대 지연 시간을 완화할 수 있습니다. 이 예제에서는 다음과 같은 지침을 설정합니다.

• 세 개의 플레이어 팀을 생성합니다.

  • 각 팀마다 3~5명의 플레이어를 포함합니다.

  • 최종적으로 팀들은 동일한 혹은 거의 동일한(차이: 1명 이내) 수의 플레이어를 포함해야 합니다.

• 다음 플레이어 속성을 포함합니다.

  • 플레이어의 스킬 레벨(제공되지 않은 경우, 기본 설정 10).

  • 플레이어의 캐릭터 역할(제공되지 않은 경우, 기본 설정 "농부").

• 매치에서 스킬 레벨이 다른 플레이어와 비슷한지 여부를 바탕으로 플레이어를 선택합니다.

  • 각 팀의 평균 플레이어 스킬이 10점 이내가 되도록 합니다.

• 팀의 "메딕" 캐릭터 수는 다음과 같이 제한합니다.

  • 매치 전체적으로 메딕의 최대 수는 5명입니다.

• 50밀리초 이하의 지연 시간을 보고하는 플레이어만 매칭합니다.

• 매치가 신속하게 이루어지지 않는 경우, 다음과 같이 플레이어 지연 시간 요건을 완화합니다.

  • 10초 후에는 플레이어 지연 시간 값을 최대 100ms로 완화합니다.

  • 20초 후에는 플레이어 지연 시간 값을 최대 150ms로 완화합니다.

이 규칙 세트 사용에 대한 참고 사항:

• 규칙 세트에 의해 팀들은 플레이어 스킬을 바탕으로 균등하게 매치됩니다. FairTeamSkill규칙을 평가하기 위해 예비 선수를 팀에 FlexMatch 임시로 추가하고 팀 내 선수들의 평균 실력을 계산합니다. 그런 다음 해당 평균 스킬을 두 팀에 있는 플레이어의 평균 스킬과 비교합니다. 규칙에 부합하지 않은 경우 해당 잠재 플레이어는 매치에 추가되지 않습니다.

• 팀 및 매치 레벨 요건(총 메딕 수)은 수집 규칙을 통해 달성합니다. 이 규칙 유형은 모든 플레이어의 캐릭터 속성 목록을 취하고 최대 카운트에 대해 확인합니다. flatten을 사용하여 모든 팀의 모든 플레이어 목록을 생성합니다.

• 지연 시간을 기준으로 평가할 때 다음에 유의합니다.

  • 지연 시간 데이터는 플레이어 객체의 일부로 매치메이킹 요청에 제공됩니다. 플레이어 속성이 아니므로 나열될 필요가 없습니다.

  • 매치메이커는 리전 별로 지연 시간을 평가합니다. 리전을 불문하고 지연 시간의 최대치보다 긴 경우 무시됩니다. 매치에 대해 수락되기 위해서는 플레이어의 지연 시간이 적어도 한 리전에서 최대치보다 짧아야 합니다.

  • 매치메이킹 요청에서 하나 이상의 플레이어에 대한 지연 시간 데이터가 누락된 경우 모든 매치에 대해 요청이 거부됩니다.

{
    "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
        }]
    }]
}

예제 4: 최선의 매치 검색을 위한 명시적 정렬 사용

이 예제에서는 플레이어 수가 각 세 명인 두 팀으로 구성된 간단한 매치를 설정합니다. 가능한 최선의 매치를 최대한 빨리 찾기 위해 명시적 정렬 규칙을 사용하는 방법을 설명합니다. 이들 규칙은 모든 액티브 매치메이킹 티켓을 정렬하여 특정 키 요건을 기준으로 최선의 매치를 생성합니다. 이 예제는 다음 지침으로 구현됩니다.

• 두 개의 플레이어 팀을 생성합니다.

• 각 팀마다 정확히 3명의 플레이어를 포함합니다.

• 다음 플레이어 속성을 포함합니다.

  • 경험 레벨(제공되지 않은 경우, 기본 설정 50).

  • 선호 게임 모드(복수 값 나열 가능)(제공되지 않은 경우 기본 설정 "협동" 및 "데스매치").

  • 선호 게임 맵(맵 이름 및 선호 가중치 포함)(제공되지 않은 경우 기본 설정 "defaultMap" 및 가중치 100).

• 사전 정렬 설정:

  • 앵커 플레이어와 동일한 게임 맵에 대한 선호를 기준으로 플레이어를 정렬합니다. 플레이어가 복수의 희망 게임 맵을 가질 수 있으므로 이 예제에서는 선호 값을 사용합니다.

  • 경험 레벨이 앵커 플레이어와 얼마나 근접한지를 기준으로 플레이어를 정렬합니다. 이렇게 정렬하고 나면 모든 팀에 있는 모든 플레이어가 최대한 근접하는 경험 레벨을 가지게 될 것입니다.

• 모든 팀에 걸쳐 모든 플레이어가 선택한 게임 모드 중 공통 게임 모드가 하나 이상 있어야 합니다.

• 모든 팀에 걸쳐 모든 플레이어가 선택한 게임 맵 중 공통 맵이 하나 이상 있어야 합니다.

이 규칙 세트 사용에 대한 참고 사항:

• 게임 맵 정렬은 mapPreference 속성 값을 비교하는 절대 정렬을 사용합니다. 이 정렬은 규칙 세트의 첫 번째 정렬이므로 맨 처음 수행됩니다.

• 경험 정렬은 거리 정렬을 사용하여 잠재 플레이어의 스킬 레벨을 앵커 플레이어의 스킬과 비교합니다.

• 정렬은 규칙 세트에 나열된 순서대로 수행됩니다. 이 시나리오에서는 플레이어를 게임 맵 선호도와 그 다음으로는 경험 레벨을 기준으로 정렬합니다.

{
    "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
    }]
}

예제 5: 복수 플레이어 속성 간의 교집합 찾기

이 예제에서는 두 개 이상의 플레이어 속성 간에 교집합을 찾기 위해 수집 규칙을 사용하는 방법을 보여줍니다. 속성 모음을 처리할 때 단일 속성의 경우 intersection 작업을, 다중 속성의 경우 reference_intersection_count 작업을 사용할 수 있습니다.

이러한 접근 방식을 보여주기 위해 이 예제에서는 선호하는 캐릭터를 토대로 매치에서 플레이어를 평가하고 있습니다. 예시 게임은 경기에 참가한 모든 플레이어가 상대가 되는 free-for-all "" 스타일 게임입니다. 각 플레이어는 (1) 자신의 캐릭터를 선택하고, (2) 게임 상대가 될 캐릭터를 선택하라는 요청 메시지를 받게 됩니다. 매치에 참여하는 모든 플레이어가 다른 모든 플레이어의 선호 상대 목록에 있는 캐릭터를 사용하도록 하는 규칙이 필요합니다.

다음은 다음과 같은 특성이 있는 매치를 설명하는 규칙 세트의 예제입니다.

• 팀 구성: 5명의 플레이어로 구성된 하나의 팀

• 플레이어 속성:

  • myCharacter: 플레이어가 선택한 캐릭터입니다.

  • preferredOpponents: 플레이어가 게임 상대로 선택하고 싶은 캐릭터의 목록입니다.

• 매치 규칙: 사용 중인 각 캐릭터가 모든 플레이어의 선호 상대 목록에 있는 경우에 잠재적 매치가 허용됩니다.

매치 규칙을 실행하기 위해 이 예제에서는 다음과 같은 속성 값을 가진 수집 규칙을 사용하고 있습니다.

• 작업 - reference_intersection_count 작업을 사용하여 측정 값의 각 문자열 목록이 참조 값의 문자열 목록과 어떻게 교집합을 이루는지 평가합니다.

• 측정 - flatten 속성 표현식을 사용하여 문자열 목록을 생성합니다. 각 문자열 목록에는 한 플레이어의 myCharacter 속성 값이 포함됩니다.

• 참조 값 - set_intersection 속성 표현식을 사용하여 매치에서 모든 플레이어에게 공통적인 preferredOpponents 속성 값 모두에 대한 문자열 목록을 생성합니다.

• 제한 - 각 플레이어가 선택한 캐릭터(측정 시 문자열 목록)는 모든 플레이어에 공통되는 선호 상대 중 최소 한 명과 매치될 수 있도록 minCount가 1로 설정됩니다.

• 확장 - 15초 내에 매치가 성사되지 않으면 최소한의 교집합 요구 사항을 완화합니다.

이 규칙의 프로세스 흐름은 다음과 같습니다.

1. 해당 매치에 플레이어가 추가됩니다. 새 플레이어가 선호하는 상대 목록과의 교집합을 포함시켜 참조 값(문자열 목록)이 다시 계산됩니다. 새 플레이어가 선택한 캐릭터를 새 문자열 목록으로 추가하여 측정 값(문자열 목록의 목록)이 다시 계산됩니다.

2. Amazon은 측정 값의 각 문자열 목록 (플레이어가 선택한 문자) 이 참조 값에 있는 하나 이상의 문자열 (플레이어가 선호하는 상대) 과 GameLift 교차하는지 확인합니다. 이 예제에서는 측정 값의 각 문자열 목록에 오직 하나의 값이 포함되어 있기 때문에 교집합은 0 또는 1입니다.

3. 측정 값의 어떤 문자열 목록도 참조 값 문자열 목록과 교집합을 이루지 않을 경우에는 규칙이 실패하고 새 플레이어가 해당 매치에서 제거됩니다.

4. 15초 내에 매치가 성사되지 않을 경우, 상대 매치 요건을 낮춰서 매치에서 나머지 플레이어 슬롯을 채웁니다.

{
    "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
        }]
    }]
}

예제 6: 모든 플레이어를 대상으로 속성 비교

이 예제에서는 플레이어 그룹에서 플레이어 속성을 비교하는 방법을 보여줍니다.

다음은 다음과 같은 특성이 있는 매치를 설명하는 규칙 세트의 예제입니다.

• 팀 구조: 두 개의 단일 플레이어 팀

• 플레이어 속성:

  • gameMode: 플레이어가 선택한 게임 유형입니다(제공되지 않는 경우 기본 설정 "순서 기반").

  • gameMap: 플레이어가 선택한 게임 세상입니다(제공되지 않는 경우 기본 설정 1).

  • character: 플레이어가 선택한 캐릭터입니다. 여기에 기본값이 없으면 플레이어가 캐릭터를 지정해야 합니다.

• 매치 규칙: 매치된 플레이어는 다음 요구 사항을 충족해야 합니다.

  • 플레이어들이 동일한 게임 모드를 선택해야 합니다.

  • 플레이어들이 동일한 게임 맵을 선택해야 합니다.

  • 플레이어들이 서로 다른 캐릭터를 선택해야 합니다.

이 규칙 세트 사용에 대한 참고 사항:

• 매치 규칙을 실행하기 위해 이 예제에서는 비교 규칙을 사용하여 모든 플레이어의 속성 값을 확인하고 있습니다. 게임 모드 및 맵에서 규칙은 값들이 동일한지 확인합니다. 각 캐릭터에서 규칙은 값들이 서로 다른지 확인합니다.

• 이 예제에서는 하나의 플레이어 정의를 수량 속성과 함께 사용하여 두 플레이어 팀을 모두 생성합니다. 팀에 "player_1" 및 "player_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])"]
    }]
}

예제 7: 라지 매치 생성

이 예제에서는 플레이어 수가 40명을 초과할 수 있는 매치에 대한 규칙 세트를 설정하는 방법을 설명합니다. 규칙 세트에서 총 maxPlayer 수가 40보다 큰 팀을 설명할 때 라지 매치로 처리됩니다. FlexMatch 라지 매치 규칙 세트 설계에서 자세히 알아보세요.

이 예제 규칙 세트는 다음 지침에 따라 매치를 생성합니다.

• 최소 요구 사항이 175명의 플레이어인 최대 200명의 플레이어로 이루어진 팀 하나를 생성합니다.

• 밸런싱 기준: 유사한 스킬 레벨에 따라 플레이어를 선택합니다. 모든 플레이어는 매칭될 자신의 스킬 레벨을 보고해야 합니다.

• 일괄 처리 선호도: 매치를 생성할 때 유사한 밸런싱 기준에 따라 플레이어를 그룹화합니다.

• 지연 시간 규칙: 최대 허용 가능 플레이어 지연 시간을 150밀리초로 설정합니다.

• 매치가 신속하게 채워지지 않는 경우 적합한 시간 내에 매치를 완료할 수 있도록 요구 사항을 완화합니다.

  • 10초 후에 플레이어가 150명인 팀을 수락합니다.

  • 12초 후에 최대 허용 가능 지연 시간을 200밀리초로 늘립니다.

  • 15초 후에 플레이어가 100명인 팀을 수락합니다.

이 규칙 세트 사용에 대한 참고 사항:

• 이 알고리즘은 "가장 큰 모집단" 일괄 처리 선호도를 사용하므로 밸런싱 기준에 따라 플레이어가 먼저 정렬됩니다. 따라서 매치는 더 채워지려고 하며 스킬이 더 유사한 플레이어를 포함하려고 합니다. 모든 플레이어는 허용 가능한 지연 시간 요구 사항을 충족하지만 자신의 위치에 대해 최상의 지연 시간을 얻지 못할 수도 있습니다.

• 이 규칙 세트에서 사용되는 알고리즘 전략인 "가장 큰 모집단"이 기본 설정입니다. 기본값을 사용하기 위해 이 설정을 생략하도록 선택할 수 있습니다.

• 매치 채우기를 활성화한 경우에는 플레이어 수 요구 사항을 너무 빨리 완화하지 마십시오. 부분적으로 채워진 게임 세션이 너무 많아질 수 있습니다. 라지 매치 요구 사항 완화에서 자세히 알아보세요.

{
    "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
        }]
    }]
}

예제 8: 복수 팀 라지 매치 생성

이 예제에서는 플레이어 수가 40명을 초과할 수 있는 복수 팀의 매치에 대한 규칙 세트를 설정하는 방법을 설명합니다. 이 예제에서는 하나의 정의로 동일한 복수 팀을 생성하는 방법 및 매치를 생성하는 동안 비대칭으로 크기가 지정된 팀을 채우는 방법을 설명합니다.

이 예제 규칙 세트는 다음 지침에 따라 매치를 생성합니다.

• 플레이어 수가 최대 15명인 동일한 "헌터" 팀 10개와 플레이어 수가 정확하게 5명인 "몬스터" 팀 한 개를 생성합니다.

• 밸런싱 기준: 몬스터 처리 수에 따라 플레이어를 선택합니다. 플레이어가 자신의 처리 수를 보고하지 않는 경우 기본값인 5를 사용합니다.

• 일괄 처리 선호도: 가장 빠른 플레이어 지연 시간을 보고하는 리전에 따라 플레이어를 그룹화합니다.

• 지연 시간 규칙: 최대 허용 가능 플레이어 지연 시간을 200밀리초로 설정합니다.

• 매치가 신속하게 채워지지 않는 경우 적합한 시간 내에 매치를 완료할 수 있도록 요구 사항을 완화합니다.

  • 15초 후에 플레이어가 10명인 팀을 수락합니다.

  • 20초 후에 플레이어가 8명인 팀을 수락합니다.

이 규칙 세트 사용에 대한 참고 사항:

• 이 규칙 세트는 잠재적으로 최대 155명의 플레이어를 포함할 수 있는 팀을 정의합니다. 이로 인해 라지 매치가 됩니다.(10 x 15명의 헌터 + 5명의 몬스터 = 155)

• 이 알고리즘은 "가장 빠른 리전" 일괄 처리 선호도를 사용하므로 플레이어가 보다 빠른 지연 시간을 보고하는 리전에 배치되려고 하며 높지만 허용 가능한 지연 시간을 보고하는 리전에는 배치되지 않으려는 경향을 보입니다. 동시에 매치에 더 적은 수의 플레이어가 포함될 가능성이 높아지고 밸런싱 기준(몬스터 스킬 수)이 더 다양해질 수도 있습니다.

• 복수 팀 정의(수량 > 1)에 대한 확장이 정의되면 해당 확장이 해당 정의로 생성된 모든 팀에 적용됩니다. 따라서 헌터 팀의 최소 플레이어 설정을 완화함으로써 10개의 헌터 팀 모두가 동등한 영향을 받게 됩니다.

• 이 규칙 세트는 플레이어 지연 시간을 최소화하도록 최적화되어 있으므로 지연 시간 규칙이 허용 가능한 연결 옵션이 없는 플레이어를 제외하는 catch-all로 사용됩니다. 이 요구 사항을 완화할 필요가 없습니다.

• 확장이 적용되기 전에 이 규칙 세트의 일치 항목을 FlexMatch 채우는 방법은 다음과 같습니다.

  • 아직 minPlayers 수에 도달한 팀이 없습니다. 헌터 팀의 열린 슬롯은 15개이고 몬스터 팀의 열린 슬롯은 5개입니다.

    • 첫 100명의 플레이어(10명씩)가 10개의 헌터 팀에 할당됩니다.

    • 다음 22명의 플레이어가 순차적으로(2명씩) 헌터 팀과 몬스터 팀에 할당됩니다.

  • 헌터 팀이 각각 12명의 플레이어인 minPlayers 수에 도달했습니다. 몬스터 팀에 2명의 플레이어가 있으며 아직 minPlayers 수에 도달하지 않았습니다.

    • 다음 3명의 플레이어가 몬스터 팀에 할당됩니다.

  • 모든 팀이 minPlayers 수에 도달했습니다. 헌터 팀에는 각각 3개의 열린 슬롯이 있습니다. 몬스터 팀이 채워졌습니다.

    • 마지막 30명의 플레이어가 순차적으로 헌터 팀에 할당됩니다. 따라서 모든 헌터 팀의 크기가 거의 비슷해집니다(한 명의 플레이어가 더 많거나 더 적음).

• 이 규칙 세트로 생성한 매치에 대한 채우기를 활성화한 경우에는 플레이어 수 요구 사항을 너무 빨리 완화하지 마십시오. 부분적으로 채워진 게임 세션이 너무 많아질 수 있습니다. 라지 매치 요구 사항 완화에서 자세히 알아보세요.

{
    "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
        }]
    }]
}

예제 9: 비슷한 특성을 가진 플레이어로 라지 매치 생성

이 예제는 batchDistance를 사용하여 두 팀이 참가하는 매치에 대한 규칙 세트를 설정하는 방법을 보여줍니다. 예제에서는:

• SimilarLeague 규칙은 매치에 참가하는 모든 플레이어가 다른 플레이어 2명 이내에 league를 갖도록 보장합니다.

• SimilarSkill 규칙은 매치에 참가하는 모든 플레이어가 다른 플레이어 10명 이내에 skill을 갖도록 보장합니다. 플레이어가 10초 동안 기다린 경우 거리는 20으로 확장됩니다. 플레이어가 20초 동안 기다린 경우 거리는 40으로 확장됩니다.

• SameMap 규칙은 매치에 참가한 모든 플레이어가 동일한 map를 요청하도록 보장합니다.

• SameMode 규칙은 매치에 참가한 모든 플레이어가 동일한 mode를 요청하도록 보장합니다.

{
    "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
        }]
    }]
}

예 10: 복합 규칙을 사용하여 비슷한 속성이나 비슷한 선택을 가진 플레이어로 매치 생성

이 예제는 compound를 사용하여 두 팀이 참가하는 매치에 대한 규칙 세트를 설정하는 방법을 보여줍니다. 예제에서는:

• SimilarLeagueDistance 규칙은 매치에 참가하는 모든 플레이어가 다른 플레이어 2명 이내에 league를 갖도록 보장합니다.

• SimilarSkillDistance 규칙은 매치에 참가하는 모든 플레이어가 다른 플레이어 10명 이내에 skill을 갖도록 보장합니다. 플레이어가 10초 동안 기다린 경우 거리는 20으로 확장됩니다. 플레이어가 20초 동안 기다린 경우 거리는 40으로 확장됩니다.

• SameMapComparison 규칙은 매치에 참가한 모든 플레이어가 동일한 map를 요청하도록 보장합니다.

• SameModeComparison 규칙은 매치에 참가한 모든 플레이어가 동일한 mode를 요청하도록 보장합니다.

• 다음 조건 중 하나에 해당하면 CompoundRuleMatchmaker 규칙이 일치하는지 확인합니다.

  • 매치에 참가한 플레이어도 동일한 map 및 mode 요청을 수행했습니다.

  • 매치에 참가한 플레이어는 비슷한 skill 및 league 속성을 가지고 있습니다.

{
    "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
        }]
    }]
}

예제 11: 플레이어의 차단 목록을 사용하는 규칙 생성

이 예제는 플레이어가 다른 특정 플레이어와 매칭되는 것을 피할 수 있는 규칙 세트를 보여줍니다. 플레이어는 차단 목록을 생성할 수 있으며, 매치메이커는 매치에 참가할 플레이어를 선택할 때 이를 평가합니다. 차단 목록 또는 금지 목록 기능을 추가하는 방법에 게임 블로그용 AWS를 참조하세요.

이 예제에서는 다음과 같은 지침을 설정합니다.

• 정확히 5명의 플레이어로 구성된 두 팀을 만듭니다..

• 플레이어 ID 목록(최대 100개)인 플레이어 차단 목록을 전달합니다.

• 모든 플레이어를 각 플레이어의 차단 목록과 비교하고 차단된 플레이어 ID가 발견되면 제안된 매치를 거부합니다.

이 규칙 세트 사용에 대한 참고 사항:

• 제안된 매치에 추가할 (또는 기존 매치의 한 스팟을 채우기 위해) 새 플레이어를 평가할 때 다음 이유 중 하나로 플레이어가가 거부될 수 있습니다.

  • 매치에 이미 선택된 플레이어의 차단 목록에 새 플레이어가 포함된 경우.

  • 새 플레이어의 차단 목록에 매치에 이미 선택된 플레이어가 포함된 경우.

• 그림에 표시된 대로 이 규칙 세트는 플레이어를 차단 목록에 있는 플레이어와 매칭하는 것을 방지합니다. 규칙 확장을 추가하고 maxCount 값을 높이면 이 요구 사항을 기본 설정(“방지” 목록이라고도 함)으로 변경할 수 있습니다.

{
    "name": "Player Block List",
    "ruleLanguageVersion": "1.0",
    "teams": [{
        "maxPlayers": 5,
        "minPlayers": 5,
        "name": "red"
    }, {
        "maxPlayers": 5,
        "minPlayers": 5,
        "name": "blue"
    }],
    "playerAttributes": [{
        "name": "BlockList",
        "type": "string_list",
        "default": []
    }],
    "rules": [{
        "name": "PlayerIdNotInBlockList",
        "type": "collection",
        "operation": "reference_intersection_count",
        "measurements": "flatten(teams[*].players.attributes[BlockList])",
        "referenceValue": "flatten(teams[*].players[playerId])",
        "maxCount": 0
    }]
}