FlexMatch Beispiele für Regelsätze

FlexMatch -Regelsätze können eine Vielzahl von Matchmaking-Szenarien abdecken. Die folgenden Beispiele entsprechen der FlexMatch Konfigurationsstruktur und der Sprache des Eigenschaftsausdrucks. Kopieren Sie diesen Regelsatz komplett, oder wählen Sie nach Bedarf Komponenten davon aus.

Weitere Informationen zur Verwendung von FlexMatch Regeln und Regelsätzen finden Sie in den folgenden Themen:

• Erstellen Sie einen FlexMatch Regelsatz

• Entwerfen Sie einen FlexMatch Regelsatz

• FlexMatchRegelsatzschema

• FlexMatchRegeln, Sprache

Anmerkung

Bei der Auswertung eines Matchmaking-Tickets mit mehreren Spielern müssen alle Spieler in der Anforderungen die Match-Anforderungen erfüllen.

Beispiel 1: Erstellen von zwei Teams mit gleichmäßig übereinstimmenden Spielern

In diesem Beispiel wird gezeigt, wie Sie zwei gleichmäßig abgeglichenen Spielerteams mit den folgenden Anweisungen erstellen.

• Erstellen Sie zwei Spielerteams.

  • Nehmen Sie zwischen vier und acht Spieler in jedes Team auf.

  • Fertige Teams müssen die gleiche Anzahl von Spielern haben.

• Berücksichtigen Sie die Qualifikationsstufe eines Spielers (falls nicht vorhanden, standardmäßig 10).

• Wählen Sie Spieler abhängig davon aus, ob ihre Qualifikation ähnlich der der anderen Spieler ist. Stellen Sie sicher, dass beide Teams durchschnittliche Spielerqualifikationen innerhalb einer Toleranz von 10 Punkten zueinander aufweisen.

• Wenn das Match nicht schnell gefüllt wird, lockern Sie die Qualifikationsanforderung, um innerhalb einer angemessenen Zeit ein Match zu erstellen.

  • Nach 5 Sekunden erweitern Sie die Suche so, dass Teams mit durchschnittlichen Spielerqualifikationen in einem Bereich von 50 Punkten zulässig sind.

  • Nach 15 Sekunden erweitern Sie die Suche so, dass Teams mit durchschnittlichen Spielerqualifikationen in einem Bereich von 100 Punkten zulässig sind.

Hinweise zur Verwendung dieses Regelsatzes:

• Dieses Beispiel lässt Teams einer beliebigen Größe zwischen vier und acht Spielern zu (obwohl sie dieselbe Größe haben müssen). Für Teams mit mehreren gültigen Größen, versucht der Matchmaker, die maximale Anzahl zulässiger Spieler so gut wie möglich zu erfüllen.

• Die FairTeamSkill-Regel stellt sicher, dass die Teams basierend auf den Spielerqualifikationen gleichmäßig abgeglichen sind. Um diese Regel für jeden neuen potenziellen Spieler auszuwerten, fügt FlexMatch den Spieler vorläufig einem Team hinzu und berechnet die Durchschnittswerte. Wenn eine Regel fehlschlägt, wird der potenzielle Spieler dem Match nicht hinzugefügt.

• Da die Strukturen beider Teams identisch sind, könnten Sie nur eine Teamdefinition erstellen und als Teamanzahl „2“ festlegen. Wenn Sie dem Team in diesem Szenario den Namen „aliens“ geben würden, dann würden Ihren Teams die Namen „aliens_1“ und „aliens_2“. zugewiesen werden.

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

Beispiel 2: Erstellen ungleichmäßiger Teams (Hunters vs. Monster)

Dieses Beispiel beschreibt einen Spielmodus, wobei eine Gruppe von Spielern ein einziges Monster jagt. Die Spieler wählen Sie die Jäger- oder die Monster-Rolle. Jäger geben das Mindestqualifikationsniveau für das Monster an, das sie jagen wollen. Die Mindestgröße des Jägerteams kann im Laufe der Zeit gelockert werden, um das Match fertigzustellen. Dieses Szenario enthält die folgenden Anweisungen:

• Erstellen Sie ein Team von genau fünf Jägern.

• Erstellen Sie ein separates Team mit genau einem Monster.

