@playcraft/skills 0.0.2

package/skills/match_engine.aicomponent/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: match_engine.aicomponent
+description: 通用篮子匹配引擎。纯函数实现，无 Phaser 依赖。提供同类聚合插入、N消检测、移除、满溢判断。通过 groupKey 回调函数确定匹配分组，支持单维度（颜色）和多维度（颜色×形状）匹配。
+triggers: 需要篮子匹配逻辑、三消检测、同类聚合插入时触发。
+---
+
+# 通用篮子匹配引擎（Match Engine）
+
+## 说明
+
+纯逻辑组件，**零 Phaser 依赖**，可独立单元测试。提供篮子中物品的核心操作：
+
+- **同类聚合插入**：新物品插到最后一个同类物品旁边（非追加末尾）
+- **N 消检测**：检查是否有 N 个同类物品，返回匹配列表
+- **移除**：从篮子中删除匹配物品
+- **满溢判断**：当前数量是否达到容量上限
+
+## Scaffold
+
+| 目标路径 | 来源 | 说明 |
+|---------|-----|------|
+| `src/game/logic/MatchEngine.ts` | `ref/MatchEngine.ts` | 匹配引擎 |
+
+## Recipe
+
+| 决策 | 原因 |
+|------|------|
+| **纯函数 + 零依赖** | 匹配逻辑不依赖 Phaser 或 DOM，可在 Node.js 中单元测试；同一套 MatchEngine 可以在 Phaser 和 Three.js 渲染后端复用 |
+| **静态方法类** | MatchEngine 是无状态算法集合，不需要实例化；静态方法调用更简洁，不需要传递 this |
+| **groupKey 回调** | 分组依据（颜色 / 颜色+形状）由调用方决定，MatchEngine 不绑定具体字段；泛化设计支持多维度匹配扩展 |
+| **同类聚合插入** | 新物品插到最后一个同类旁边（非追加末尾），符合三消类游戏标准交互模式，视觉反馈更直观 |
+
+## Adapter
+
+- **Role**: `matchEngine` — 通用篮子同类聚合匹配引擎（纯逻辑，零渲染依赖）
+- **Provides**: `MatchEngine` 静态类（`insertToTray()`、`checkMatch()`、`removeFromTray()`、`isTrayFull()`），`TrayItem` 类型
+- **Requires**: 无（纯 TypeScript，零外部依赖）
+- **Consumed by**: `game_scene.aicomponent`（pick_and_match 玩法中管理篮子逻辑）、`gameplay_unit_test.aivalidator`（匹配逻辑单元测试）
+- **Integration point**: `src/game/logic/MatchEngine.ts` → `Game.ts` 在物品插入/消除时调用
+
+## Imports
+
+无（纯 TypeScript，零外部依赖）
+
+## 关键接口
+
+```typescript
+interface TrayItem {
+  id: string;
+  color: string;  // 或任意分组键
+}
+
+class MatchEngine {
+  static insertToTray(item: TrayItem, tray: TrayItem[]): { newTray: TrayItem[]; insertIndex: number };
+  static checkMatch(tray: TrayItem[], matchCount?: number): TrayItem[];
+  static removeFromTray(tray: TrayItem[], matchedIds: string[]): TrayItem[];
+  static isTrayFull(tray: TrayItem[], capacity: number): boolean;
+}
+```
+
+## 配置
+
+| 参数 | 默认 | 说明 |
+|------|------|------|
+| matchCount | 3 | 消除所需的同类数量 |
+| groupKey | `item.color` | 分组依据字段 |
+
+## 使用示例
+
+```typescript
+// 插入
+const { newTray, insertIndex } = MatchEngine.insertToTray(item, tray);
+
+// 检测匹配
+const matched = MatchEngine.checkMatch(newTray);
+if (matched.length > 0) {
+  const finalTray = MatchEngine.removeFromTray(newTray, matched.map(m => m.id));
+}
+
+// 满溢检查
+if (MatchEngine.isTrayFull(newTray, 7)) {
+  // 游戏失败
+}
+```

package/skills/match_engine.aicomponent/manifest.json

