FlexMatch ルールセットの例 - Amazon GameLift
例 1: プレイヤーが均等にマッチングされる 2 つのチームを作成する例 2: 不均等なチーム (ハンター対モンスター) を作成する 例 3: チームレベル要件とレイテンシーの制限を設定する例 4: 明示的な並べ替えを使用して最適なマッチングを見つける例 5: 複数のプレイヤー属性間の交差を見つける例 6: すべてのプレイヤー間の属性の比較例 7: ラージ試合を作成する例 8: 複数チームのラージ試合を作成する例 9: 類似の属性を持つプレイヤーとのラージ試合を作成する例 10: 複合ルールを使用して、類似の属性または類似のセレクションを持つプレイヤーとのマッチを作成する例 11: プレイヤーのブロックリストを使用するルールを作成する

翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

FlexMatch ルールセットの例

FlexMatch ルールセットは、さまざまなマッチメーキングシナリオに対応できます。次の例は、 FlexMatch 構成構造とプロパティ式言語に準拠しています。これらのルールセット全体をコピーするか、必要に応じてコンポーネントを選択します。

FlexMatch ルールとルールセットの使用の詳細については、以下のトピックを参照してください。

注記

複数のプレイヤーが含まれるマッチメーキングチケットを評価する場合は、リクエスト内のすべてのプレイヤーがマッチング要件を満たす必要があります。

例 1: プレイヤーが均等にマッチングされる 2 つのチームを作成する

この例では、プレイヤーが均等にマッチングされる 2 つのチームを設定する手順を示します。

  • プレイヤーのチームを 2 つ作成します。

    • 各チームに 4〜8 名のプレイヤーを含めます。

    • 最終的に両チームのプレイヤー数は同じにする必要があります。

  • プレイヤーのスキルレベルを含めます (指定しない場合、デフォルトの 10 が使用されます)。

  • スキルレベルが類似するプレイヤーを選択します。両チームのプレイヤーの平均スキル差は 10 ポイント以内とします。

  • すぐにマッチングが満たされない場合は、妥当な時間内にマッチングが完了するようにプレイヤーのスキル要件を緩和します。

    • 5 秒後に、検索範囲を広げて平均スキル差が 50 ポイント以内のプレイヤーを対象にします。

    • 15 秒後に、検索範囲を広げて平均スキル差が 100 ポイント以内のプレイヤーを対象にします。

このルールセットの使用に関する注意事項

  • この例では、チームのサイズが 4 〜 8 プレイヤーの任意のチームを対象にしています (ただし、両チームのサイズは同じにする必要があります)。チームのサイズが有効な範囲内である場合、マッチメーカーはできる限り最大数のプレイヤーをマッチングします。

  • FairTeamSkill ルールでは、プレイヤーのスキルに基づいてチームを均等にマッチングします。新たな見込みプレイヤーごとにこのルールを評価するために、 FlexMatch は暫定的にチームにプレーヤーを追加し、平均を計算します。ルールが失敗すると、プレイヤー候補はマッチングに追加されません。

  • 両方のチームは同一の構造を持っているため、1 つのチーム定義だけを作成し、チーム数を "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 つのチームを作成します。

  • 正確に 1 匹のモンスターで構成される別のチームを作成します。

  • 以下のプレイヤー属性を含めます。

    • プレイヤーのスキルレベル (指定しない場合、デフォルトの 10 が使用されます)。

    • プレイヤーが希望するモンスターのスキルレベル (指定しない場合、デフォルトの 10 が使用されます)。

    • プレイヤーがモンスターのロールを希望するかどうか (指定しない場合、デフォルトで 0 または false になります)。

  • 以下の条件に基づいてモンスターとなるプレイヤーを選択します。

    • プレイヤーはモンスターのロールをリクエストする必要があります。

    • プレイヤーは、ハンターチームに既に追加されているプレイヤーが希望する最高のスキルレベルを達成済みであるか、超えている必要があります。

  • 以下の条件に基づいてハンターチームに属するプレイヤーを選択します。

    • モンスターのロールをリクエストしたプレイヤーは、ハンターチームに参加できません。

    • モンスターのロールが既に埋まっている場合、プレイヤーが希望するモンスターのスキルレベルは、モンスター候補のスキルより低くなければなりません。

  • すぐにマッチングが達成されない場合は、以下のようにハンターチームの最小サイズを緩和します。

    • 30 秒後に、ハンターチームのプレイヤー 4 名のみでゲームを開始することを許可します。

    • 60 秒後に、ハンターチームのプレイヤー 3 名のみでゲームを開始することを許可します。