• Berücksichtigen Sie die folgenden Spielerattribute:

  • Die Qualifikationsstufe eines Spielers (falls nicht vorhanden, standardmäßig 10).

  • Die bevorzugte Monster-Qualifikationsstufe eines Spielers (falls nicht vorhanden, standardmäßig 10).

  • Ob der Spieler das Monster sein will (falls nicht vorhanden, standardmäßig 0 oder false).

• Wählen Sie einen Spieler als Monster basierend auf den folgenden Kriterien:

  • Der Spieler muss die Monsterrolle angefordert haben.

  • Der Spieler muss das höchste Qualifikationsniveau haben, das die Spieler, die bereits im Jägerteam vorhanden sind, bevorzugen, oder dieses übertreffen.

• Wählen Sie Spieler für das Jägerteam basierend auf den folgenden Kriterien:

  • Spieler, die eine Monster-Rolle anfordern, können nicht dem Jägerteam beitreten.

  • Wenn die Monster-Rolle bereits belegt ist, muss der Spieler ein gewünschtes Monster-Qualifikationsniveau anfordern, das niedriger als die Qualifikation des vorgeschlagenen Monsters ist.

• Wird ein Match nicht schnell gefüllt, lockern Sie die Mindestgröße des Jägerteams wie folgt:

  • Nach 30 Sekunden darf ein Spiel mit nur vier Spielern im Jägerteam starten.

  • Nach 60 Sekunden darf ein Spiel mit nur drei Spielern im Jägerteam starten.

Hinweise zur Verwendung dieses Regelsatzes:

• Durch die Verwendung von zwei separaten Teams für Jäger und Monster können Sie die Mitgliedschaft basierend auf verschiedenen Kriterien bewerten.

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

Beispiel 3: Festlegen von Anforderungen und Latenzlimits auf Teamebene

In diesem Beispiel wird veranschaulicht, wie Spielerteams eingerichtet und ein Regelsatz anstatt auf einzelne Spieler auf jedes Team angewandt wird. Anhand einer einzigen Definition werden drei gut abgestimmte Teams erstellt. Außerdem wird eine maximale Latenz für alle Spieler festgelegt. Maximalwerte für die Latzen können im Laufe der Zeit gelockert werden, um das Match zu vervollständigen. In diesem Beispiel werden die folgenden Anweisungen beschrieben:

• Erstellen Sie drei Spielerteams.

  • Nehmen Sie zwischen drei und fünf Spieler in jedes Team auf.

  • Fertige Teams müssen die gleiche oder fast die gleiche Anzahl von Spielern (plus/minus einem Spieler) aufweisen.

• Berücksichtigen Sie die folgenden Spielerattribute:

  • Die Qualifikationsstufe eines Spielers (falls nicht vorhanden, standardmäßig 10).

  • Die Charakterrolle eines Spielers (falls nicht vorhanden, standardmäßig „Bauer“).

• Wählen Sie Spieler abhängig davon aus, ob ihre Qualifikation ähnlich der der anderen Spieler im Match sind.

  • Stellen Sie sicher, dass beide Teams durchschnittliche Spielerqualifikationen innerhalb einer Toleranz von 10 Punkten zueinander aufweisen.

• Beschränken Sie Teams an die folgende Anzahl von „Heiler“-Charakteren:

  • Ein ganzes Match kann maximal fünf Heiler haben.

• Nehmen Sie nur Spieler in ein Match auf, die eine Latenz von 50 Millisekunden oder weniger verzeichnen.

• Wird ein Match nicht schnell gefüllt, lockern Sie die Anforderung an die Spieler-Latenz wie folgt:

  • Nach 10 Sekunden lassen Sie Latenzwerte von bis zu 100 ms für die Spieler zu.

  • Nach 20 Sekunden lassen Sie Latenzwerte von bis zu 150 ms für die Spieler zu.

Hinweise zur Verwendung dieses Regelsatzes:

• Der Regelsatz stellt sicher, dass die Teams basierend auf den Spielerqualifikationen gleichmäßig abgeglichen sind. Um die FairTeamSkill Regel zu bewerten, fügt den potenziellen Spieler FlexMatch einem Team hinzu und berechnet die durchschnittliche Fähigkeit der Spieler im Team. Anschließend wird die Regel mit der durchschnittlichen Qualifikation der Spieler in beiden Teams verglichen. Wenn eine Regel fehlschlägt, wird der potenzielle Spieler dem Match nicht hinzugefügt.