@@ -0,0 +1,23 @@
+{
+  "schemaVersion": 1,
+  "atomId": "match_engine.aicomponent",
+  "bundleType": "aicomponent",
+  "category": "logic",
+  "mode": "fixed",
+  "label": {
+    "zh": "通用篮子匹配引擎（N消检测）",
+    "en": "Generic tray match engine (N-match detection)"
+  },
+  "tags": ["logic", "match", "tray", "engine", "match-3", "grouping", "eliminate", "pure-function"],
+  "bindingRoles": ["matchEngine"],
+  "imports": [],
+  "binding": {
+    "role": "matchEngine",
+    "target": "src/game/logic/MatchEngine.ts",
+    "type": "code-module-reference"
+  },
+  "files": {
+    "skill": "SKILL.md",
+    "ref": ["ref/MatchEngine.ts"]
+  }
+}

package/skills/match_engine.aicomponent/ref/MatchEngine.ts

@@ -0,0 +1,75 @@
+import type { TrayItem, CarColor } from "./types";
+import { GameConfig } from "../GameConfig";
+
+/**
+ * 篮子匹配引擎
+ * 同类聚合插入 + 3 消检测
+ */
+export class MatchEngine {
+  /**
+   * 将物品插入篮子（同类聚合：新物品插到最后一个同色物品旁边）
+   */
+  static insertToTray(
+    item: TrayItem,
+    tray: TrayItem[],
+  ): { newTray: TrayItem[]; insertIndex: number } {
+    const newTray = [...tray];
+
+    // 寻找最后一个同色物品的位置
+    let lastSameColorIndex = -1;
+    for (let i = newTray.length - 1; i >= 0; i--) {
+      if (newTray[i].color === item.color) {
+        lastSameColorIndex = i;
+        break;
+      }
+    }
+
+    let insertIndex: number;
+    if (lastSameColorIndex >= 0) {
+      insertIndex = lastSameColorIndex + 1;
+      newTray.splice(insertIndex, 0, item);
+    } else {
+      insertIndex = newTray.length;
+      newTray.push(item);
+    }
+
+    return { newTray, insertIndex };
+  }
+
+  /**
+   * 检测篮子中是否有 3 个同色物品
+   * @returns 匹配的物品列表（空数组表示无匹配）
+   */
+  static checkMatch(tray: TrayItem[]): TrayItem[] {
+    const colorCount = new Map<CarColor, TrayItem[]>();
+
+    for (const item of tray) {
+      const list = colorCount.get(item.color) || [];
+      list.push(item);
+      colorCount.set(item.color, list);
+    }
+
+    for (const [, items] of colorCount) {
+      if (items.length >= GameConfig.MATCH_COUNT) {
+        return items.slice(0, GameConfig.MATCH_COUNT);
+      }
+    }
+
+    return [];
+  }
+
+  /**
+   * 从篮子中移除匹配的物品
+   */
+  static removeFromTray(tray: TrayItem[], matchedIds: string[]): TrayItem[] {
+    const idSet = new Set(matchedIds);
+    return tray.filter(item => !idSet.has(item.id));
+  }
+
+  /**
+   * 判断篮子是否已满
+   */
+  static isTrayFull(tray: TrayItem[], capacity: number): boolean {
+    return tray.length >= capacity;
+  }
+}

