本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# FlexMatch 规则语言
<a name="match-rules-reference"></a>

本节中的参考主题介绍了用于构建与 Amazon GameLift Servers FlexMatch 配合使用的对战规则的语法和语义。有关编写对战规则和规则集的详细帮助，请参阅[构建 FlexMatch 规则集](match-rulesets.md)。

**Topics**
+ [FlexMatch 规则集架构](match-ruleset-schema.md)
+ [FlexMatch 规则集属性定义](match-ruleset-property-definitions.md)
+ [FlexMatch 规则类型](match-rules-reference-ruletype.md)
+ [FlexMatch 属性表达式](match-rules-reference-property-expression.md)

# FlexMatch 规则集架构
<a name="match-ruleset-schema"></a>

FlexMatch 规则集对小对战规则和大对战规则使用标准模式。有关每个部分的详细说明，请参阅[FlexMatch 规则集属性定义](match-ruleset-property-definitions.md)。

## 小型对战的规则集架构
<a name="match-ruleset-schema-small"></a>

以下架构记录了规则集的所有可能属性和允许的值，该规则集用于建立最多 40 名玩家的对战。

```
{
    "name": "string",
    "ruleLanguageVersion": "1.0",
    "playerAttributes":[{ 
         "name": "string,
         "type": <"string", "number", "string_list", "string_number_map">,
         "default": "string"
    }],
    "algorithm": {
        "strategy": "exhaustiveSearch",
        "batchingPreference": <"random", "sorted">,
        "sortByAttributes": [ "string" ],
        "expansionAgeSelection": <"newest", "oldest">,
        "backfillPriority": <"normal", "low", "high">
    },
    "teams": [{
        "name": "string",
        "maxPlayers": number,
        "minPlayers": number,
        "quantity": integer
    }],
    "rules": [{
        "type": "distance",
        "name": "string",
        "description": "string",
        "measurements": "string",
        "referenceValue": number, 
        "maxDistance": number,
        "minDistance": number,
        "partyAggregation": <"avg", "min", "max">
        },{
        "type": "comparison",
        "name": "string",
        "description": "string",
        "measurements": "string",
        "referenceValue": number, 
        "operation": <"<", "<=", "=", "!=", ">", ">=">,
        "partyAggregation": <"avg", "min", "max">
        },{
        "type": "collection",
        "name": "string",
        "description": "string",
        "measurements": "string",
        "referenceValue": number,
        "operation": <"intersection", "contains", "reference_intersection_count">,
        "maxCount": number,
        "minCount": number,
        "partyAggregation": <"union", "intersection">
        },{
        "type": "latency",
        "name": "string",
        "description": "string",
        "maxLatency": number,
        "maxDistance": number,
        "distanceReference": number, 
        "partyAggregation": <"avg", "min", "max">
        },{
        "type": "distanceSort",
        "name": "string",
        "description": "string",
        "sortDirection": <"ascending", "descending">,
        "sortAttribute": "string", 
        "mapKey": <"minValue", "maxValue">,
        "partyAggregation": <"avg", "min", "max">
        },{
        "type": "absoluteSort",
        "name": "string",
        "description": "string",
        "sortDirection": <"ascending", "descending">,
        "sortAttribute": "string", 
        "mapKey": <"minValue", "maxValue">,
        "partyAggregation": <"avg", "min", "max">
        },{
        "type": "compound",
        "name": "string",
        "description": "string",
        "statement": "string"
        }
    }],
    "expansions": [{
        "target": "string",
        "steps": [{
            "waitTimeSeconds": number,
            "value": number
        }, {
            "waitTimeSeconds": number,
            "value": number
        }]
    }]
}
```

# 大型对战的规则集架构
<a name="match-ruleset-schema-large"></a>

以下架构记录了规则集的所有可能属性和允许的值，该规则集用于构建超过 40 名玩家的对战。如果规则集中定义的所有团队的 `maxPlayers` 值超过 40，FlexMatch 将按照大型对战指南处理使用此规则集的对战请求。