• Die Team- und Match-Level-Anforderungen (Gesamtanzahl der Heiler) werden durch eine Sammlungsregel erzielt. Dieser Regeltyp vergleicht eine Liste von Charakterattributen aller Spieler und verglicht sie mit der maximal zulässigen Anzahl. Verwenden Sie flatten zum Erstellen einer Liste aller Spieler in allen Teams.

• Bei der Auswertung von basierend auf Latenz, beachten Sie Folgendes:

  • Latenzdaten werden in der Matchmaking-Anforderung als Teil des Player-Objekts bereitgestellt. Es handelt sich nicht um ein Spielerattribut, sodass es nicht als solches aufgeführt werden muss.

  • Der Matchmaker bewertet die Latenz nach Region. Jede Region mit einer Latenz höher als der maximal zulässigen Latzen wird ignoriert. Um für ein Match akzeptiert zu werden, muss ein Spieler mindestens eine Region mit einer Latenz unterhalb der maximal zulässigen Latenz haben.

  • Wenn Matchmaking-Anforderungen Latenzdaten für einen oder mehrere Spieler weglassen, wird die Anforderung für alle Matches abgelehnt.

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

Beispiel 4: Verwenden Sie die explizite Sortierung, um die besten Übereinstimmungen zu finden

In diesem Beispiel wird ein einfaches Match mit zwei Teams mit jeweils drei Spielern eingerichtet. Es veranschaulicht, wie Sie explizite Sortierregeln anwenden, um die bestmöglichen Matches so schnell wie möglich zu finden. Diese Regeln sortieren alle aktiven Matchmaking-Tickets, um die besten Übereinstimmungen auf der Grundlage bestimmter Schlüsselanforderungen zu erstellen. Dieses Beispiel wird mit den folgenden Anweisungen implementiert:

• Erstellen Sie zwei Spielerteams.

• Nehmen Sie genau drei Spieler in jedes Team auf.

• Berücksichtigen Sie die folgenden Spielerattribute:

  • Qualifikationsniveau (falls nicht vorhanden, standardmäßig 50).

  • Bevorzugte Spielmodi (es können mehrere Werte angegeben werden) (falls nicht vorhanden, standardmäßig „coop“ und „deathmatch“).

  • Bevorzugte Spiel-Karten, einschließlich Kartenname und Prioritätsgewichtung (falls nicht vorhanden, standardmäßig "defaultMap", mit einem Gewicht von 100).

• Einrichtung der Vorsortierung:

  • Sortieren Sie Spieler basierend auf ihrer Präferenz für dieselbe Spiel-Karte wie der Anker-Spieler. Spieler können mehrere bevorzugte Spiel-Karten haben, deshalb verwendet dieses Beispiel einen Präferenzwert.

  • Sortieren Sie Spieler anhand dessen, wie gut ihre Erfahrung mit der eines Anker-Spielers übereinstimmt. Dank dieser Sortierung verfügen alle Spieler in allen Teams über Erfahrungsniveaus, die so ähnlich wie möglich sind.

• Alle Spieler in allen Teams muss mindestens einen gemeinsamen Spiel-Modus ausgewählt haben.

• Alle Spieler in allen Teams muss mindestens eine gemeinsame Spiel-Karte ausgewählt haben.

Hinweise zur Verwendung dieses Regelsatzes:

• Die Sortierung nach Spiel-Karte verwendet eine absolute Sortierung, die den mapPreference-Attributwert vergleicht. Da diese Regel an erster Stelle des Regelsatzes steht, erfolgt diese Sortierung zuerst.

• Die Sortierung nach Erfahrung verwendet eine Distanzsortierung, um die Qualifikationsstufe eines potenziellen Spielers mit der Qualifikation des Anker-Spielers zu vergleichen.

• Sortierungen werden in der Reihenfolge ausgeführt, in der sie im Regelsatz aufgelistet werden. In diesem Szenario werden Spieler nach der Präferenz für ihre Spiel-Karte und dann nach dem Erfahrungswert sortiert.

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

Beispiel 5: Bestimmung von Schnittmengen über mehrere Spielerattribute hinweg

Dieses Beispiel veranschaulicht, wie Sie mit einer Sammlungsregel Schnittmengen in zwei oder mehreren Spielerattributen finden. Beim Arbeiten mit Sammlungen können Sie die intersection-Operation für ein einzelnes Attribut und die reference_intersection_count-Operation für mehrere Attribute verwenden.

