a
This commit is contained in:
@@ -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',
|
||||
]
|
||||
@@ -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
|
||||
@@ -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()
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user