package/skills/memory_match.aigameplay/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: memory_match.aigameplay
+description: 记忆翻牌配对玩法封包 - 经典记忆游戏，翻开卡牌找到所有匹配对，以最少翻牌次数通关
+triggers: 记忆,memory,翻牌,flip,配对,match,pair,卡牌,card,寻找,find,格子,grid,消除,eliminate
+---
+
+# memory_match.aigameplay
+
+记忆翻牌配对玩法封包。实现经典记忆配对规则的 PGS JSON 和 reducer，玩家翻开卡牌寻找图案相同的一对，所有对子找到后游戏胜利，以最少翻牌次数为优化目标。
+
+## Recipe
+
+- **玩法类型**：memory_match（记忆翻牌配对）
+- **参考文件**：
+  - `ref/pgs-schema.json`：PGS (PlayCraft Gameplay Schema, 玩法定义规范) 规则骨架（entities、rules、algorithm、testCases）
+  - `ref/reducer.template.ts`：reducer 接口约束模板（`init` / `dispatch` / `getState` + 分步函数）
+- **核心规则**：
+  - `gridCols × gridRows`: 4×4（默认16张牌，8对）
+  - `maxFaceUpCount`: 2（同时最多翻开2张）
+  - `flipBackDelayMs`: 1000（两张不匹配时延迟1秒后翻回）
+  - `matchCondition`: 两张 face_up 状态的牌 pairId 相同则配对成功
+  - `winCondition`: 所有牌变为 matched 状态
+- **PGS Agent 操作流程**：
+  1. 读取 `ref/pgs-schema.json` 作为规则骨架起点
+  2. 读取 `ref/reducer.template.ts` 了解接口约束
+  3. 实现 `reducer.ts`，导出 `init(config)`、`dispatch(state, action)`、`getState(state)` 以及**全部分步函数**
+  4. 运行 `ref/pgs-schema.json` 中的所有 `testCases`，全部通过后才算完成
+  5. 更新 manifest 的 `generation.pgsVersion` 和 `result.outputFile`
+- **可 fork 变体**：
+  - 计时模式：添加 `timeLimitSeconds` 限制游戏时间
+  - 更大网格：修改 `gridCols/gridRows`，如 6×6=36张牌
+  - 三元配对：修改为每组3张相同，`maxFaceUpCount: 3`
+
+## Result
+
+- **产物文件**：`reducer.ts`
+- **格式**：TypeScript，导出 `init(config)`、`dispatch(action)`、`getState()` + 分步函数接口
+- **验证**：所有 testCases 必须通过
+
+## 渲染集成（⚠️ 场景层必读）
+
+### 设计原则：逻辑与动画分离
+
+reducer 提供两套接口：
+
+| 接口 | 适用场景 | 特点 |
+|------|---------|------|
+| `dispatch()` | 无头测试、AI 模拟、跳过动画 | 一步到位，只返回最终状态 |
+| 分步函数 | **渲染层/GameScene** | 逐步执行，返回中间过程数据 |
+
+### ⚠️ 翻牌动画必须使用分步函数驱动
+
+正确做法是**分步驱动动画链**：
+
+```ts
+// ✅ 正确做法：逐步调用分步函数，每步之间插入动画
+// Step 1: 翻开卡牌（逻辑更新）
+const newState = flipCard(state, cardId);
+await playFlipAnimation(cardId, 'face_up');  // 播放翻牌动画（旋转180°）
+
+// Step 2: 检查配对
+const matchResult = checkMatch(newState);
+if (matchResult.isMatch) {
+  // 配对成功：播放消除/高亮动画
+  await playMatchAnimation(matchResult.cardIds);
+} else if (matchResult.shouldFlipBack) {
+  // 两张牌都已翻开但不匹配：延迟后翻回
+  await delay(flipBackDelayMs);
+  const flippedState = flipBackMismatched(newState);
+  await playFlipAnimation(matchResult.cardIds, 'face_down');  // 翻回动画
+}
+
+// Step 3: 检测胜利
+if (checkWin(newState)) { showWinPanel(); }
+```
+
+### 分步函数返回值与动画映射
+
+| 分步函数 | 返回值 | 场景层动画 |
+|---------|--------|-----------|
+| `flipCard()` | `MemoryMatchState` | 对目标卡牌播放翻转 Tween（Y轴旋转180°）|
+| `checkMatch()` | `{ isMatch, cardIds, shouldFlipBack }` | 匹配→高亮动画；不匹配→等待后翻回 |
+| `flipBackMismatched()` | `MemoryMatchState` | 对两张牌播放翻回动画 |
+| `checkWin()` | `boolean` | 触发所有牌欢庆动画 + 胜利面板 |
+
+## Binding
+
+- **Binding Role**：`gameplayRule`
+- **挂载目标**：`game/gameplay/memory_match/reducer.ts`
+- **引用类型**：`gameplay-module-reference`
+- **接口契约**：`init(config)` / `dispatch(state, action)` / `getState(state)` / `flipCard(cardId)` / `checkMatch()` / `flipBackMismatched()` / `checkWin()`
+
+## Skill Definition
+
+tools:
+  - bash
+  - write
+  - read
+prompt_extension: |
+  You are implementing a memory match card gameplay module following the PGS specification.
+  Write the PGS JSON with entities (cards with id/pairId/state, board, moves_count, matched_pairs),
+  rules (flip_card, check_pair, flip_back, win_check), algorithm, and testCases
+  (at least 3: match success, mismatch, win condition).
+  Implement reducer.ts with:
+    - init/dispatch/getState (一体化接口，用于测试)
+    - flipCard/checkMatch/flipBackMismatched/checkWin (分步函数，用于渲染层动画驱动)
+  Card states: face_down → face_up → matched (or face_down on mismatch).
+  Maximum 2 cards face_up at once. If already 2 face_up, reject new flip.
+  Win: all pairs matched (all cards in 'matched' state).
+  Run all testCases to verify logic before finalizing.
+  Apply the Binding to wire the reducer into the game's gameplay module path.