Um diesen Ansatz zu verdeutlichen, wertet dieses Beispiel Spieler in einem Match basierend auf ihren Charakter-Präferenzen aus. Das Beispielspiel ist ein „free-for-all“-Stil, bei dem alle Spieler in einem Spiel Opponenten sind. Jeder Spieler wird aufgefordert, (1) einen Charakter für sich zu wählen, und (2) Charaktere zu wählen, gegen die er spielen möchte. Wir brauchen eine Regel, die gewährleistet, dass jeder Spieler in einem Match einen Charakter verwendet, der auf der Liste bevorzugter Gegner der anderen Spieler steht.

Der Beispielregelsatz beschreibt ein Match mit den folgenden Eigenschaften:

• Team-Struktur: Ein Team mit fünf Spielern

• Spielerattribute:

  • myCharacter: Der vom Spieler ausgewählte Charakter.

  • preferredOpponents: Liste der Charaktere, gegen die der Spieler spielen will.

• Match-Regeln: Ein potenzielles Match ist akzeptabel, wenn sich jeder der verwendeten Charaktere auf der Liste der bevorzugten Gegner aller Spieler befindet.

Um die Match-Regeln zu implementieren, verwendet dieses Beispiel eine Sammlungsregel mit den folgenden Eigenschaftswerten:

• Operation – Verwendet die -reference_intersection_countOperation, um auszuwerten, wie sich jede Zeichenfolgenliste im Messungswert mit der Zeichenfolgenliste im Referenzwert schneidet.

• Messung – Verwendet den flatten Eigenschaftsausdruck, um eine Liste von Zeichenfolgenlisten zu erstellen, wobei jede Zeichenfolgenliste den myCharacter-Attributwert eines Spielers enthält.

• Referenzwert – Verwendet den -set_intersectionEigenschaftsausdruck, um eine Zeichenfolgenliste aller preferredOpponents-Attributwerte zu erstellen, die jedem Spieler im Match gemeinsam sind.

• Einschränkungen – minCount ist auf 1 gesetzt, um sicherzustellen, dass das von jedem Spieler gewählte Zeichen (eine Zeichenfolgenliste in der Messung) mit mindestens einem der bevorzugten Opponenten übereinstimmt, die allen Spielern gemeinsam sind. (eine Zeichenfolge im Referenzwert).

• Erweiterung – Wenn eine Übereinstimmung nicht innerhalb von 15 Sekunden erfüllt wird, reduzieren Sie die Mindestüberschneidungsanforderung.

Der Verarbeitungsablauf für diese Regel sieht wie folgt aus:

1. Ein Spieler wird dem potenziellen Match hinzugefügt. Der Referenzwert (eine Zeichenfolgenliste) wird neu berechnet, um die Schnittmengen mit der Liste der bevorzugten Gegner des neuen Spielers zu beinhalten. Der Messwert (eine Liste von Zeichenfolgenlisten) wird neu berechnet, um den von dem neuen Spieler gewählten Charakter als neue Zeichenfolgenliste hinzuzufügen.

2. Amazon GameLift überprüft, ob sich jede Zeichenfolgenliste im Messungswert (die von den Spielern ausgewählten Zeichen) mit mindestens einer Zeichenfolge im Referenzwert (die bevorzugten Opponenten der Spieler) schneidet. Da in diesem Beispiel jede Zeichenfolgenliste in der Messung nur einen Wert enthält, ist die Schnittmenge entweder 0 oder 1.

3. Wenn eine Zeichenfolgenliste in der Messung keine Schnittmenge mit der Referenzwert-Zeichenfolgenliste hat, schlägt die Regel fehl und der neue Spieler wird aus dem potenziellen Match entfernt.

4. Wird ein Match nicht innerhalb von 15 Sekunden gefüllt, wird die Match-Anforderung des Gegners verworfen, die restlichen Spielerplätze im Match zu füllen.

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

Beispiel 6: Vergleichen von Attributen in allen Spielern

Dieses Beispiel veranschaulicht, wie Spielerattribute innerhalb einer Gruppe von Spielern verglichen werden.

Der Beispielregelsatz beschreibt ein Match mit den folgenden Eigenschaften:

• Teamstruktur: Zwei Singleplayer-Teams

