v9.0 Phase2: AI扮演+录制回放+跨端一致性 - 738个测试全绿

Phase2新增:
- AIPlayerEngine: 4种策略(random/normal/boundary/explorer)自动扮演
- ActionRecorder/Replayer: 录制操作序列+倍速回放+玩家过滤+蓝本导出
- ConsistencyChecker: 跨端MD5哈希对比+文本相似度+一致性得分(0-100)
- 12个新API端点(AI扮演3+录制4+回放3+一致性2)
- 修复AI玩家error分支无限循环bug
- 统一命名: 多人协同多端协同测试
- 52个新增测试(AIPlayer13+Recorder8+Replayer7+Consistency12+其他12)

Author: zcj220

desktop/src/components/AppLayout.tsx

@@ -22,7 +22,7 @@ const navItems = [
   { to: '/running', icon: Activity, label: '测试面板' },
   { to: '/desktop-test', icon: Monitor, label: '桌面测试' },
   { to: '/miniprogram-test', icon: Smartphone, label: '小程序测试' },
-  { to: '/multiplayer-test', icon: Users, label: '多人测试' },
+  { to: '/multiplayer-test', icon: Users, label: '多端协同' },
   { to: '/history', icon: History, label: '历史记录' },
   { to: '/analytics', icon: BarChart3, label: '报告分析' },
   { to: '/dashboard', icon: User, label: '个人中心' },

desktop/src/pages/MultiPlayerTestPage.tsx

@@ -155,7 +155,7 @@ export default function MultiPlayerTestPage() {
       {/* 标题 */}
       <div className="flex items-center justify-between">
         <h1 className="text-xl font-bold text-white flex items-center gap-2">
-          <Gamepad2 className="w-5 h-5 text-amber-400" /> 多人协同测试
+          <Gamepad2 className="w-5 h-5 text-amber-400" /> 多端协同测试
         </h1>
         <div className="flex items-center gap-2">
           {status?.running && (

src/api/routes.py

@@ -1375,10 +1375,152 @@ async def run_multiplayer_blueprint(req: dict) -> dict:
         await bp.execute(_orchestrator)
         return bp.get_report()
 
-    @router.delete("/multiplayer/room", tags=["多人测试"])
+    @router.delete("/multiplayer/room", tags=["多端协同"])
     async def destroy_room() -> dict:
         """销毁房间，断开所有玩家。"""
         await _orchestrator.reset()
         return {"message": "房间已销毁"}
 
+    # ── 多端协同 Phase2（v9.0）────────────────────
+
+    from src.testing.ai_player import AIPlayerEngine, AIPlayerConfig, AIStrategy
+    from src.testing.action_recorder import ActionRecorder, ActionReplayer
+    from src.testing.consistency_checker import ConsistencyChecker
+
+    _ai_engines: dict[str, AIPlayerEngine] = {}
+    _recorder = ActionRecorder()
+    _replayer: Optional[ActionReplayer] = None
+    _checker = ConsistencyChecker()
+
+    @router.post("/multiplayer/ai/start/{player_id}", tags=["多端协同-AI"])
+    async def start_ai_player(player_id: str, req: dict = None) -> dict:
+        """启动 AI 自动扮演指定玩家。
+
+        Body: strategy(random/normal/boundary/explorer), max_actions, action_delay
+        """
+        req = req or {}
+        strategy = AIStrategy(req.get("strategy", "normal"))
+        config = AIPlayerConfig(
+            strategy=strategy,
+            max_actions=req.get("max_actions", 50),
+            action_delay=req.get("action_delay", 1.0),
+        )
+        engine = AIPlayerEngine(config)
+        _ai_engines[player_id] = engine
+
+        import asyncio
+        asyncio.create_task(engine.run_player(_orchestrator, player_id))
+        return {
+            "player_id": player_id,
+            "strategy": strategy.value,
+            "max_actions": config.max_actions,
+        }
+
+    @router.post("/multiplayer/ai/stop/{player_id}", tags=["多端协同-AI"])
+    async def stop_ai_player(player_id: str) -> dict:
+        """停止指定玩家的 AI 扮演。"""
+        engine = _ai_engines.get(player_id)
+        if engine:
+            engine.stop()
+            return {"player_id": player_id, "actions_done": engine.action_count}
+        raise HTTPException(status_code=404, detail=f"AI玩家 {player_id} 不存在")
+
+    @router.get("/multiplayer/ai/report/{player_id}", tags=["多端协同-AI"])
+    async def ai_player_report(player_id: str) -> dict:
+        """获取 AI 玩家操作报告。"""
+        engine = _ai_engines.get(player_id)
+        if engine:
+            return engine.get_report()
+        raise HTTPException(status_code=404, detail=f"AI玩家 {player_id} 不存在")
+
+    @router.post("/multiplayer/record/start", tags=["多端协同-录制"])
+    async def start_recording() -> dict:
+        """开始录制操作。"""
+        _recorder.start()
+        return {"recording": True}
+
+    @router.post("/multiplayer/record/stop", tags=["多端协同-录制"])
+    async def stop_recording() -> dict:
+        """停止录制。"""
+        _recorder.stop()
+        return {
+            "recording": False,
+            "actions": _recorder.action_count,
+            "duration": round(_recorder.duration, 2),
+        }
+
+    @router.post("/multiplayer/record/action", tags=["多端协同-录制"])
+    async def record_action(req: dict) -> dict:
+        """录制一条操作。
+
+        Body: player_id, action, params(可选)
+        """
+        if not _recorder.is_recording:
+            raise HTTPException(status_code=400, detail="未在录制状态")
+        recorded = _recorder.record(
+            player_id=req.get("player_id", ""),
+            action=req.get("action", ""),
+            params=req.get("params", {}),
+        )
+        return {"recorded": True, "offset": round(recorded.offset, 3), "total": _recorder.action_count}
+
+    @router.get("/multiplayer/record/export", tags=["多端协同-录制"])
+    async def export_recording() -> dict:
+        """导出录制为蓝本格式。"""
+        return _recorder.export_blueprint()
+
+    @router.post("/multiplayer/replay/start", tags=["多端协同-回放"])
+    async def start_replay(req: dict = None) -> dict:
+        """开始回放录制的操作。
+
+        Body: speed(倍率), player_filter(可选玩家列表)
+        """
+        nonlocal _replayer
+        req = req or {}
+        actions = _recorder.actions
+        if not actions:
+            raise HTTPException(status_code=400, detail="无录制数据")
+        _replayer = ActionReplayer(actions)
+
+        import asyncio
+        speed = req.get("speed", 1.0)
+        player_filter = req.get("player_filter")
+        asyncio.create_task(_replayer.replay(_orchestrator, speed, player_filter))
+        return {"replaying": True, "total_actions": len(actions), "speed": speed}
+
+    @router.post("/multiplayer/replay/stop", tags=["多端协同-回放"])
+    async def stop_replay() -> dict:
+        """停止回放。"""
+        if _replayer:
+            _replayer.stop()
+            return _replayer.get_status()
+        return {"replaying": False}
+
+    @router.get("/multiplayer/replay/status", tags=["多端协同-回放"])
+    async def replay_status() -> dict:
+        """获取回放进度。"""
+        if _replayer:
+            return _replayer.get_status()
+        return {"replaying": False, "total": 0, "current": 0, "progress": 0}
+
+    @router.post("/multiplayer/consistency/check", tags=["多端协同-一致性"])
+    async def consistency_check(req: dict = None) -> dict:
+        """执行跨端一致性检查。
+
+        Body: player_ids(可选, 默认全部), check_source, check_screenshot
+        """
+        req = req or {}
+        report = await _checker.check(
+            _orchestrator,
+            player_ids=req.get("player_ids"),
+            check_source=req.get("check_source", True),
+            check_screenshot=req.get("check_screenshot", True),
+        )
+        return report.to_dict()
+
+    @router.get("/multiplayer/consistency/summary", tags=["多端协同-一致性"])
+    async def consistency_summary() -> dict:
+        """获取一致性检查历史摘要。"""
+        return _checker.get_summary()
+
     return router

src/testing/action_recorder.py

@@ -0,0 +1,222 @@
+"""
+操作录制与回放引擎（v9.0 Phase2）
+
+录制多端操作序列，保存为可回放的蓝本。
+支持：实时录制、时间戳精确回放、部分回放、蓝本导出。
+"""
+
+import json
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+from loguru import logger
+
+
+@dataclass
+class RecordedAction:
+    """一条录制的操作。"""
+    player_id: str
+    action: str
+    params: dict = field(default_factory=dict)
+    timestamp: float = 0.0       # 录制时的绝对时间
+    offset: float = 0.0          # 相对于录制开始的偏移（秒）
+
+
+class ActionRecorder:
+    """操作录制器。"""
+
+    def __init__(self) -> None:
+        self._recording = False
+        self._start_time: float = 0
+        self.actions: list[RecordedAction] = []
+
+    @property
+    def is_recording(self) -> bool:
+        return self._recording
+
+    @property
+    def action_count(self) -> int:
+        return len(self.actions)
+
+    @property
+    def duration(self) -> float:
+        if not self.actions:
+            return 0
+        return self.actions[-1].offset
+
+    def start(self) -> None:
+        """开始录制。"""
+        self._recording = True
+        self._start_time = time.time()
+        self.actions.clear()
+        logger.info("录制开始")
+
+    def stop(self) -> None:
+        """停止录制。"""
+        self._recording = False
+        logger.info("录制停止 | 操作: {} | 时长: {:.1f}s", len(self.actions), self.duration)
+
+    def record(self, player_id: str, action: str, params: dict = None) -> RecordedAction:
+        """录制一条操作。"""
+        now = time.time()
+        recorded = RecordedAction(
+            player_id=player_id,
+            action=action,
+            params=params or {},
+            timestamp=now,
+            offset=now - self._start_time if self._start_time else 0,
+        )
+        self.actions.append(recorded)
+        return recorded
+
+    def export_blueprint(self) -> dict:
+        """导出为多端蓝本格式。"""
+        player_ids = list(dict.fromkeys(a.player_id for a in self.actions))
+        players = [{"id": pid, "platform": "web"} for pid in player_ids]
+
+        steps = []
+        for a in self.actions:
+            step = {"player": a.player_id, "action": a.action}
+            step.update(a.params)
+            steps.append(step)
+
+        return {
+            "mode": "multiplayer",
+            "recorded": True,
+            "duration": round(self.duration, 2),
+            "players": players,
+            "steps": steps,
+        }
+
+    def save(self, path: str) -> Path:
+        """保存蓝本到文件。"""
+        p = Path(path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(json.dumps(self.export_blueprint(), ensure_ascii=False, indent=2),
+                      encoding="utf-8")
+        logger.info("蓝本已保存: {}", path)
+        return p
+
+    @staticmethod
+    def load_recording(path: str) -> list[RecordedAction]:
+        """从文件加载录制数据。"""
+        p = Path(path)
+        if not p.exists():
+            raise FileNotFoundError(f"文件不存在: {path}")
+        data = json.loads(p.read_text(encoding="utf-8"))
+        actions = []
+        offset = 0.0
+        for step in data.get("steps", []):
+            pid = step.get("player", "")
+            action = step.get("action", "")
+            params = {k: v for k, v in step.items() if k not in ("player", "action")}
+            actions.append(RecordedAction(
+                player_id=pid, action=action, params=params, offset=offset,
+            ))
+            offset += 0.5  # 默认间隔
+        return actions
+
+
+class ActionReplayer:
+    """操作回放器。"""
+
+    def __init__(self, actions: list[RecordedAction] = None) -> None:
+        self.actions = actions or []
+        self._replaying = False
+        self._current_index = 0
+
+    @property
+    def is_replaying(self) -> bool:
+        return self._replaying
+
+    @property
+    def progress(self) -> float:
+        if not self.actions:
+            return 0
+        return self._current_index / len(self.actions)
+
+    @property
+    def current_index(self) -> int:
+        return self._current_index
+
+    async def replay(self, orchestrator: Any, speed: float = 1.0,
+                     player_filter: list[str] = None) -> list[dict]:
+        """回放录制的操作序列。
+
+        Args:
+            orchestrator: MultiPlayerOrchestrator 实例
+            speed: 回放速度倍率（2.0 = 2倍速）
+            player_filter: 只回放这些玩家的操作（None=全部）
+        """
+        self._replaying = True
+        self._current_index = 0
+        results = []
+        prev_offset = 0.0
+
+        logger.info("回放开始 | 操作: {} | 速度: {}x | 过滤: {}",
+                     len(self.actions), speed, player_filter or "全部")
+
+        for i, action in enumerate(self.actions):
+            if not self._replaying:
+                break
+
+            if player_filter and action.player_id not in player_filter:
+                continue
+
+            delay = (action.offset - prev_offset) / speed
+            if delay > 0:
+                await self._interruptible_sleep(delay)
+            if not self._replaying:
+                break
+            prev_offset = action.offset
+
+            self._current_index = i + 1
+            success = True
+            error = ""
+
+            try:
+                if action.action == "wait":
+                    await self._interruptible_sleep(action.params.get("duration", 1) / speed)
+                else:
+                    await orchestrator.execute_action(
+                        action.player_id, action.action, **action.params
+                    )
+            except Exception as e:
+                success = False
+                error = str(e)
+                logger.warning("回放操作失败 | {} | {} | {}", action.player_id, action.action, e)
+
+            results.append({
+                "index": i,
+                "player": action.player_id,
+                "action": action.action,
+                "params": action.params,
+                "success": success,
+                "error": error,
+            })
+
+        self._replaying = False
+        passed = sum(1 for r in results if r["success"])
+        logger.info("回放完成 | 执行: {} | 通过: {} | 失败: {}",
+                     len(results), passed, len(results) - passed)
+        return results
+
+    async def _interruptible_sleep(self, duration: float) -> None:
+        """可中断的 sleep。"""
+        import asyncio
+        end = time.time() + duration
+        while time.time() < end and self._replaying:
+            await asyncio.sleep(min(0.1, end - time.time()))
+
+    def stop(self) -> None:
+        self._replaying = False
+
+    def get_status(self) -> dict:
+        return {
+            "replaying": self._replaying,
+            "total": len(self.actions),
+            "current": self._current_index,
+            "progress": round(self.progress * 100, 1),
+        }