""" 数据收集脚本 - 用于离线训练数据集构建 功能: 1. 支持多设备并发收集游戏截图 2. 截图命名格式规范，方便后续批量标注 3. 只收集截图，不调用VLM（节省时间和资源） 4. 自动重试失败的轮次 5. 记录每局游戏的元数据 """ import argparse import json import re import time from concurrent.futures import ThreadPoolExecutor, as_completed from datetime import datetime from pathlib import Path from typing import Dict, List, Optional, Tuple from adb_controller import ADBController class DataCollector: """游戏数据收集器""" def __init__(self, device_id: str, output_dir: str = "game_data_raw", debug: bool = False): self.device_id = device_id self.debug = debug # 创建输出目录（使用安全的文件名） safe_device_id = device_id.replace(":", "_").replace(".", "_") self.output_dir = Path(output_dir) / safe_device_id self.output_dir.mkdir(parents=True, exist_ok=True) # 检查已有的episode，自动续集 self.start_episode_id = self._find_next_episode_id() if self.start_episode_id > 1: print(f"[{device_id}] 检测到已有数据，从 Episode {self.start_episode_id} 继续收集") # 初始化 ADB 控制器 print(f"[{device_id}] 连接 Android 设备...") self.controller = ADBController(device_id=device_id) # 获取屏幕分辨率 self.screen_width, self.screen_height = self.controller.get_screen_resolution() print(f"[{device_id}] 屏幕分辨率: {self.screen_width}x{self.screen_height}") # 游戏元数据 self.episodes = [] def _find_next_episode_id(self) -> int: """ 查找下一个可用的episode_id（避免覆盖已有数据） Returns: 下一个episode_id（从1开始） """ existing_episodes = list(self.output_dir.glob("episode_*_metadata.json")) if not existing_episodes: return 1 # 提取所有已有的episode_id episode_ids = [] for metadata_file in existing_episodes: # 文件名格式: episode_001_metadata.json match = re.match(r"episode_(\d+)_metadata\.json", metadata_file.name) if match: episode_ids.append(int(match.group(1))) if episode_ids: return max(episode_ids) + 1 else: return 1 def calculate_card_positions(self) -> List[Tuple[int, int]]: """计算 3 个选项按钮的点击位置""" # 根据截图分析，选项按钮在屏幕约65-68%高度处 y = 860 # 调整后的坐标（720x1280屏幕，避免触发键盘） positions = [ (135, y), # 左边（选项a） (360, y), # 中间（选项b） (585, y), # 右边（选项c） ] return positions def calculate_next_button_position(self) -> Tuple[int, int]: """计算"下一轮"按钮的位置""" # 下一轮按钮在屏幕约80-82%高度处 return (360, 1040) def random_choice(self) -> int: """随机选择一个索引（0, 1, 2）""" import random return random.choice([0, 1, 2]) def capture_and_save(self, episode_id: int, round_num: int, suffix: str = "") -> Optional[str]: """ 截图并保存，使用标准化的文件名 文件名格式: episode_{ep}_round_{rd}_{suffix}.png 例如: episode_001_round_03_question.png, episode_001_round_03_result.png Args: episode_id: 局数 round_num: 轮数 suffix: 文件名后缀，如 "question" 或 "result" Returns: 保存的文件路径（相对路径），失败返回 None """ try: screenshot = self.controller.capture_screenshot() # 标准化文件名 if suffix: filename = f"episode_{episode_id:03d}_round_{round_num:02d}_{suffix}.png" else: filename = f"episode_{episode_id:03d}_round_{round_num:02d}.png" filepath = self.output_dir / filename screenshot.save(filepath) if self.debug: print(f"[{self.device_id}] 截图已保存: {filepath}") return str(filepath.relative_to(self.output_dir.parent)) except Exception as e: print(f"⚠ [{self.device_id}] 截图失败: {e}") return None def check_card_color_changed(self) -> bool: """ 简单检查：等待一下后重新截图，看是否有颜色变化 这里用简化的方法：如果点击后界面没报错，就认为成功 """ time.sleep(0.8) return True # 简化处理，假设点击总是成功 def play_one_round(self, episode_id: int, round_num: int) -> Optional[Dict]: """ 玩一轮游戏并收集数据 收集两张截图： 1. question.png - 操作前的状态（灯光+数字选项） 2. result.png - 操作后的反馈（显示正确答案） Returns: 该轮的元数据字典，失败返回 None """ print(f"[{self.device_id}] Round {round_num}/10") # 短暂延迟，避免并发时ADB冲突 time.sleep(0.3) # 1. 截图1：question（操作前状态） question_screenshot = self.capture_and_save(episode_id, round_num, "question") if question_screenshot is None: return None # 2. 随机选择一个卡片点击 selected_index = self.random_choice() if self.debug: print(f"[{self.device_id}] 随机选择索引: {selected_index}") # 3. 点击卡片 positions = self.calculate_card_positions() x, y = positions[selected_index] max_retry = 3 click_success = False for retry in range(max_retry): success = self.controller.tap(x, y, delay=1.0) if not success: if retry < max_retry - 1: print(f"⚠ [{self.device_id}] 点击失败，重试 {retry + 1}/{max_retry}") time.sleep(0.5) continue else: print(f"⚠ [{self.device_id}] 点击失败，跳过此轮") return None # 检查点击是否成功 if self.check_card_color_changed(): click_success = True break else: if retry < max_retry - 1: print(f"⚠ [{self.device_id}] 点击未生效，重试 {retry + 1}/{max_retry}") time.sleep(0.5) if not click_success: print(f"⚠ [{self.device_id}] 多次点击均未成功") return None # 4. 等待反馈显示 time.sleep(1.5) # 5. 截图2：result（操作后反馈，包含正确答案） # 增加短暂延迟避免并发冲突 time.sleep(0.2) result_screenshot = self.capture_and_save(episode_id, round_num, "result") if result_screenshot is None: print(f"⚠ [{self.device_id}] result截图失败") return None # 6. 点击"下一轮"按钮 next_x, next_y = self.calculate_next_button_position() success = self.controller.tap(next_x, next_y, delay=1.0) if not success: print(f"⚠ [{self.device_id}] 点击下一轮失败") return None # 7. 返回该轮的元数据 metadata = { "round": round_num, "question_screenshot": question_screenshot, "result_screenshot": result_screenshot, "selected_index": selected_index, "click_position": [x, y], "timestamp": datetime.now().isoformat(), } return metadata def collect_one_episode(self, episode_id: int) -> Dict: """ 收集一局游戏的数据（10轮） Returns: 该局的元数据字典 """ print(f"\n{'=' * 60}") print(f"[{self.device_id}] Episode {episode_id} 开始") print(f"{'=' * 60}\n") episode_metadata = { "episode_id": episode_id, "device_id": self.device_id, "start_time": datetime.now().isoformat(), "rounds": [], "completed_rounds": 0, "success": False, } # 收集10轮数据 completed_rounds = 0 attempt_count = 0 max_attempts = 20 # 最多尝试20次 while completed_rounds < 10 and attempt_count < max_attempts: attempt_count += 1 round_num = completed_rounds + 1 round_metadata = self.play_one_round(episode_id, round_num) if round_metadata is not None: episode_metadata["rounds"].append(round_metadata) completed_rounds += 1 print(f"✓ [{self.device_id}] Round {completed_rounds}/10 完成") # 轮次间等待 if completed_rounds < 10: time.sleep(1.0) else: print(f"⚠ [{self.device_id}] Round {round_num} 失败，重试...") time.sleep(1.5) episode_metadata["completed_rounds"] = completed_rounds episode_metadata["success"] = completed_rounds == 10 episode_metadata["end_time"] = datetime.now().isoformat() # 截取最终得分界面 time.sleep(2.0) final_screenshot_path = self.capture_and_save(episode_id, 99, "final") # 用99表示final if final_screenshot_path: episode_metadata["final_screenshot"] = final_screenshot_path # 保存该局的元数据 metadata_file = self.output_dir / f"episode_{episode_id:03d}_metadata.json" with open(metadata_file, "w", encoding="utf-8") as f: json.dump(episode_metadata, f, ensure_ascii=False, indent=2) print(f"\n{'=' * 60}") print(f"[{self.device_id}] Episode {episode_id} 完成") print(f"[{self.device_id}] 成功轮数: {completed_rounds}/10") print(f"[{self.device_id}] 元数据已保存: {metadata_file}") print(f"{'=' * 60}\n") self.episodes.append(episode_metadata) return episode_metadata def refresh_browser(self): """刷新浏览器页面，准备下一局""" print(f"[{self.device_id}] 刷新浏览器...") # 点击刷新按钮 refresh_button_x = 380 refresh_button_y = 130 self.controller.tap(refresh_button_x, refresh_button_y, delay=1.0) time.sleep(3.0) # 等待页面加载 print(f"[{self.device_id}] 浏览器已刷新") def collect_data(self, num_episodes: int) -> List[Dict]: """ 收集多局游戏数据 Args: num_episodes: 要收集的局数 Returns: 所有局的元数据列表 """ # 从续集ID开始 for i in range(num_episodes): episode_id = self.start_episode_id + i self.collect_one_episode(episode_id) # 局间刷新浏览器（最后一局不需要） if i < num_episodes - 1: self.refresh_browser() time.sleep(2.0) # 保存汇总信息 summary = { "device_id": self.device_id, "total_episodes": num_episodes, "successful_episodes": sum(1 for ep in self.episodes if ep["success"]), "total_rounds_collected": sum(ep["completed_rounds"] for ep in self.episodes), "collection_time": datetime.now().isoformat(), "output_dir": str(self.output_dir), "episodes": self.episodes, } summary_file = self.output_dir / "collection_summary.json" with open(summary_file, "w", encoding="utf-8") as f: json.dump(summary, f, ensure_ascii=False, indent=2) print(f"\n{'=' * 60}") print(f"[{self.device_id}] 数据收集完成！") print(f"[{self.device_id}] 总局数: {num_episodes}") print(f"[{self.device_id}] 成功局数: {summary['successful_episodes']}") print(f"[{self.device_id}] 总轮数: {summary['total_rounds_collected']}") print(f"[{self.device_id}] 汇总文件: {summary_file}") print(f"{'=' * 60}\n") return self.episodes def collect_from_device(device_id: str, num_episodes: int, output_dir: str, debug: bool) -> Dict: """ 从单个设备收集数据（用于并发执行） Returns: 收集汇总信息 """ try: collector = DataCollector(device_id=device_id, output_dir=output_dir, debug=debug) collector.collect_data(num_episodes) # 读取汇总文件 summary_file = collector.output_dir / "collection_summary.json" with open(summary_file, encoding="utf-8") as f: return json.load(f) except Exception as e: print(f"⚠ 设备 {device_id} 收集失败: {e}") import traceback traceback.print_exc() return {"device_id": device_id, "error": str(e), "success": False} def main(): parser = argparse.ArgumentParser(description="游戏数据收集脚本（用于离线训练）") # 设备配置 parser.add_argument( "--devices", type=str, nargs="+", required=True, help="Android 设备地址列表，如: 101.43.137.83:5555 192.168.1.100:5555", ) # 收集配置 parser.add_argument("--episodes", type=int, default=10, help="每个设备收集多少局游戏（默认10局）") parser.add_argument("--output-dir", type=str, default="game_data_raw", help="输出目录（默认 game_data_raw）") # 执行模式 parser.add_argument("--parallel", action="store_true", help="并发执行多个设备（默认顺序执行）") parser.add_argument("--max-workers", type=int, default=4, help="并发执行时的最大线程数（默认4）") parser.add_argument("--debug", action="store_true", help="开启调试模式") args = parser.parse_args() print("=" * 60) print("游戏数据收集脚本") print("=" * 60) print(f"设备数量: {len(args.devices)}") print(f"每设备局数: {args.episodes}") print(f"预计总轮数: {len(args.devices) * args.episodes * 10}") print(f"输出目录: {args.output_dir}") print(f"执行模式: {'并发' if args.parallel else '顺序'}") print("=" * 60) print() start_time = time.time() all_summaries = [] if args.parallel and len(args.devices) > 1: # 并发执行 print(f"使用 {min(args.max_workers, len(args.devices))} 个线程并发收集数据...\n") with ThreadPoolExecutor(max_workers=min(args.max_workers, len(args.devices))) as executor: # 提交所有任务 future_to_device = { executor.submit(collect_from_device, device_id, args.episodes, args.output_dir, args.debug): device_id for device_id in args.devices } # 等待完成 for future in as_completed(future_to_device): device_id = future_to_device[future] try: summary = future.result() all_summaries.append(summary) print(f"✓ 设备 {device_id} 数据收集完成") except Exception as e: print(f"⚠ 设备 {device_id} 发生异常: {e}") else: # 顺序执行 for device_id in args.devices: print(f"\n处理设备: {device_id}") print("-" * 60) summary = collect_from_device(device_id, args.episodes, args.output_dir, args.debug) all_summaries.append(summary) # 生成总汇总 elapsed_time = time.time() - start_time total_summary = { "total_devices": len(args.devices), "episodes_per_device": args.episodes, "total_episodes_collected": sum(s.get("total_episodes", 0) for s in all_summaries), "successful_episodes": sum(s.get("successful_episodes", 0) for s in all_summaries), "total_rounds_collected": sum(s.get("total_rounds_collected", 0) for s in all_summaries), "collection_time_seconds": elapsed_time, "output_dir": args.output_dir, "timestamp": datetime.now().isoformat(), "device_summaries": all_summaries, } # 保存总汇总 output_path = Path(args.output_dir) output_path.mkdir(parents=True, exist_ok=True) total_summary_file = output_path / "total_summary.json" with open(total_summary_file, "w", encoding="utf-8") as f: json.dump(total_summary, f, ensure_ascii=False, indent=2) # 打印最终结果 print("\n" + "=" * 60) print("所有数据收集完成！") print("=" * 60) print(f"总设备数: {total_summary['total_devices']}") print(f"总局数: {total_summary['total_episodes_collected']}") print(f"成功局数: {total_summary['successful_episodes']}") print(f"总轮数: {total_summary['total_rounds_collected']}") print(f"耗时: {elapsed_time:.1f} 秒 ({elapsed_time / 60:.1f} 分钟)") print(f"输出目录: {args.output_dir}") print(f"总汇总文件: {total_summary_file}") print("=" * 60) print("\n下一步: 使用标注脚本对收集的截图进行批量标注") if __name__ == "__main__": main()