• Spielerattribute:

  • gameMode: Art des vom Spieler gewählten Spiels (falls nicht angegeben, wird standardmäßig „rundenbasiert“ verwendet).

  • gameMap: Vom Spieler gewählte Spielwelt (falls nicht anders angegeben, standardmäßig 1).

  • character: Vom Spieler gewählte Spielfigur (kein Standardwert bedeutet, dass der Spieler eine Spielfigur angeben muss).

• Match-Regeln: In einem Match platzierte Spieler müssen die folgenden Anforderungen erfüllen:

  • Die Spieler müssen denselben Spiel-Modus wählen.

  • Die Spieler müssen dieselbe Spielekarte wählen.

  • Die Spieler müssen unterschiedliche Charaktere wählen.

Hinweise zur Verwendung dieses Regelsatzes:

• Um die Match-Regel zu implementieren, verwendet dieses Beispiel Vergleichsregeln, um die Attributwerte aller Spieler zu vergleichen. Für den Spielmodus und die Karte überprüft die Regel, ob die Werte identisch sind. Für den Charakter überprüft die Regel, ob die Werte unterschiedlich sind.

• Dieses Beispiel verwendet eine Spieler-Definition mit einer Mengen-Eigenschaft zum Erstellen beider Spieler-Teams. Dem Team werden die folgenden Namen zugewiesen: „player_1“ und „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])"]
    }]
}

Beispiel 7: Erstellen einer großen Übereinstimmung

In diesem Beispiel wird veranschaulicht, wie Sie einen Regelsatz für Matches mit mehr als 40 Spielern einrichten. Wenn ein Regelsatz Teams mit einer maxPlayer-Gesamtzahl größer als 40 beschreibt, wird er als großes Match verarbeitet. Weitere Informationen finden Sie unter Entwerfen Sie einen FlexMatch Regelsatz für große Übereinstimmungen.

Der Beispiel-Regelsatz erstellt ein Match unter Beachtung der folgenden Anweisungen:

• Erstellen Sie ein Team mit bis zu 200 Spielern mit einer Mindestanforderung von 175 Spielern.

• Ausgleichende Kriterien: Wählen Sie Spieler basierend auf vergleichbarer Qualifikationsstufe aus. Alle Spieler müssen ihre Qualifikationsstufe angeben, um in ein Match aufgenommen zu werden.

• Stapelverarbeitungs-Präferenz: Gruppieren Sie Spieler beim Erstellen von Matches nach ähnlichen ausgleichenden Kritieren.

• Latenzregeln: Legen Sie als maximal zulässige Spieler-Latenz 150 Millisekunden fest.

• Wenn das Match nicht schnell gefüllt wird, lockern Sie die Anforderung, um innerhalb einer angemessenen Zeit ein Match fertig zu stellen.

  • Akzeptieren Sie nach 10 Sekunden ein Team mit 150 Spielern.

  • Erhöhen Sie nach 12 Sekunden die maximale akzeptable Latenz auf 200 Millisekunden.

  • Akzeptieren Sie nach 15 Sekunden ein Team mit 100 Spielern.

Hinweise zur Verwendung dieses Regelsatzes:

• Da der Algorithmus die Stapelverarbeitungs-Präferenz „largestPopulation“ verwendet, werden Spieler zuerst basierend auf den ausgleichenden Kriterien sortiert. Dies hat zur Folge, dass Matches meist voller sind und Spieler mit ähnlicherer Qualifikation enthalten. Alle Spieler erfüllen akzeptable Latenzanforderungen, erhalten möglicherweise aber nicht die bestmögliche Latenz für ihren Ort.

• Die in diesem Regelsatz verwendete Algorithmusstrategie „largestPopulation“ ist die Standardeinstellung. Wenn Sie die Standardeinstellung verwenden möchten, müssen Sie die Einstellung nicht explizit angeben.

• Wenn Sie Match-Backfill aktiviert haben, lockern Sie die erforderliche Spieleranzahl nicht zu schnell. Andernfalls erhalten Sie zu viele nur teilweise gefüllte Spielsitzungen. Weitere Informationen finden Sie unter Relaxen Sie große Spielanforderungen.

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

Beispiel 8: Erstellen einer großen Übereinstimmung mit mehreren Teams

In diesem Beispiel wird veranschaulicht, wie ein Regelsatz für Matches mit mehreren Teams eingerichtet wird, die mehr als 40 Spieler enthalten können. Es wird aufgezeigt, wie mit einer Definition mehrere identische Teams erstellt werden und wie Teams asymmetrischer Größe bei der Erstellung des Matches gefüllt werden.