```
{
    "name": "string",
    "ruleLanguageVersion": "1.0",
    "playerAttributes":[{ 
         "name": "string,
         "type": <"string", "number", "string_list", "string_number_map">,
         "default": "string"
    }],
    "algorithm": {
        "strategy": "balanced",
        "batchingPreference": <"largestPopulation", "fastestRegion">,
        "balancedAttribute": "string",
        "expansionAgeSelection": <"newest", "oldest">,
        "backfillPriority": <"normal", "low", "high">
    },
    "teams": [{
        "name": "string",
        "maxPlayers": number,
        "minPlayers": number,
        "quantity": integer
    }],
    "rules": [{
        "name": "string",
        "type": "latency",
        "description": "string",
        "maxLatency": number,
        "partyAggregation": <"avg", "min", "max">
    }, {
        "name": "string",
        "type": "batchDistance",
        "batchAttribute": "string",
        "maxDistance": number
    }],
    "expansions": [{
        "target": "string",
        "steps": [{
            "waitTimeSeconds": number,
            "value": number
        }, {
            "waitTimeSeconds": number,
            "value": number
        }]
    }]
}
```

# FlexMatch 规则集属性定义
<a name="match-ruleset-property-definitions"></a>

本节定义了规则集架构中的每个属性。有关创建规则集的其他帮助，请参阅[构建 FlexMatch 规则集](match-rulesets.md)。