このルールセットの使用に関する注意事項

  • ハンターとモンスターに 2 つの異なるチームを使用することで、さまざまな条件のセットに基づいてメンバーシップを評価できます。

{
    "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 つの均等にマッチングされたチームを作成するための 1 つの定義を使用します。また、すべてのプレイヤーの最大レイテンシーを設定します。レイテンシーの最大値は、マッチングを達成するために徐々に緩和できます。この例では、以下の手順を開始します。

  • プレイヤーのチームを 3 つ作成します。

    • 各チームに 3〜5 名のプレイヤーを含めます。

    • 各チームの最終的なプレイヤー数は同数またはほぼ同数 (差は 1 以内) にする必要があります。

  • 以下のプレイヤー属性を含めます。

    • プレイヤーのスキルレベル (指定しない場合、デフォルトの 10 が使用されます)。

    • プレイヤーのキャラクターロール (指定しない場合、デフォルトの「農民」が使用されます)。

  • マッチングのスキルレベルが類似するプレイヤーを選択します。

    • 各チームのプレイヤーの平均スキル差は 10 ポイント以内とします。

  • チームの「医者」キャラクターを以下の数に制限します。

    • マッチング全体の医者の最大数は 5 とします。

  • 50 ミリ秒以下のレイテンシーを報告したプレイヤーのみにマッチングします。

  • すぐにマッチングが達成されない場合は、以下のようにプレイヤーのレイテンシー要件を緩和します。

    • 10 秒後に、プレイヤーのレイテンシー値として最大 100 ミリ秒まで許可します。

    • 20 秒後に、プレイヤーのレイテンシー値として最大 150 ミリ秒まで許可します。

このルールセットの使用に関する注意事項

  • このルールセットでは、プレイヤーのスキルに基づいてチームを均等にマッチングします。FairTeamSkill ルールを評価するために、 は潜在的なプレイヤーをチームに FlexMatch 暫定的に追加し、チーム内のプレイヤーの平均スキルを計算します。次に、これを両方のチームのプレイヤー平均スキルと比較します。ルールが失敗すると、プレイヤー候補はマッチングに追加されません。

  • チームレベルおよびマッチングレベルの要件 (医者の総数) は、収集ルールを通じて達成されます。このルールタイプでは、すべてのプレイヤーのキャラクター属性のリストを、最大数に照らしてチェックします。すべてのチームのすべてのプレイヤーのリストを作成するには、flatten を使用します。

  • レイテンシーに基づいて評価する場合は、以下の点に注意してください。

    • レイテンシーデータは、Player オブジェクトの一部としてマッチメーキングリクエストで提供されます。これは属性ではないため、属性としてリストする必要はありません。

    • マッチメーカーは、リージョン別にレイテンシーを評価します。レイテンシーが最大数を超えるすべてのリージョンは無視されます。プレイヤーがマッチングで承諾されるためには、レイテンシーが最大値未満のリージョンが少なくとも 1 つ必要です。

    • マッチメーキングリクエストが 1 人または複数のプレイヤーのレイテンシデータを省略した場合、そのリクエストはすべてのマッチで拒否されます。

{
    "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 人ずつのプレイヤーで構成される 2 つのチームでシンプルなマッチングを設定します。明示的な並べ替えルールを使用して、可能な限り最良のマッチングをできるだけ早く見つける方法を示します。これらのルールでは、すべてのアクティブなマッチメーキングチケットを事前に並べ替え、特定のキーとなる要件に基づいて最適な対戦を作成します。この例は、以下の手順に従って実装します。

  • プレイヤーのチームを 2 つ作成します。

  • 各チームを正確に 3 人のプレイヤーで構成します。

  • 以下のプレイヤー属性を含めます。

    • 経験レベル (指定しない場合、デフォルトで 50 が使用されます)。

    • 優先するゲームモード (複数の値をリスト可能) (指定しない場合、デフォルトで「クープ」と「デスマッチ」が使用されます)。

    • 優先するゲームマップ (マップ名と優先重み付けを含む) (指定しない場合、デフォルトで重み 100 の "defaultMap" が使用されます)。

  • 事前並べ替えを設定します。

    • アンカープレイヤーとして同じゲームマップを優先する度合いに基づいてプレイヤーを並べ替えます。プレイヤーのお気に入りのゲームマップは複数存在することがあるため、この例では優先値を使用しています。

    • 経験レベルがアンカープレイヤーとどれだけ近くマッチングするかに基づいてプレイヤーを並べ替えます。この並べ替えにより、すべてのチーム間ですべてのプレイヤーの経験レベルができるだけ近いものになります。

  • すべてのチーム間ですべてのプレイヤーが少なくとも 1 つのゲームモードを共通して選択している必要があります。

  • すべてのチーム間ですべてのプレイヤーが少なくとも 1 つのゲームマップを共通して選択している必要があります。

このルールセットの使用に関する注意事項

  • ゲームマップの並べ替えでは、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: 複数のプレイヤー属性間の交差を見つける

この例では、収集ルールを使用して、2 つ以上のプレイヤー属性の交差を見つける方法を説明します。コレクションを操作するときは、1 つの属性に対しては intersection オペレーションを使用し、複数の属性に対しては reference_intersection_count オペレーションを使用できます。

この方法を説明するために、この例ではキャラクターの設定に基づいて、マッチングのプレイヤーを評価します。サンプルゲームはfree-for-all「」スタイルで、試合内のすべてのプレイヤーが対戦相手です。各プレイヤーは、(1) 自分のキャラクターを選択し、(2) 対戦するキャラクターを選択することが求められます。マッチングの各プレイヤーが、他のすべてのプレイヤーの希望する対戦相手リストに含まれているキャラクターを使用するようにするルールが必要です。

このルールセットの例では、次の特性を持つマッチングについて説明します。

  • チーム構造: 5 人のプレイヤーがいる 1 つのチーム

  • プレイヤー属性:

    • myCharacter: プレイヤーが選択したキャラクター。

    • preferredOpponents: プレイヤーが対戦したいキャラクターのリスト。

  • マッチングルール: 使用中の各キャラクターが各プレイヤーの希望する対戦リストに含まれている場合、マッチング候補は受け入れ可能です。

マッチングルールを実装するため、この例では次のプロパティ値を持つ収集ルールを使用します。

  • オペレーション reference_intersection_count オペレーションを使用して、測定値の文字列リストがリファレンス値の文字列リストと交差する方法を評価します。

  • 測定 flatten プロパティ表現を使用して文字列のリストを作成し、各リストに 1 人のプレイヤーの myCharacter 属性値を含めます。

  • リファレンス値 set_intersection プロパティ表現を使用して、試合の各プレイヤーに共通するすべての preferredOpponents 属性値を含む文字列のリストを作成します。

  • 制約 minCount を 1 に設定し、各プレイヤーの選択したキャラクター (測定値の文字列のリスト) が、すべてのプレイヤーに共通の 1 人以上の優先される対戦相手 (リファレンス値の文字列) と一致するようにします。

  • 拡張 15 秒以内にマッチングが達成されない場合は、最小の交差要件を緩和します。

このルールのプロセスフローは次のようになります。

  1. プレイヤーがマッチング候補に追加されます。参照値 (文字列のリスト) が再計算され、新しいプレイヤーの希望の対戦相手リストに交差が含まれるようにします。計測値 (文字列のリスト) が再計算され、新しいプレイヤーの選択されたキャラクターが新しい文字列リストとして追加されます。

  2. Amazon は、測定値の各文字列リスト (プレイヤーが選択したキャラクター) が、リファレンス値 (プレイヤーの優先対戦相手) の少なくとも 1 つの文字列と交差する GameLift ことを確認します。この例では、測定値の各文字列リストには値が 1 つしか含まれないため、交差は 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: すべてのプレイヤー間の属性の比較

この例では、プレイヤーのグループ間でプレイヤー属性を比較する方法を示します。

このルールセットの例では、次の特性を持つマッチングについて説明します。

  • チーム構造: 2 つの単一プレイヤーチーム

  • プレイヤー属性:

    • gameMode: プレイヤーによって選択されたゲームのタイプ (指定されていない場合は、デフォルトで「順番ベース」となります)。

    • gameMap: プレイヤーによって選択されたゲーム世界 (指定されない場合は、デフォルトで 1 になります)。

    • キャラクター: プレイヤーによって選択されたキャラクター (デフォルト値がない場合、プレイヤーはキャラクターを指定する必要があります)。

  • マッチングルール: マッチングされたプレイヤーは次の要件を満たす必要があります。

    • プレイヤーは同じゲームモードを選択する必要があります。

    • プレイヤーは同じゲームマップを選択する必要があります。

    • 多くのプレイヤーは異なるキャラクターを選択します。

このルールセットの使用に関する注意事項

  • この例では、マッチングルールを実装するため、比較ルールを使用してすべてのプレイヤーの属性値を確認します。ゲームモードとマップについては、値が同じことがルールで確認されます。キャラクターについては、値が異なることがルールで確認されます。

  • この例では、両方のプレイヤーチームを作成するために数量プロパティを指定して 1 つのプレイヤー定義を使用します。チームには、"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 以上であると定義された場合、大規模なマッチングとして処理されます。詳細については、「ラージ対戦ルールセットの設計」を参照してください。

この例のルールセットでは、以下の手順に従ってマッチングが作成されます。

  • 最大 200 人、最低 175 人のプレイヤーがいる 1 つのチームを作成します。

  • バランシング条件: 類似したスキルレベルに基づいてプレイヤーを選択します。すべてプレイヤーは、マッチングのためにスキルレベルを報告する必要があります。

  • バッチ優先設定: マッチングの作成時に、類似したバランシング条件によってプレイヤーをグループ化します。

  • レイテンシールール: 最大許容プレイヤーレイテンシーとして 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 人を超える複数チームのマッチング用にルールをセットセットアップする方法を示しています。この例は、1 つの定義を持つ複数の同じチームを作成する方法と、マッチング作成で非対称サイズのチームを満たす方法を示しています。

この例のルールセットでは、以下の手順に従ってマッチングが作成されます。

  • 最大 15 人のプレイヤーがいる同一の「ハンター」チームを 10 個と、厳密に 5 人のプレイヤーがいる「モンスター」チームを 1 個作成します。

  • バランシング要件: モンスターを倒した数を基準にプレイヤーを選択します。プレイヤーが倒した数を報告しない場合は、デフォルト値の 5 を使用します。

  • バッチ優先設定: 最短のプレイヤーレイテンシーが報告されているリージョンを基準に、プレイヤーをグループ化します。

  • レイテンシールール: 許容されるプレイヤーレイテンシーの最大値を 200 ミリ秒に設定します。

  • すぐにマッチングが満たされない場合は、妥当な時間内にマッチングを完了するために要件を緩和します。

    • 15 秒後に、10 人のプレイヤーチームを受け入れます。

    • 20 秒後に、8 人のプレイヤーチームを受け入れます。

このルールセットの使用に関する注意事項

  • このルールセットは、潜在的に最大 155 人のプレイヤーを保持できるチームを定義します。これはラージ試合となります。（10×15ハンター　+　5　モンスター　=　155）

  • アルゴリズムは「最短リージョン」バッチ優先設定を使用しているため、プレイヤーはより高い (許容範囲内の) レイテンシーを報告しているリージョンよりも、より速いレイテンシーを報告しているリージョンに配置される傾向があります。同時に、マッチングのプレイヤーはより少数になり、バランシング条件 (モンスタースキルの数) はより広範囲になる可能性があります。

  • 拡張は、複数チーム (数量 > 1) に対して定義された場合、定義を作成したすべてのチームに適用されます。したがって、ハンターチームの最小プレイヤー設定を緩和することによって、10 個すべてのハンターチームが同様に影響を受けます。

  • このルールセットはプレイヤーレイテンシーを最小にするために最適化されているため、このレイテンシールールは許容される接続オプションを持たないプレイヤーを除外するキャッチオールとして機能します。この要件を緩和する必要はありません。

  • 拡張が有効になる前に、 がこのルールセットの一致 FlexMatch を満たす方法は次のとおりです。

    • どのチームも minPlayers カウントにまだ達していません。ハンターチームには 15 個の空きスロットがあり、モンスターチームには 5 つの空きスロットがあります。

      • 最初の 100 人のプレイヤーが (10 人ずつ) 10 個のハンターチームに割り当てられます。

      • 次の 22 名のプレイヤーは順番に (2 人ずつ) ハンターチームとモンスターチームに割り当てられます。

    • ハンターチームはそれぞれ minPlayers カウントである 12 人のプレイヤーに達しました。モンスターチームには 2 人のプレイヤーがいて、minPlayers カウントには達していません。

      • 次の 3 人のプレイヤーがモンスターチームに割り当てられます。

    • すべてのチームが minPlayers カウントに達しました。ハンターチームにはそれぞれ 3 つの空きスロットがあります。モンスターチームのスロットがいっぱいになりました。

      • 最後の 30 人のプレイヤーが順にハンターチームに割り当てられ、すべてのハンターチームがほぼ同じサイズ (+/- 1 人のプレイヤー) になります。

  • このルールセットを使用して作成されたマッチングに対してバックフィルが有効になっている場合、プレイヤーカウント要件を急に緩和しないでください。緩和が速すぎると、部分的に満たされたゲームセッションが大量に作成される可能性があります。詳細については、「ラージな対戦要件の緩和」を参照してください。

{
    "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 を使用して 2 つのチームとの試合にルールセットを設定する方法を示します。これらの例では:

  • SimilarLeagueルールにより、試合内のすべてのプレイヤーがleague 2人以内の他のプレイヤーを保持します。

  • SimilarSkillルールにより、試合内のすべてのプレイヤーがskill 10人以内の他のプレイヤーを保持します。プレイヤーが 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 を使用して 2 つのチームとの試合にルールセットを設定する方法を示します。これらの例では:

  • SimilarLeagueDistanceルールにより、試合内のすべてのプレイヤーがleague 2人以内の他のプレイヤーを保持します。

  • SimilarSkillDistanceルールにより、試合内のすべてのプレイヤーがskill 10人以内の他のプレイヤーを保持します。プレイヤーが 10 秒待っている場合、距離は20に拡大されます。プレイヤーが 20 秒待っている場合、距離は40に拡大されます。

  • SameMapComparisonルールにより、試合内のすべてのプレイヤーが同じことをリクエストしていることが保証されますmap。

  • SameModeComparisonルールにより、試合内のすべてのプレイヤーが同じことをリクエストしていることが保証されますmode。

  • CompoundRuleMatchmaker ルールにより、以下の条件の内 1 つが true である場合に、マッチを保証します。

    • マッチ内のプレイヤーは同じ 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 人のプレイヤーで構成される 2 つのチームを作成します。

  • プレイヤー 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
    }]
}