Der Beispiel-Regelsatz erstellt ein Match unter Beachtung der folgenden Anweisungen:

• Erstellen Sie zehn identische „Jäger“-Teams mit bis zu 15 Spielern und ein „Monster“-Team mit genau fünf Spielern.

• Ausgleichende Kriterien: Wählen Sie Spieler basierend auf der Anzahl der Monster-Kills aus. Verwenden Sie bei Spielern, für die keine Kill-Anzahl verzeichnet wird, als Standardwert 5.

• Stapelverarbeitungs-Präferenzen: Gruppieren Sie Spieler basierend auf den Regionen, in denen sie die schnellste Spieler-Latenz verzeichnen.

• Latenzregel: Legen Sie als maximal zulässige Spieler-Latenz 200 Millisekunden fest.

• Wenn das Match nicht schnell gefüllt wird, lockern Sie die Anforderung, um innerhalb einer angemessenen Zeit ein Match fertig zu stellen.

  • Akzeptieren Sie nach 15 Sekunden Teams mit 10 Spielern.

  • Akzeptieren Sie nach 20 Sekunden Teams mit 8 Spielern.

Hinweise zur Verwendung dieses Regelsatzes:

• Dieser Regelsatz definiert Teams, die potenziell bis zu 155 Spieler aufnehmen können, was es zu einem großen Match macht. (10 x 15 Spieler + 5 Monster = 155)

• Da der Algorithmus als Stapelverarbeitungs-Präferenz die „schnellste Region“ verwendet, werden Spieler verstärkt in Regionen mit schnellerer verzeichneter Latenz und nicht in Regionen mit hoher (aber akzeptabler) verzeichneter Latenz platziert. Gleichzeitig besitzen Matches wahrscheinlich weniger Spieler, und das ausgleichende Kriterium (Anzahl von Monster-Kills) kann stärker variieren.

• Wenn eine Erweiterung für eine Multi-Team-Definition (Menge >1) definiert ist, gilt die Erweiterung für alle Teams, die mit dieser Definition erstellt wurden. Von einer Lockerung der minimalen Einstellung der Spieler im Jäger-Team sind alle zehn Jäger Teams gleichermaßen betroffen.

• Da dieser Regelsatz zum Minimieren der Spieler-Latenz optimiert ist, fungiert die Latenz-Regel als Catch-all-Methode zum Ausschließen von Spielern ohne akzeptable Verbindungsoptionen. Wir müssen diese Anforderung nicht lockern.

• So FlexMatch füllt Übereinstimmungen für diesen Regelsatz aus, bevor Erweiterungen wirksam werden:

  • Keines der Teams hat die minPlayers-Anzahl erreicht. Jäger-Teams besitzen über 15 verfügbare Spielerplätze, während das Monster-Team 5 verfügbare Spielerplätze hat.

    • Die ersten 100 Spieler werden (jeweils 10) den zehn Jäger-Teams zugewiesen.

    • Die nächsten 22 Spielern werden sequenziell (jeweils 2) den Jäger-Teams und dem Moster-Team zugewiesen.

  • Jäger-Teams haben die minPlayers-Anzahl von jeweils 12 Spielern erreicht. Das Monster-Team besitzt 2 Spieler und hat die minPlayers-Anzahl noch nicht erreicht.

    • Die nächsten drei Spieler werden dem Monster-Team zugewiesen.

  • Alle Teams haben die minPlayers-Anzahl erreicht. Jäger-Teams besitzen jeweils drei verfügbare Spielerplätze. Das Monster-Team ist voll.

    • Die letzten 30 Spieler werden sequenziell den Jäger-Teams zugewiesen. Dadurch wird sichergestellt, dass alle Jäger-Teams in etwa (plus oder minus einem Spieler) die gleiche Größe aufweisen.

• Wenn Sie Backfill für die mit diesem Regelsatz erstellten Matches aktiviert haben, lockern Sie die erforderliche Spieleranzahl nicht zu schnell. Andernfalls erhalten Sie zu viele nur teilweise gefüllte Spielsitzungen. Weitere Informationen finden Sie unter Relaxen Sie große Spielanforderungen.

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

Beispiel 9: Erstellen eines großen Matches mit Spielern mit ähnlichen Attributen

