This commit is contained in:
Ubuntu
2026-07-03 16:58:28 +08:00
commit 32b43f85bd
6240 changed files with 1987678 additions and 0 deletions
+18
View File
@@ -0,0 +1,18 @@
# Net-Games Engine
# 游戏引擎核心模块
from .player import Player, HumanPlayer, AIPlayer
from .room_manager import RoomManager, Room
from .game_base import GameBase, GameState
from .ai_adapter import AIAdapter
__all__ = [
'Player',
'HumanPlayer',
'AIPlayer',
'RoomManager',
'Room',
'GameBase',
'GameState',
'AIAdapter',
]
+211
View File
@@ -0,0 +1,211 @@
"""
AIAdapter AI适配器基类
统一不同AI类型的接口
"""
from abc import ABC, abstractmethod
from typing import Dict, Any, Optional
import asyncio
import time
class AIAdapter(ABC):
"""
AI 适配器基类
所有AI实现必须继承此类
"""
def __init__(self, ai_type: str, config: Optional[Dict] = None):
self.ai_type = ai_type
self.config = config or {}
self.last_call_time: Optional[float] = None
self.total_calls = 0
self.total_latency = 0.0
@abstractmethod
async def make_decision(self, game_state: Dict[str, Any],
available_actions: list,
player_context: Dict[str, Any]) -> Dict[str, Any]:
"""
AI 做出决策
Args:
game_state: 完整游戏状态
available_actions: 可用操作列表
player_context: 玩家上下文(手牌、角色等)
Returns:
{
'action': str, # 操作类型
'data': Dict, # 操作数据
'reasoning': str, # 决策理由(可选)
'confidence': float # 置信度 0-1
}
"""
pass
@abstractmethod
def get_name(self) -> str:
"""获取AI名称"""
pass
def record_call(self, latency_ms: float):
"""记录调用统计"""
self.last_call_time = time.time()
self.total_calls += 1
self.total_latency += latency_ms
@property
def average_latency(self) -> float:
"""平均延迟"""
if self.total_calls == 0:
return 0.0
return self.total_latency / self.total_calls
def to_dict(self) -> Dict[str, Any]:
"""序列化信息"""
return {
'ai_type': self.ai_type,
'name': self.get_name(),
'total_calls': self.total_calls,
'average_latency_ms': round(self.average_latency, 2)
}
class RuleBasedAdapter(AIAdapter):
"""
基于规则的AI适配器
适合简单的决策逻辑
"""
def __init__(self, config: Optional[Dict] = None):
super().__init__('rule', config)
self.rule_engine = None # 在子类中实现
async def make_decision(self, game_state: Dict[str, Any],
available_actions: list,
player_context: Dict[str, Any]) -> Dict[str, Any]:
"""
基于规则的决策
子类需要重写具体逻辑
"""
start_time = time.time()
# 默认实现:选择第一个可用操作
result = {
'action': available_actions[0] if available_actions else 'pass',
'data': {},
'reasoning': '默认规则选择',
'confidence': 0.5
}
latency = (time.time() - start_time) * 1000
self.record_call(latency)
return result
def get_name(self) -> str:
return "规则AI"
class LLMAdapter(AIAdapter):
"""
大语言模型AI适配器
支持 DeepSeek / OpenAI 等
"""
def __init__(self, model: str = 'deepseek-chat', api_key: str = '',
api_url: str = '', config: Optional[Dict] = None):
super().__init__('llm', config)
self.model = model
self.api_key = api_key
self.api_url = api_url
self.timeout = config.get('timeout', 30) if config else 30
async def make_decision(self, game_state: Dict[str, Any],
available_actions: list,
player_context: Dict[str, Any]) -> Dict[str, Any]:
"""
调用大模型API做决策
子类需要实现具体调用逻辑
"""
start_time = time.time()
# TODO: 实现具体的API调用
# 这里先返回占位符
result = {
'action': 'pass',
'data': {},
'reasoning': '大模型响应占位符',
'confidence': 0.8
}
latency = (time.time() - start_time) * 1000
self.record_call(latency)
return result
def get_name(self) -> str:
return f"LLM({self.model})"
class MinimaxAdapter(AIAdapter):
"""
Minimax算法AI适配器
适用于象棋等完全信息博弈
"""
def __init__(self, depth: int = 3, config: Optional[Dict] = None):
super().__init__('minimax', config)
self.depth = depth
self.evaluator = None # 在子类中实现
async def make_decision(self, game_state: Dict[str, Any],
available_actions: list,
player_context: Dict[str, Any]) -> Dict[str, Any]:
"""
Minimax决策
子类需要实现具体算法
"""
start_time = time.time()
# TODO: 实现 Minimax + Alpha-Beta
result = {
'action': available_actions[0] if available_actions else 'pass',
'data': {},
'reasoning': f'Minimax depth={self.depth}',
'confidence': 0.9
}
latency = (time.time() - start_time) * 1000
self.record_call(latency)
return result
def get_name(self) -> str:
return f"Minimax(depth={self.depth})"
class AIAdapterFactory:
"""
AI适配器工厂
用于创建不同类型的AI
"""
_adapters = {
'rule': RuleBasedAdapter,
'llm': LLMAdapter,
'minimax': MinimaxAdapter,
}
@classmethod
def register(cls, ai_type: str, adapter_class: type):
"""注册新的AI类型"""
cls._adapters[ai_type] = adapter_class
@classmethod
def create(cls, ai_type: str, config: Optional[Dict] = None) -> Optional[AIAdapter]:
"""创建AI适配器"""
adapter_class = cls._adapters.get(ai_type)
if adapter_class:
return adapter_class(config)
return None
+236
View File
@@ -0,0 +1,236 @@
"""
GameBase 游戏基类
定义游戏的通用接口和状态管理
"""
from abc import ABC, abstractmethod
from typing import Dict, List, Any, Optional
from enum import Enum
import time
import json
class GamePhase(Enum):
"""游戏阶段枚举"""
WAITING = "waiting" # 等待玩家
READY = "ready" # 准备开始
STARTING = "starting" # 开始中
PLAYING = "playing" # 游戏中
PAUSED = "paused" # 暂停
ENDED = "ended" # 已结束
class GameState:
"""
游戏状态类
管理游戏的所有状态数据
"""
def __init__(self, game_type: str, room_id: str):
self.game_type = game_type
self.room_id = room_id
self.phase = GamePhase.WAITING
self.round = 0
self.turn_count = 0
self.current_turn_player_id: Optional[str] = None
self.winner_id: Optional[str] = None
self.started_at: Optional[float] = None
self.ended_at: Optional[float] = None
# 玩家状态
self.player_states: Dict[str, Dict] = {}
# 游戏特定数据
self.data: Dict[str, Any] = {}
# 历史记录
self.history: List[Dict] = []
def start(self):
"""开始游戏"""
self.phase = GamePhase.PLAYING
self.round = 1
self.started_at = time.time()
def end(self, winner_id: Optional[str] = None):
"""结束游戏"""
self.phase = GamePhase.ENDED
self.winner_id = winner_id
self.ended_at = time.time()
def next_turn(self, player_id: str):
"""切换回合"""
self.current_turn_player_id = player_id
self.turn_count += 1
def add_history(self, action: str, player_id: str, data: Dict):
"""添加历史记录"""
self.history.append({
'turn': self.turn_count,
'action': action,
'player_id': player_id,
'data': data,
'timestamp': time.time()
})
def set_player_state(self, player_id: str, state: Dict):
"""设置玩家状态"""
self.player_states[player_id] = state
def get_player_state(self, player_id: str) -> Optional[Dict]:
"""获取玩家状态"""
return self.player_states.get(player_id)
def to_dict(self, player_id: Optional[str] = None) -> Dict[str, Any]:
"""
序列化为字典
player_id: 如果提供,包含该玩家的私有信息
"""
return {
'game_type': self.game_type,
'room_id': self.room_id,
'phase': self.phase.value,
'round': self.round,
'turn_count': self.turn_count,
'current_turn': self.current_turn_player_id,
'winner': self.winner_id,
'started_at': self.started_at,
'ended_at': self.ended_at,
'player_states': self.player_states,
'data': self.data,
'history': self.history[-20:] if len(self.history) > 20 else self.history,
}
def to_json(self) -> str:
"""序列化为 JSON"""
return json.dumps(self.to_dict(), default=str)
class GameBase(ABC):
"""
游戏基类
所有具体游戏必须继承此类
"""
def __init__(self, room_id: str, game_type: str):
self.room_id = room_id
self.game_type = game_type
self.state = GameState(game_type, room_id)
self.players: Dict[str, Any] = {} # player_id -> Player
self.player_order: List[str] = [] # 玩家顺序
self.is_started = False
self.is_ended = False
@property
@abstractmethod
def min_players(self) -> int:
"""最少玩家数"""
pass
@property
@abstractmethod
def max_players(self) -> int:
"""最多玩家数"""
pass
@property
def player_count(self) -> int:
"""当前玩家数"""
return len(self.players)
def add_player(self, player):
"""添加玩家"""
if self.player_count >= self.max_players:
raise ValueError("房间已满")
self.players[player.id] = player
if player.id not in self.player_order:
self.player_order.append(player.id)
self.state.set_player_state(player.id, {
'name': player.name,
'is_ai': player.is_ai,
'seat': player.seat_number,
})
def remove_player(self, player_id: str):
"""移除玩家"""
if player_id in self.players:
del self.players[player_id]
if player_id in self.player_order:
self.player_order.remove(player_id)
@abstractmethod
def can_start(self) -> bool:
"""检查是否可以开始游戏"""
pass
@abstractmethod
def start(self):
"""开始游戏"""
pass
@abstractmethod
def handle_action(self, player_id: str, action: str, data: Dict) -> Dict:
"""
处理玩家操作
返回: {'success': bool, 'message': str, 'state_update': Dict}
"""
pass
@abstractmethod
def get_valid_actions(self, player_id: str) -> List[str]:
"""获取玩家当前可用的操作列表"""
pass
@abstractmethod
def check_winner(self) -> Optional[str]:
"""检查是否有获胜者"""
pass
def get_current_player(self) -> Optional[Any]:
"""获取当前回合玩家"""
if self.state.current_turn_player_id:
return self.players.get(self.state.current_turn_player_id)
return None
def next_player(self) -> Optional[Any]:
"""切换到下一个玩家"""
if not self.player_order:
return None
current_id = self.state.current_turn_player_id
if not current_id or current_id not in self.player_order:
next_id = self.player_order[0]
else:
current_idx = self.player_order.index(current_id)
next_idx = (current_idx + 1) % len(self.player_order)
next_id = self.player_order[next_idx]
self.state.next_turn(next_id)
return self.players.get(next_id)
def end_game(self, winner_id: Optional[str] = None):
"""结束游戏"""
self.is_ended = True
self.state.end(winner_id)
def to_dict(self) -> Dict[str, Any]:
"""序列化游戏状态"""
return {
'room_id': self.room_id,
'game_type': self.game_type,
'min_players': self.min_players,
'max_players': self.max_players,
'player_count': self.player_count,
'is_started': self.is_started,
'is_ended': self.is_ended,
'state': self.state.to_dict(),
'players': {
pid: p.to_dict() for pid, p in self.players.items()
}
}
+154
View File
@@ -0,0 +1,154 @@
"""
Player 玩家抽象基类
支持人类玩家和 AI 玩家
"""
from abc import ABC, abstractmethod
from typing import Optional, Dict, Any
from enum import Enum
import uuid
import time
class PlayerType(Enum):
HUMAN = "human"
AI = "ai"
class Player(ABC):
"""
玩家抽象基类
封装玩家的通用属性和行为
"""
def __init__(self, name: str, player_id: Optional[str] = None):
self.id = player_id or f"player_{uuid.uuid4().hex[:8]}"
self.name = name
self.type: PlayerType = PlayerType.HUMAN
# 连接状态
self.is_connected = False
self.socket_id: Optional[str] = None
self.connected_at: Optional[float] = None
# 房间状态
self.room_id: Optional[str] = None
self.seat_number: Optional[int] = None
# 游戏状态
self.is_ready = False
self.role: Optional[str] = None # landlord/farmer/red/black
# 断线托管
self.is_ai_controlled = False # 是否处于AI托管模式
self.offline_since: Optional[float] = None # 离线时间戳
self.original_ai_control = False # 记录原始状态,用于恢复
# 统计数据
self.total_games = 0
self.win_count = 0
self.score = 0
@property
@abstractmethod
def is_ai(self) -> bool:
"""是否为 AI 玩家"""
pass
def connect(self, socket_id: str):
"""玩家连接"""
self.socket_id = socket_id
self.is_connected = True
self.connected_at = time.time()
def disconnect(self):
"""玩家断开连接"""
self.socket_id = None
self.is_connected = False
self.offline_since = time.time()
def enable_ai_control(self):
"""启用AI托管"""
self.is_ai_controlled = True
def disable_ai_control(self):
"""取消AI托管,恢复人工控制"""
self.is_ai_controlled = False
self.offline_since = None
def join_room(self, room_id: str, seat: int):
"""加入房间"""
self.room_id = room_id
self.seat_number = seat
def leave_room(self):
"""离开房间"""
self.room_id = None
self.seat_number = None
self.is_ready = False
self.role = None
def set_ready(self, ready: bool = True):
"""设置准备状态"""
self.is_ready = ready
def to_dict(self, include_private: bool = False) -> Dict[str, Any]:
"""序列化为字典"""
data = {
'id': self.id,
'name': self.name,
'type': self.type.value,
'is_ai': self.is_ai,
'is_connected': self.is_connected,
'is_ai_controlled': self.is_ai_controlled,
'seat_number': self.seat_number,
'is_ready': self.is_ready,
'role': self.role,
}
if include_private:
data.update({
'room_id': self.room_id,
'socket_id': self.socket_id,
'offline_since': self.offline_since,
'total_games': self.total_games,
'win_count': self.win_count,
'score': self.score,
})
return data
def __repr__(self):
return f"<{self.__class__.__name__}(id={self.id[:8]}, name={self.name}, seat={self.seat_number})>"
class HumanPlayer(Player):
"""人类玩家"""
def __init__(self, name: str, player_id: Optional[str] = None):
super().__init__(name, player_id)
self.type = PlayerType.HUMAN
@property
def is_ai(self) -> bool:
return False
class AIPlayer(Player):
"""AI 玩家"""
def __init__(self, name: str, ai_type: str, ai_config: Optional[Dict] = None):
super().__init__(name)
self.type = PlayerType.AI
self.ai_type = ai_type # "rule", "minimax", "deepseek"
self.ai_config = ai_config or {}
self.is_connected = True # AI 始终在线
self.is_ready = True # AI 自动准备
@property
def is_ai(self) -> bool:
return True
def to_dict(self, include_private: bool = False) -> Dict[str, Any]:
data = super().to_dict(include_private)
data['ai_type'] = self.ai_type
return data
+391
View File
@@ -0,0 +1,391 @@
"""
RoomManager 房间管理器
管理所有游戏房间的生命周期
"""
import uuid
import random
import string
import time
import logging
from typing import Dict, List, Optional, Type, Any, Tuple
from threading import Lock
from .player import Player, HumanPlayer, AIPlayer
from .game_base import GameBase
logger = logging.getLogger(__name__)
class Room:
"""
房间类
封装房间的所有状态和逻辑
"""
def __init__(self, room_id: str, room_code: str, game_type: str,
max_players: int = 3, config: Optional[Dict] = None):
self.id = room_id
self.code = room_code
self.game_type = game_type
self.max_players = max_players
self.config = config or {}
self.status = 'waiting' # waiting, playing, ended, closed
self.created_at = time.time()
self.started_at: Optional[float] = None
self.ended_at: Optional[float] = None
# 玩家
self.players: Dict[str, Player] = {} # player_id -> Player
self.seats: Dict[int, Optional[str]] = {} # seat -> player_id
# 房主
self.host_id: Optional[str] = None
# 游戏实例
self.game: Optional[GameBase] = None
# 最后活动时间
self.last_activity = time.time()
@property
def player_count(self) -> int:
return len(self.players)
@property
def is_full(self) -> bool:
return self.player_count >= self.max_players
@property
def is_empty(self) -> bool:
return self.player_count == 0
@property
def all_ready(self) -> bool:
"""所有人类玩家是否已准备"""
for player in self.players.values():
if not player.is_ai and not player.is_ready:
return False
return self.player_count > 0
def get_next_seat(self) -> int:
"""获取下一个可用座位号"""
for i in range(self.max_players):
if i not in self.seats or not self.seats[i]:
return i
return -1
def add_player(self, player: Player) -> bool:
"""添加玩家到房间"""
if self.is_full:
return False
seat = self.get_next_seat()
if seat == -1:
return False
# 设置房主
if self.host_id is None:
self.host_id = player.id
player.join_room(self.id, seat)
self.players[player.id] = player
self.seats[seat] = player.id
self.last_activity = time.time()
return True
def remove_player(self, player_id: str) -> bool:
"""从房间移除玩家"""
if player_id not in self.players:
return False
player = self.players[player_id]
if player.seat_number is not None:
self.seats[player.seat_number] = None
player.leave_room()
del self.players[player_id]
# 更换房主
if self.host_id == player_id and self.players:
self.host_id = next(iter(self.players.keys()))
elif not self.players:
self.host_id = None
self.last_activity = time.time()
return True
def get_player_by_socket(self, socket_id: str) -> Optional[Player]:
"""通过 socket_id 查找玩家"""
for player in self.players.values():
if player.socket_id == socket_id:
return player
return None
def start_game(self, game_class: Type[GameBase]) -> bool:
"""开始游戏"""
if self.status != 'waiting':
return False
# 斗地主需要3人
if self.game_type == 'doudizhu' and self.player_count < 3:
return False
# TestGame 需要1人
if self.game_type == 'test_game' and self.player_count < 1:
return False
# 创建游戏实例
self.game = game_class(self.id, self.game_type)
# 添加所有玩家
for player in self.players.values():
self.game.add_player(player)
# 开始游戏
self.game.start()
self.status = 'playing'
self.started_at = time.time()
self.last_activity = time.time()
return True
def end_game(self):
"""结束游戏"""
if self.status == 'playing' and self.game:
self.game.end_game()
self.status = 'ended'
self.ended_at = time.time()
self.last_activity = time.time()
def close(self):
"""关闭房间"""
self.status = 'closed'
self.players.clear()
self.seats.clear()
def to_dict(self, include_game_state: bool = True) -> Dict[str, Any]:
"""序列化为字典"""
data = {
'id': self.id,
'code': self.code,
'game_type': self.game_type,
'status': self.status,
'max_players': self.max_players,
'player_count': self.player_count,
'host_id': self.host_id,
'created_at': self.created_at,
'players': [p.to_dict() for p in self.players.values()],
}
if include_game_state and self.game:
data['game'] = self.game.to_dict()
return data
def update_activity(self):
"""更新最后活动时间"""
self.last_activity = time.time()
class RoomManager:
"""
房间管理器
单例模式,管理所有房间
"""
_instance = None
_lock = Lock()
def __new__(cls):
if cls._instance is None:
with cls._lock:
if cls._instance is None:
cls._instance = super().__new__(cls)
cls._instance._initialized = False
return cls._instance
def __init__(self):
if self._initialized:
return
self._rooms: Dict[str, Room] = {} # room_id -> Room
self._room_codes: Dict[str, str] = {} # room_code -> room_id
self._player_rooms: Dict[str, str] = {} # player_id -> room_id
self._game_registry: Dict[str, Type[GameBase]] = {} # game_type -> GameClass
self._initialized = True
def register_game(self, game_type: str, game_class: Type[GameBase]):
"""注册游戏类型"""
self._game_registry[game_type] = game_class
def _generate_room_code(self) -> str:
"""生成6位房间号"""
while True:
code = ''.join(random.choices(string.ascii_uppercase + string.digits, k=6))
if code not in self._room_codes:
return code
def create_room(self, game_type: str, max_players: int = 3,
config: Optional[Dict] = None) -> Optional[Room]:
"""创建房间"""
if game_type not in self._game_registry:
return None
room_id = f"room_{uuid.uuid4().hex[:12]}"
room_code = self._generate_room_code()
room = Room(room_id, room_code, game_type, max_players, config)
self._rooms[room_id] = room
self._room_codes[room_code] = room_id
return room
def get_room(self, room_id: Optional[str] = None,
room_code: Optional[str] = None) -> Optional[Room]:
"""获取房间"""
if room_id:
return self._rooms.get(room_id)
if room_code:
room_id = self._room_codes.get(room_code)
if room_id:
return self._rooms.get(room_id)
return None
def get_room_by_player(self, player_id: str) -> Optional[Room]:
"""通过玩家ID获取房间"""
room_id = self._player_rooms.get(player_id)
if room_id:
return self._rooms.get(room_id)
return None
def join_room(self, room_code: str, player: Player) -> Tuple[bool, str]:
"""
玩家加入房间
返回: (success, message)
"""
room = self.get_room(room_code=room_code)
if not room:
return False, "房间不存在"
if room.status != 'waiting':
return False, "游戏已开始"
if room.is_full:
return False, "房间已满"
# 如果玩家已经在其他房间,先离开
if player.id in self._player_rooms:
old_room_id = self._player_rooms[player.id]
if old_room_id != room.id:
self.leave_room(player.id)
if room.add_player(player):
self._player_rooms[player.id] = room.id
return True, "加入成功"
return False, "加入失败"
def leave_room(self, player_id: str) -> bool:
"""玩家离开房间"""
room = self.get_room_by_player(player_id)
if not room:
return False
room.remove_player(player_id)
if player_id in self._player_rooms:
del self._player_rooms[player_id]
# 如果房间空了,延迟关闭
if room.is_empty:
room.close()
self._cleanup_room(room.id)
return True
def start_game(self, room_id: str) -> Tuple[bool, str]:
"""开始游戏"""
room = self.get_room(room_id)
if not room:
return False, "房间不存在"
game_class = self._game_registry.get(room.game_type)
if not game_class:
return False, "游戏类型未注册"
if room.start_game(game_class):
return True, "游戏开始"
return False, "无法开始游戏"
def get_all_rooms(self, game_type: Optional[str] = None,
status: Optional[str] = None) -> List[Room]:
"""获取所有房间"""
rooms = list(self._rooms.values())
if game_type:
rooms = [r for r in rooms if r.game_type == game_type]
if status:
rooms = [r for r in rooms if r.status == status]
return rooms
def _cleanup_room(self, room_id: str):
"""清理房间"""
if room_id in self._rooms:
room = self._rooms[room_id]
if room.code in self._room_codes:
del self._room_codes[room.code]
del self._rooms[room_id]
def cleanup_inactive_rooms(self, max_inactive_minutes: int = 30):
"""清理不活跃房间
清理策略:
- 所有人类玩家都断开且游戏已结束:5分钟后清理
- 所有人类玩家都断开但游戏进行中:10分钟后清理
- 有活跃玩家但长期无活动:30分钟后清理
"""
import time as _time
now = _time.time()
to_remove = []
for room_id, room in list(self._rooms.items()):
# 计算人类玩家连接状态
human_players = [p for p in room.players.values() if not p.is_ai]
all_disconnected = len(human_players) > 0 and all(not p.is_connected for p in human_players)
inactive_time = now - room.last_activity
if all_disconnected:
# 所有人类玩家都断开了
if room.status in ('ended', 'closed'):
# 游戏已结束,5分钟后清理
if inactive_time > 5 * 60:
to_remove.append(room_id)
logger.info(f"清理已结束的空房间: {room.code} (断开 {int(inactive_time//60)} 分钟)")
else:
# 游戏进行中,10分钟后清理
if inactive_time > 10 * 60:
to_remove.append(room_id)
logger.info(f"清理进行中的空房间: {room.code} (断开 {int(inactive_time//60)} 分钟)")
else:
# 有活跃玩家,使用标准超时
if inactive_time > max_inactive_minutes * 60:
to_remove.append(room_id)
logger.info(f"清理不活跃房间: {room.code} (无活动 {int(inactive_time//60)} 分钟)")
for room_id in to_remove:
self._cleanup_room(room_id)
return len(to_remove)
+154
View File
@@ -0,0 +1,154 @@
"""
TestGame 示例游戏
用于测试引擎的简单猜数字游戏
"""
import random
from typing import Dict, List, Optional, Any
from .game_base import GameBase, GamePhase
class TestGame(GameBase):
"""
猜数字游戏
用于测试引擎的简单游戏
- 系统随机生成 1-100 的数字
- 玩家轮流猜数字
- 系统提示大了/小了/对了
- 猜中者获胜
"""
def __init__(self, room_id: str, game_type: str):
super().__init__(room_id, game_type)
self.target_number: Optional[int] = None
self.min_guess = 1
self.max_guess = 100
self.guesses: Dict[str, List[int]] = {} # player_id -> guesses
@property
def min_players(self) -> int:
return 1
@property
def max_players(self) -> int:
return 4
def can_start(self) -> bool:
return self.player_count >= self.min_players
def start(self):
"""开始游戏"""
if not self.can_start():
raise ValueError("玩家不足")
# 生成目标数字
self.target_number = random.randint(self.min_guess, self.max_guess)
# 初始化玩家猜测记录
for player_id in self.players:
self.guesses[player_id] = []
# 设置第一个玩家
if self.player_order:
self.state.next_turn(self.player_order[0])
self.state.start()
self.is_started = True
# 更新游戏状态数据
self.state.data = {
'min': self.min_guess,
'max': self.max_guess,
'target': self.target_number, # 只有服务端知道
}
def handle_action(self, player_id: str, action: str, data: Dict) -> Dict[str, Any]:
"""处理玩家操作"""
# 检查是否是当前玩家回合
if self.state.current_turn_player_id != player_id:
return {
'success': False,
'message': '不是你的回合'
}
if action != 'guess':
return {
'success': False,
'message': f'无效的操作: {action}'
}
# 获取猜测的数字
guess = data.get('number')
if not isinstance(guess, int) or guess < self.min_guess or guess > self.max_guess:
return {
'success': False,
'message': f'请输入 {self.min_guess}-{self.max_guess} 之间的整数'
}
# 记录猜测
self.guesses[player_id].append(guess)
# 判断结果
if guess == self.target_number:
# 猜中了
self.state.data['last_result'] = {
'player_id': player_id,
'guess': guess,
'result': 'correct'
}
self.end_game(player_id)
return {
'success': True,
'message': f'恭喜!{guess} 是正确的数字!',
'result': 'correct',
'winner': player_id
}
elif guess < self.target_number:
result = 'too_small'
message = f'{guess} 太小了'
else:
result = 'too_large'
message = f'{guess} 太大了'
self.state.data['last_result'] = {
'player_id': player_id,
'guess': guess,
'result': result
}
# 记录历史
self.state.add_history('guess', player_id, {'guess': guess, 'result': result})
# 切换到下一个玩家
self.next_player()
return {
'success': True,
'message': message,
'result': result,
'next_turn': self.state.current_turn_player_id
}
def get_valid_actions(self, player_id: str) -> List[str]:
"""获取可用操作"""
if self.state.current_turn_player_id != player_id:
return []
return ['guess']
def check_winner(self) -> Optional[str]:
"""检查获胜者"""
return self.state.winner_id
def to_dict(self) -> Dict[str, Any]:
"""序列化游戏状态"""
data = super().to_dict()
# 添加游戏特定数据(隐藏目标数字)
client_data = dict(self.state.data)
client_data.pop('target', None) # 客户端看不到目标数字
data['state']['data'] = client_data
data['guesses'] = self.guesses
return data