package/skills/memory_match.aigameplay/manifest.json

@@ -0,0 +1,164 @@
+{
+  "schemaVersion": 1,
+  "atomId": "memory_match.aigameplay",
+  "bundleType": "aigameplay",
+  "category": "gameplay",
+  "mode": "fixed",
+  "label": {
+    "zh": "记忆翻牌配对玩法",
+    "en": "Memory Match Card gameplay"
+  },
+  "tags": [
+    "gameplay",
+    "memory",
+    "cards",
+    "match",
+    "casual",
+    "puzzle"
+  ],
+  "bindingRoles": [
+    "gameplayRule"
+  ],
+  "imports": [
+    {
+      "slot": "engine",
+      "pinAtomId": "phaser.aicomponent",
+      "edgeKind": "requires",
+      "bindAs": "engine"
+    },
+    {
+      "slot": "bgMusic",
+      "description": "背景循环音乐",
+      "bindAs": "bgm",
+      "required": false,
+      "edgeKind": "compatibleWith",
+      "matchBindingRoles": [
+        "bgMusic"
+      ],
+      "allowedBundleTypes": [
+        "aiaudio"
+      ],
+      "constraints": {
+        "loop": true
+      }
+    },
+    {
+      "slot": "cardFaces",
+      "description": "卡牌正面贴图集",
+      "bindAs": "cardFaces",
+      "required": false,
+      "edgeKind": "compatibleWith",
+      "matchBindingRoles": [
+        "tileTextureSet"
+      ],
+      "allowedBundleTypes": [
+        "aiimage"
+      ]
+    },
+    {
+      "slot": "background",
+      "description": "游戏背景图",
+      "bindAs": "bg",
+      "required": false,
+      "edgeKind": "compatibleWith",
+      "matchBindingRoles": [
+        "backgroundTexture"
+      ],
+      "allowedBundleTypes": [
+        "aiimage"
+      ]
+    },
+    {
+      "slot": "tutorial",
+      "description": "新手引导浮层",
+      "bindAs": "tutorial",
+      "required": false,
+      "edgeKind": "compatibleWith",
+      "matchBindingRoles": [
+        "tutorialOverlay"
+      ],
+      "allowedBundleTypes": [
+        "aicomponent"
+      ]
+    },
+    {
+      "slot": "winPanel",
+      "description": "通关反馈面板视觉",
+      "bindAs": "winPanel",
+      "required": false,
+      "edgeKind": "compatibleWith",
+      "matchBindingRoles": [
+        "successFeedbackPanel"
+      ],
+      "allowedBundleTypes": [
+        "aiimage"
+      ]
+    },
+    {
+      "slot": "losePanel",
+      "description": "失败反馈面板视觉",
+      "bindAs": "losePanel",
+      "required": false,
+      "edgeKind": "compatibleWith",
+      "matchBindingRoles": [
+        "failFeedbackPanel"
+      ],
+      "allowedBundleTypes": [
+        "aiimage"
+      ]
+    },
+    {
+      "slot": "endScreen",
+      "description": "可玩广告结算屏（含 CTA 按钮）",
+      "bindAs": "endScreen",
+      "required": false,
+      "edgeKind": "compatibleWith",
+      "matchBindingRoles": [
+        "playableEndScreenLayout"
+      ],
+      "allowedBundleTypes": [
+        "aicomponent"
+      ]
+    }
+  ],
+  "generation": {
+    "kind": "pgs",
+    "pgsVersion": "1.0",
+    "gameplayType": "memory_match",
+    "rules": {
+      "gridCols": 4,
+      "gridRows": 4,
+      "pairCount": 8,
+      "maxFaceUpCount": 2,
+      "flipBackDelayMs": 1000
+    }
+  },
+  "result": {
+    "outputFile": "reducer.ts",
+    "format": "typescript",
+    "constraints": {
+      "testCasesMustPass": true
+    }
+  },
+  "binding": {
+    "role": "gameplayRule",
+    "target": "game/gameplay/memory_match/reducer.ts",
+    "type": "gameplay-module-reference",
+    "constraints": {
+      "interface": [
+        "init(config)",
+        "dispatch(state, action)",
+        "getState(state)",
+        "flipCard(state, cardId)",
+        "checkMatch(state)",
+        "flipBackMismatched(state)",
+        "checkWin(state)"
+      ]
+    }
+  },
+  "files": {
+    "skill": "SKILL.md",
+    "pgsSchema": "ref/pgs-schema.json",
+    "reducerTemplate": "ref/reducer.template.ts"
+  }
+}