Dieses Beispiel veranschaulicht, wie Sie mithilfe von einen Regelsatz für Matches mit zwei Teams einrichtenbatchDistance. Im Beispiel:

• Die SimilarLeague Regel stellt sicher, dass alle Spieler in einem Spiel league innerhalb von 2 anderen Spielern ein haben.

• Die SimilarSkill Regel stellt sicher, dass alle Spieler in einem Spiel skill innerhalb von 10 anderen Spielern ein haben. Wenn ein Spieler 10 Sekunden gewartet hat, wird die Entfernung auf 20 erweitert. Wenn ein Spieler 20 Sekunden gewartet hat, wird die Entfernung auf 40 erweitert.

• Die SameMap Regel stellt sicher, dass alle Spieler in einem Spiel denselben angefordert habenmap.

• Die SameMode Regel stellt sicher, dass alle Spieler in einem Spiel denselben angefordert habenmode.

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

Beispiel 10: Verwenden Sie eine zusammengesetzte Regel, um ein Match mit Spielern mit ähnlichen Attributen oder ähnlichen Auswahlen zu erstellen

Dieses Beispiel veranschaulicht, wie Sie mithilfe von einen Regelsatz für Matches mit zwei Teams einrichtencompound. Im Beispiel:

• Die SimilarLeagueDistance Regel stellt sicher, dass alle Spieler in einem Spiel league innerhalb von 2 anderen Spielern ein haben.

• Die SimilarSkillDistance Regel stellt sicher, dass alle Spieler in einem Spiel skill innerhalb von 10 anderen Spielern ein haben. Wenn ein Spieler 10 Sekunden gewartet hat, wird die Entfernung auf 20 erweitert. Wenn ein Spieler 20 Sekunden gewartet hat, wird die Entfernung auf 40 erweitert.

• Die SameMapComparison Regel stellt sicher, dass alle Spieler in einem Spiel denselben angefordert habenmap.

• Die SameModeComparison Regel stellt sicher, dass alle Spieler in einem Spiel denselben angefordert habenmode.

• Die CompoundRuleMatchmaker Regel stellt eine Übereinstimmung sicher, wenn mindestens eine der folgenden Bedingungen erfüllt ist:

  • Spieler in einem Match haben dieselbe map und dieselbe angefordertmode.

  • Spieler in einer Übereinstimmung haben vergleichbare - skill und -leagueAttribute.

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

Beispiel 11: Erstellen einer Regel, die die Blockliste eines Spielers verwendet

Dieses Beispiel zeigt einen Regelsatz, mit dem Spieler vermeiden können, mit bestimmten anderen Spielern abgeglichen zu werden. Spieler können eine Blockliste erstellen, die der Matchmaker bei der Spielerauswahl für ein Match auswertet. Weitere Hinweise zum Hinzufügen einer Blockliste oder zum Vermeiden einer Listenfunktion finden Sie unter AWS für Games Blog.

In diesem Beispiel werden die folgenden Anweisungen beschrieben:

• Erstellen Sie zwei Teams mit genau fünf Spielern.

• Übergeben Sie die Blockierliste eines Spielers, bei der es sich um eine Liste von Spieler-IDs (bis zu 100) handelt.

• Vergleichen Sie alle Spieler mit der Blockliste jedes Spielers und lehnen Sie ein vorgeschlagenes Match ab, wenn blockierte Spieler-IDs gefunden werden.

Hinweise zur Verwendung dieses Regelsatzes:

• Wenn Sie einen neuen Spieler auswerten, um ihn zu einem vorgeschlagenen Match hinzuzufügen (oder einen Spot in einem vorhandenen Match aufzufüllen), kann der Spieler aus einem der folgenden Gründe abgelehnt werden:

  • Wenn sich der neue Spieler auf einer Blockliste für Spieler befindet, die bereits für das Spiel ausgewählt sind.

  • Wenn Spieler, die bereits für das Spiel ausgewählt sind, auf der Blockierliste des neuen Spielers stehen.

• Wie gezeigt, verhindert dieser Regelsatz, dass ein Spieler mit einem Spieler auf seiner Blockliste übereinstimmt. Sie können diese Anforderung in eine Präferenz ändern (auch als „Vermeidungs“-Liste bezeichnet), indem Sie eine Regelerweiterung hinzufügen und den maxCount Wert erhöhen.

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