**`name`**  
规则集的描述性标签。此值与分配给Amazon GameLift Servers[MatchmakingRuleSet 资源的](https://docs.aws.amazon.com/gamelift/latest/apireference/API_MatchmakingRuleSet.html)名称无关。此值包含在描述已完成匹配的对战数据中，但任何 Amazon GameLift Servers 流程均未使用该值。  
允许的值：字符串：字符串  
必填？ 否

**`ruleLanguageVersion`**  
正在使用的 FlexMatch 属性表达式语言的版本。  
允许的值： 或   
必填？ 是

**`playerAttributes`**  
包含在对战请求中并用于对战过程的玩家数据的集合。您还可以在此处声明属性，以便将玩家数据包含在传递给游戏服务器的对战数据中，即使对战过程中未使用这些数据也是如此。  
必填？ 否    
**`name`**  
玩家属性的唯一名称，供对战构建器使用。此名称必须与对战请求中引用的玩家属性名称相匹配。  
允许的值：字符串：字符串  
必填？ 是  
**`type`**  
玩家属性值的数据类型。  
允许的值：“字符串”、“数字”、“字符串列表”、“string\$1number\$1map”  
必填？ 是  
**`default `**  
当对战请求未提供给玩家的默认值时要使用的默认值。  
允许的值：玩家属性允许的任何值。  
必填？ 否 

**`algorithm`**  
用于自定义对战过程的可选配置设置。  
必填？ 否    
**`strategy`**  
构建匹配时使用的方法。如果未设置此属性，则默认行为为“exhaustiveSearch”。  
允许的值：  
+ “exhaustiveSearch”：标准匹配方法。FlexMatch 根据一组自定义匹配规则评估池中的其他票证，从而围绕批次中最旧的票证形成匹配。此策略适用于40名或更少玩家的对战。使用此策略时，`batchingPreference` 应设置为“随机”或“已排序”。
+ “平衡” – 经过优化的方法，可快速形成大型匹配项。此策略仅适用于 41 到 200 名玩家的对战。它通过对票证池进行预排序，建立潜在的对战并将玩家分配给团队，然后使用指定的玩家属性平衡对战中的每支团队来形成对战。例如，此策略可以用来平衡一场对战中所有团队的平均技能水平。使用此策略时，`balancedAttribute` 必须将其设置，`batchingPreference` 应设置为“最大人群”或“最快区域”。此策略无法识别大多数自定义规则类型。
必填？ 是  
**`batchingPreference`**  
在对票证进行分组以进行对战之前使用的预排序方法。预先对票证池进行排序会根据特定特征将票证批量组合在一起，这往往会提高最后一场对战中玩家的统一性。  
允许的值：  
+ “随机”– 仅在 `strategy` =“EximativeSearch”时有效。不进行预排序；池中的票证是随机批量排序的。这是详尽搜索策略的默认行为。
+ “已排序”– 仅在 `strategy` =“EximativeSearch”时有效。票证池是根据中列出的玩家属性进行预先排序的。`sortbyAttributes`
+ “最大人群”– 仅在 `strategy` =“平衡”时有效。票证池是按玩家报告延迟水平可接受的区域进行预先排序的。这是默认的平衡策略的默认行为。
+ “最快区域”– 仅在 `strategy` =“平衡”时有效。票证池按玩家报告最低延迟水平的地区进行预先排序。由此产生的对战需要更长的时间才能完成，但是所有玩家的延迟往往很低。
必填？ 是  
**`balancedAttribute`**  
使用平衡策略进行大型对战时要使用的玩家属性的名称。  
允许的值：`playerAttributes` 用 `type` =“数字”声明的任何属性。  
必填？ 是的，如果 `strategy` =“平衡”。  
**`sortByAttributes`**  
在批处理之前对票证池进行预排序时要使用的玩家属性列表。此属性仅在使用详尽搜索策略进行预排序时使用。属性列表的顺序决定了排序顺序。FlexMatch 对字母和数值使用标准排序惯例。  
允许的值：中声明的任何属性`playerAttributes`。  
必填？ 是的，如果 `batchingPreference` =“已排序”。  
**`backfillPriority`**  
用于匹配回填票证的优先级排序方法。此属性确定 FlexMatch 何时批量处理回填票证。它仅在使用详尽搜索策略进行预排序时使用。如果未设置此属性，则默认行为为“正常”。  
允许的值：  
+ “正常” – 在形成匹配项时，不考虑票证的请求类型（回填或新匹配项）。
+ “高”– 票证批次按请求类型（然后按年龄）排序，FlexMatch 会先尝试匹配回填票证。
+ “低”– 票证批次按请求类型（然后按年龄）排序，FlexMatch 会先尝试匹配非回填票证。
必填？ 否  
**`expansionAgeSelection`**  
计算匹配规则扩展等待时间的方法。如果对战在一定时间后仍未完成，则扩展版用于放宽对战要求。等待时间是根据已部分填满的对战中已有票证的使用年限计算的。如果未设置此属性，则默认行为为“最新”。  
允许的值：  
+ “最新” – 扩展等待时间是根据部分完成的对战中带有最新创建时间戳的票证计算得出的。扩展触发的速度往往更慢，因为一张较新的票证可以重新启动等待时间。
+ “最旧” – 扩展等待时间是根据对战中创建时间戳最早的票据计算得出的。扩展往往会更快地触发。
必填？ 否

**`teams`**  
一场对战中团队的配置。为每支队伍提供团队名称和规模范围。规则集必须定义至少一支团队。    
**`name`**  
HSM 的唯一名称。可以在规则和扩展中提及团队名称。成功对战后，玩家将在对战数据中按队名进行分配。  
允许的值：字符串：字符串  
必填？ 是  
**`maxPlayers`**  
maxPlayers（必需） 指定可以分配给团队的玩家的最大数量。  
允许的值：数值：数字  
必填？ 是  
**`minPlayers`**  
在对战可行之前，必须分配到团队的最低玩家人数。  
允许的值：数值：数字  
必填？ 是  
**`quantity`**  
在一场对战中要创建的此类团队的数量。数量大于 1 的队伍会附加一个数字（“Red\$11”、“Red\$12” 等）。如果未设置该属性，默认值为 7。  
允许的值：数值：数字  
必填？ 否

**`rules`**  
创建一组定义如何评估玩家在对战游戏中的接受情况的规则语句。  
必填？ 否    
**`name`**  
HSM 的唯一名称。规则集中的所有规则都必须具有唯一的名称。规则名称也可在跟踪与此规则相关的活动的事件日志和指标中引用。  
允许的值：字符串：字符串  
必填？ 是  
**`description`**  
规则的文字描述。此信息可用于确定规则的用途。它不用于对战过程。  
允许的值：字符串：字符串  
必填？ 否  
**`type`**  
规则声明的类型。每种规则类型都有其他必须设置的属性。有关每种规则类型的结构和用法的更多详细信息，请参阅[FlexMatch 规则类型](match-rules-reference-ruletype.md)。  
允许的值：  
+ “absoluteSort”– 使用显式排序方法进行排序，该方法根据指定的玩家属性是否与批次中最旧的票证进行比较，对批次中的票证进行排序。
+ “集合”-评估集合中的值，例如作为集合的玩家属性或多个玩家的一组值。
+ “比较”-比较两个值。
+ “复合” – 使用规则集中其他规则的逻辑组合定义复合对战规则。仅支持玩家人数不超过 40 人的对战。
+ “距离”-测量数字值之间的距离。
+ “batchDistance”-测量属性值之间的差异并将其用于对匹配请求进行分组。
+ “distanceSort”– 使用显式排序方法进行排序，该方法根据具有数值的指定玩家属性与批次中最旧的票证的比较情况对批次中的票证进行排序。
+ “延迟” – 评估为对战请求报告的区域延迟数据。
必填？ 是

**`expansions`**  
当对战无法完成时，随着时间的推移放宽对战要求的规则。将扩展设置为一系列逐步应用的步骤，以便更容易找到匹配项。默认情况下，FlexMatch 根据添加到对战中的最新票证的年龄来计算等待时间。您可以使用算法属性更改扩展等待时间的计算方式`expansionAgeSelection`。  
扩展等待时间是绝对值，因此每个步骤的等待时间应比上一步长。例如，要安排一系列逐步扩展，可以使用 30 秒、40 秒和 50 秒的等待时间。等待时间不能超过匹配请求允许的最长时间，该时间在对战配置中设置。  
必填？ 否    
**`target`**  
要放松的规则集元素。您可以放宽团队规模属性或任何规则语句属性。语法是 "<component name>[<rule/team name>]。 <property name>”。例如，要更改团队的最小规模：`teams[Red, Yellow].minPlayers`。在名为“minSkill”的比较规则语句中更改最低技能要求:`rules[minSkill].referenceValue`.  
必填？ 是  
**`steps`**    
**`waitTimeSeconds`**  
在为目标规则集元素应用新值之前等待的时间长度，以秒为单位。  
必填？ 是  
**`value`**  
目标规则集元素的新值。

# FlexMatch 规则类型
<a name="match-rules-reference-ruletype"></a>

## Batch 距离规则
<a name="match-rules-reference-ruletype-batchdistance"></a>

```
batchDistance
```

Batch 距离规则用于测量两个属性值之间的差异。您可以将批量距离规则类型用于大小匹配项。有两种类型的批量距离规则：
+ *比较数值属性值*。例如，某项距离规则可能要求所有玩家必须在相邻的两个级别内。对于这种类型，请定义所有票证之间的最`batchAttribute`大距离。
+ *比较字符串属性值*。例如，这种类型的批量距离规则可能要求一场对战中的所有玩家都请求相同的游戏模式。对于此类型，请定义 FlexMatch 用于形成批次的 `batchAttribute` 值。

**距离规则属性**
+ **`batchAttribute`**– 用于形成批次的玩家属性值。
+ **`maxDistance`**– 成功匹配的最大距离值。用于比较数值属性。
+ **`partyAggregation`** – 该值决定 FlexMatch 如何处理多名玩家（多方）的票证。有效的选项包括票证玩家的最小值（`min`）、最大值（`max`）和平均（`avg`）值。默认值为 `avg`。

**Example**  
示例  

```
{
  "name":"SimilarSkillRatings",
  "description":"All players must have similar skill ratings",
  "type":"batchDistance",
  "batchAttribute":"SkillRating",
  "maxDistance":"500"
}
```

```
{
  "name":"SameGameMode",
  "description":"All players must have the same game mode",
  "type":"batchDistance",
  "batchAttribute":"GameMode"
}
```

## 比较规则 ()
<a name="match-rules-reference-ruletype-comparison"></a>

```
comparison
```

比较规则将一个玩家属性值与另一个值进行比较。有两种类型的比较规则。
+ 与@@ *参考值进行比较*。例如，这种类型的比较规则可能要求匹配的玩家具有一定的技能等级或更高。对于此类型，请指定玩家属性、参考值和比较操作。
+ *比较不同玩家*。例如，这种类型的比较规则可能要求对战中的所有玩家使用不同的角色。对于这种类型，请指定玩家属性以及等于（`=`）或不等于（`!=`）的比较操作。不要指定参考值。

**注意**  
Batch 距离规则可以更有效地比较玩家属性。为了减少对战延迟，请尽可能使用批量距离规则。

**比较规则属性**
+  要比较的玩家属性值。
+ **`referenceValue`**– 与预期匹配的测量值进行比较的值。
+ **`operation`**– 决定如何将测量值与参考值进行比较的值。有效操作包括：。
+ **`partyAggregation`** – 该值决定 FlexMatch 如何处理多名玩家（多方）的票证。有效的选项包括票证玩家的最小值（`min`）、最大值（`max`）和平均（`avg`）值。默认值为 `avg`。

## 距离规则 ()
<a name="match-rules-reference-ruletype-distance"></a>

```
distance
```

距离规则用于度量两个数字值之间的差值，例如技能级别之间的差距。例如，距离规则可能要求所有玩家玩游戏至少 30 小时。

**注意**  
Batch 距离规则可以更有效地比较玩家属性。为了减少对战延迟，请尽可能使用批量距离规则。

**距离规则属性**
+ **`measurements`**– 要测量距离的玩家属性值。这必须是带有数值的属性。
+ **`referenceValue`** &endash; 用于对照潜在对战游戏度量距离的数字值。
+ / 为了成功进行对战游戏而允许的最大或最小距离值。
+ **`partyAggregation`** – 该值决定 FlexMatch 如何处理多名玩家（多方）的票证。有效的选项包括票证玩家的最小值（`min`）、最大值（`max`）和平均（`avg`）值。默认值为 `avg`。

## 收集规则 ()
<a name="match-rules-reference-ruletype-collection"></a>

```
collection
```

收集规则将一组玩家属性值与批次中其他玩家的属性值或参考值进行比较。一个集合可以包含多个玩家的属性值和/或采用集合格式 (字符串列表) 的一个玩家属性。例如，收集规则可能会考虑队伍中玩家选择的角色。然后，该规则可能会要求队伍至少拥有某个角色中的一个。

**收集规则属性**
+ **`measurements`**– 要比较的玩家属性值的集合。属性值必须采用字符串列表形式。
+  值或值集合，用于对照潜在对战游戏评估测量值。
+ **`operation`**– 决定如何比较一组测量值的值。有效选项包含以下内容：
  + `intersection`– 此操作用于衡量所有玩家收藏中相同值的数量。有关使用交叉操作的规则的示例，请参见[示例：使用显式排序以查找最佳对战游戏](match-examples-4.md)。
  + `contains` 计量包含特定参考值的玩家属性集合的数量。有关使用“包含”操作的规则的示例，请参见[示例：设置团队级要求和延迟限制](match-examples-3.md)。
  + `reference_intersection_count`– 此操作测量玩家属性集合中与参考值集合中的物品相匹配的物品数量。您可以使用此操作来比较多个不同的玩家属性。有关比较多个玩家属性集合的规则示例，请参阅[示例：在多个玩家属性之间查找交集](match-examples-5.md)。
+ / 为了成功进行对战游戏而允许的最大或最小计数值。
+ **`partyAggregation`** – 该值决定 FlexMatch 如何处理多名玩家（多方）的票证。对于此值，您可以使用`union`合并队伍中所有玩家的玩家属性。或者，您可以`intersection`使用队伍的共同玩家属性。默认值为 `union`。

## 复合规则
<a name="match-rules-reference-ruletype-compound"></a>

```
compound
```

复合规则使用逻辑语句来形成40名或更少玩家的对战。可以在单个规则集中使用多个复合规则。使用多个复合规则时，所有复合规则都必须为 true 才能形成匹配项。

您不能使用扩展规则[扩展复合规则](match-rulesets-components-algorithm.md#match-rulesets-components-algorithm-expansion)，但可以扩展基础规则或支持规则。

**复合规则属性**
+ **`statement`**– 用于组合单个规则以形成复合规则的逻辑。您在此属性中指定的规则必须是在规则集的早期定义的。不能在复合`batchDistance`规则中使用规则。

  此属性支持以下逻辑运算符：
  + `and`– 如果提供的两个参数均为真，则表达式为真。
  + `or`– 如果提供的两个参数中的任何一个为真，则表达式为真。
  + `not`– 反转表达式中参数的结果。
  + `xor`– 如果只有一个参数为真，则表达式为真。

**Example 示例**  
以下示例根据玩家选择的游戏模式匹配不同技能等级的玩家。  

```
{
    "name": "CompoundRuleExample",
    "type": "compound",
    "statement": "or(and(SeriousPlayers, VeryCloseSkill), and(CasualPlayers, SomewhatCloseSkill))"
}
```

## 延迟规则
<a name="match-rules-reference-ruletype-latency"></a>

```
latency
```

延迟规则衡量每个位置的玩家延迟。延迟规则会忽略任何延迟时间高于最大值的位置。玩家在至少一个位置的延迟值必须低于最大值，延迟规则才能接受。通过指定`maxLatency`属性，您可以将此规则类型用于大型匹配项。

**延迟规则属性**
+ **`maxLatency`**-某个位置的最大可接受延迟值。如果工单没有延迟低于最大值的位置，则该票证不符合延迟规则。
+ **`maxDistance`**– 每张票证的延迟时间与距离参考值之间的最大值。
+ **`distanceReference`**– 用于比较工单延迟的延迟值。距离参考值的最大距离之内的票证将成功匹配。有效选项为玩家延迟的最小值（`min`）或平均值（`avg`）。
+ **`partyAggregation`** – 该值决定 FlexMatch 如何处理多名玩家（多方）的票证。有效的选项包括票证玩家的最小值（`min`）、最大值（`max`）和平均（`avg`）值。默认值为 `avg`。

**注意**  
队列可以将游戏会话放置在与延迟规则不匹配的区域。有关队列延迟策略的更多信息，请参阅[创建玩家延迟策略](https://docs.aws.amazon.com/gameliftservers/latest/developerguide/queues-design.html#queues-design-latency)。

## 绝对排序规则 ()
<a name="match-rules-reference-ruletype-absolute"></a>

```
absoluteSort
```

绝对排序规则根据指定的玩家属性对一批对战票证进行排序，与添加到该批次的第一张票据进行比较。

**绝对排序规则属性**
+ **`sortDirection`** – 对对战票证进行排序的顺序。有效选项包括：
+ **`sortAttribute`**– 用于对票证进行排序的玩家属性。
+ **`mapKey`**– 如果是地图，则用于对玩家属性进行排序的选项。有效选项包括：
  + `minValue`– 值最低的密钥是第一个。
  + `maxValue`– 值最高的密钥是第一个。
+ **`partyAggregation`** – 该值决定 FlexMatch 如何处理多名玩家（多方）的票证。有效的选项包括最小值（`min`）玩家属性、最大值（`max`）玩家属性以及队伍中玩家所有玩家属性的平均值（`avg`）。默认值为 `avg`。

**Example**  
示例  
以下示例规则按技能等级对玩家进行排序，并对队伍的技能水平进行平均值。  

```
{
    "name":"AbsoluteSortExample",
    "type":"absoluteSort",
    "sortDirection":"ascending",
    "sortAttribute":"skill",
    "partyAggregation":"avg"
}
```

## 距离排序规则 ()
<a name="match-rules-reference-ruletype-distancesort"></a>

```
distanceSort
```

距离排序规则根据指定玩家属性与添加到该批次的第一张票据之间的距离对一批对战票证进行排序。

**距离排序规则属性**
+ **`sortDirection`** – 对对战票证进行排序的方向。有效选项包括：
+ **`sortAttribute`**– 用于对票证进行排序的玩家属性。
+ **`mapKey`**– 如果是地图，则用于对玩家属性进行排序的选项。有效选项包括：
  + `minValue`– 对于添加到批次中的第一张票证，请找到值最低的密钥。
  + `maxValue`– 对于添加到批次中的第一张票证，请找到值最高的密钥。
+ **`partyAggregation`** – 该值决定 FlexMatch 如何处理多名玩家（多方）的票证。有效的选项包括票证玩家的最小值（`min`）、最大值（`max`）和平均（`avg`）值。默认值为 `avg`。

# FlexMatch 属性表达式
<a name="match-rules-reference-property-expression"></a>

属性表达式在规则集中用于引用与对战有关的某些属性。它们允许您在定义属性值时使用计算和逻辑。属性表达式通常采用以下两种形式之一：
+ 单个玩家数据
+ 计算出的个人玩家数据集合。

## 常见的对战属性表达式
<a name="match-rules-reference-property-expression-common"></a>

有效属性表达式标识单个玩家、团队或对战游戏的特定值。以下部分表达式说明了如何标识团队和玩家：


| Goal | Input | 含义 | Output | 
| --- | --- | --- | --- | 
| 标识对战游戏的特定团队： | teams[red] | 红队 | Team  | 
| 标识对战游戏的特定团队： | teams[red,blue] | 红队和蓝队 | List<Team> | 
| 标识对战游戏的所有团队： | teams[\$1] | 所有团队 | List<Team> | 
| 标识特定团队中的玩家： | team[red].players | 红队中的玩家  | List<Player> | 
| 标识特定团队中的玩家： | team[red,blue].players | 对战游戏的玩家 (按团队分组) | List<List<Player>> | 
| 标识对战游戏的玩家： | team[\$1].players | 对战游戏的玩家 (按团队分组) | List<List<Player>> | 

## 属性表达式示例
<a name="match-rules-reference-property-expression-examples"></a>

下表给出基于之前示例构建的部分有效属性表达式：


****  

| Expression | 含义 | 结果类型 | 
| --- | --- | --- | 
|  `teams[red].players[playerId]`  | 红 IDs 队所有球员中的球员 | List<string> | 
| teams[red].players.attributes[skill] | 红队所有玩家的“技能”属性 | List<number> | 
| teams[red,blue].players.attributes[skill] | 红队和蓝队所有玩家的“技能”属性，按队伍分组 | List<List<number>> | 
| teams[\$1].players.attributes[skill] | 对战游戏的所有玩家的“技能”属性 (按团队分组) | List<List<number>> | 

## 属性表达式聚合
<a name="match-rules-reference-property-expression-aggregation"></a>

属性表达式可用于使用以下函数或组合函数来聚合团队数据：


****  

| 聚合 | Input | 含义 | Output | 
| --- | --- | --- | --- | 
| min | List<number> | 获取列表中所有数字的最小值。 | 数字 | 
| max | List<number> | 获取列表中所有数字的最大值。 | 数字 | 
| avg | List<number> | 获取列表中所有数字的平均值。 | 数字 | 
| median | List<number> | 获取列表中所有数字的中值。 | 数字 | 
| sum | List<number> | 获取列表中所有数字的总和。 | 数字 | 
| count | List<?> | 获取列表中的元素数量。 | 数字 | 
| stddev | List<number> | 获取列表中所有数字的标准差。 | 数字 | 
| flatten | List<List<?>> | 将嵌套列表的集合变成包含所有元素的单个列表。 | List<?> | 
| set\$1intersection | List<List<string>> | 获取在集合的所有字符串列表中找到的字符串列表。 | List<string> | 
| 以上全部 | List<List<?>> | 对嵌套列表的所有操作会对每个子列表执行一次以生成结果列表。 | List<?> | 

下表给出使用聚合函数的部分有效属性表达式：


****  

| Expression | 含义 | 结果类型 | 
| --- | --- | --- | 
| flatten(teams[\$1].players.attributes[skill]) | 对战游戏中的所有玩家的“技能”属性 (未分组) | List<number> | 
| avg(teams[red].players.attributes[skill]) | 红队玩家的平均技能 | 数字 | 
| avg(teams[\$1].players.attributes[skill] | 对战游戏中的每个团队的平均技能 | List<number> | 
| avg(flatten(teams[\$1].players.attributes[skill])) | 对战游戏中的所有玩家的平均技能级别。该表达式获取玩家技能的展开列表，然后计算它们的平均值。 | 数字 | 
| count(teams[red].players) | 红队的玩家数量 | 数字 | 
| count (teams[\$1].players) | 对战游戏中的每个团队的玩家数量 | List<number> | 
| max(avg(teams[\$1].players.attributes[skill])) | 对战游戏中的最高团队技能级别  | 数字 |