package/skills/memory_match.aigameplay/ref/pgs-schema.json

@@ -0,0 +1,190 @@
+{
+  "_comment": "PGS (PlayCraft Gameplay Schema) 参考骨架 - 记忆翻牌配对玩法。Agent 以此为起点编写或 fork 玩法规则。",
+  "version": "1.0",
+  "gameplayType": "memory_match",
+  "entities": {
+    "board": {
+      "type": "grid",
+      "cols": 4,
+      "rows": 4,
+      "description": "游戏棋盘，默认 4×4 排列 16 张牌（8对），可通过 config 覆盖"
+    },
+    "card": {
+      "type": "cell-item",
+      "description": "棋盘上的卡牌",
+      "fields": {
+        "id": "number，卡牌唯一 ID（0 ~ totalCards-1）",
+        "pairId": "number，配对组 ID，相同 pairId 的两张牌为一对",
+        "state": "'face_down'（背面朝上，初始状态）| 'face_up'（正面朝上，已翻开）| 'matched'（已配对，保持翻开）"
+      }
+    },
+    "movesCount": {
+      "type": "counter",
+      "initial": 0,
+      "description": "玩家翻牌总次数（每翻开一张 +1）"
+    },
+    "matchedPairs": {
+      "type": "counter",
+      "initial": 0,
+      "description": "已成功配对的对数"
+    },
+    "faceUpCards": {
+      "type": "list",
+      "maxLength": 2,
+      "description": "当前正面朝上（face_up 状态）的卡牌 ID 列表，最多2张"
+    }
+  },
+  "rules": {
+    "flip_card": {
+      "description": "玩家翻开一张背面朝下的牌",
+      "preconditions": [
+        "目标牌必须为 face_down 状态",
+        "当前 face_up 的牌不超过 1 张（若已有2张 face_up 未处理，则拒绝新翻牌）"
+      ],
+      "effect": "目标牌 state 变为 face_up；movesCount + 1；加入 faceUpCards 列表"
+    },
+    "check_pair": {
+      "description": "当 faceUpCards 恰好有2张时自动触发配对检测",
+      "condition": "faceUpCards[0].pairId === faceUpCards[1].pairId",
+      "onMatch": "两张牌 state 变为 matched；matchedPairs + 1；faceUpCards 清空",
+      "onMismatch": "不立即翻回，标记为 pending_flip_back，等待 flipBackDelayMs 后翻回"
+    },
+    "flip_back": {
+      "description": "两张不匹配的 face_up 牌在延迟后翻回 face_down",
+      "delayMs": 1000,
+      "effect": "两张牌 state 变回 face_down；faceUpCards 清空"
+    },
+    "win_check": {
+      "description": "每次配对成功后检测胜利条件",
+      "condition": "matchedPairs === totalPairs",
+      "result": "win=true，游戏结束"
+    }
+  },
+  "algorithm": {
+    "description": "主循环：翻牌 → 配对检测 → 翻回/胜利",
+    "steps": [
+      "1. 玩家点击一张 face_down 的牌",
+      "2. 若当前 faceUpCards 已有2张（pending flip back），拒绝操作",
+      "3. 翻开牌：state → face_up，movesCount + 1，加入 faceUpCards",
+      "4. 若 faceUpCards.length < 2，等待玩家翻第二张",
+      "5. 若 faceUpCards.length === 2，触发 check_pair",
+      "6a. 若 pairId 相同（配对成功）：两张 state → matched，matchedPairs + 1，faceUpCards 清空",
+      "6b. 若 pairId 不同（不匹配）：标记 pending，等待 flipBackDelayMs 毫秒后翻回 face_down",
+      "7. 配对成功后检测 win_check：matchedPairs === totalPairs → 胜利"
+    ]
+  },
+  "winCondition": {
+    "type": "all_pairs_matched",
+    "description": "所有牌对均已配对（matchedPairs === totalPairs，即所有卡牌均为 matched 状态）"
+  },
+  "loseCondition": {
+    "type": "none",
+    "description": "无失败条件（或可通过 config 设置 maxMoves 以步数限制为失败条件）"
+  },
+  "testCases": [
+    {
+      "id": "tc_match_success",
+      "description": "配对成功：翻开两张相同 pairId 的牌",
+      "initialState": {
+        "cards": [
+          { "id": 0, "pairId": 1, "state": "face_down" },
+          { "id": 1, "pairId": 2, "state": "face_down" },
+          { "id": 2, "pairId": 1, "state": "face_down" },
+          { "id": 3, "pairId": 2, "state": "face_down" }
+        ],
+        "movesCount": 0,
+        "matchedPairs": 0,
+        "faceUpCards": []
+      },
+      "actions": [
+        { "type": "flip_card", "cardId": 0 },
+        { "type": "flip_card", "cardId": 2 }
+      ],
+      "expectedState": {
+        "cards": [
+          { "id": 0, "state": "matched" },
+          { "id": 2, "state": "matched" }
+        ],
+        "matchedPairs": 1,
+        "movesCount": 2,
+        "faceUpCards": []
+      }
+    },
+    {
+      "id": "tc_mismatch_flip_back",
+      "description": "不匹配翻回：翻开两张 pairId 不同的牌，等待延迟后两张回到 face_down",
+      "initialState": {
+        "cards": [
+          { "id": 0, "pairId": 1, "state": "face_down" },
+          { "id": 1, "pairId": 2, "state": "face_down" },
+          { "id": 2, "pairId": 1, "state": "face_down" },
+          { "id": 3, "pairId": 2, "state": "face_down" }
+        ],
+        "movesCount": 0,
+        "matchedPairs": 0,
+        "faceUpCards": []
+      },
+      "actions": [
+        { "type": "flip_card", "cardId": 0 },
+        { "type": "flip_card", "cardId": 1 },
+        { "type": "flip_back_mismatched" }
+      ],
+      "expectedState": {
+        "cards": [
+          { "id": 0, "state": "face_down" },
+          { "id": 1, "state": "face_down" }
+        ],
+        "matchedPairs": 0,
+        "movesCount": 2,
+        "faceUpCards": []
+      }
+    },
+    {
+      "id": "tc_win_condition",
+      "description": "胜利条件：所有配对完成后 win=true",
+      "initialState": {
+        "cards": [
+          { "id": 0, "pairId": 1, "state": "face_down" },
+          { "id": 1, "pairId": 1, "state": "face_down" }
+        ],
+        "movesCount": 0,
+        "matchedPairs": 0,
+        "faceUpCards": [],
+        "totalPairs": 1
+      },
+      "actions": [
+        { "type": "flip_card", "cardId": 0 },
+        { "type": "flip_card", "cardId": 1 }
+      ],
+      "expectedState": {
+        "matchedPairs": 1,
+        "win": true,
+        "gameOver": true
+      }
+    },
+    {
+      "id": "tc_reject_flip_when_two_faceup",
+      "description": "拒绝翻牌：已有2张 face_up 未处理时，拒绝新的翻牌请求",
+      "initialState": {
+        "cards": [
+          { "id": 0, "pairId": 1, "state": "face_up" },
+          { "id": 1, "pairId": 2, "state": "face_up" },
+          { "id": 2, "pairId": 1, "state": "face_down" }
+        ],
+        "movesCount": 2,
+        "matchedPairs": 0,
+        "faceUpCards": [0, 1]
+      },
+      "actions": [
+        { "type": "flip_card", "cardId": 2 }
+      ],
+      "expectedState": {
+        "cards": [
+          { "id": 2, "state": "face_down" }
+        ],
+        "movesCount": 2,
+        "note": "翻牌请求被拒绝，状态不变"
+      }
+    }
+  ]
+}