""" 事件处理器模块 处理匹配相关的事件 """ import time import threading import queue from typing import Dict, Any, List, Optional, Callable class EventHandler: """ 事件处理器 处理匹配相关的事件 """ def __init__(self, plugin): """ 初始化事件处理器 Args: plugin: 匹配系统插件实例 """ self.plugin = plugin self.enabled = False self.initialized = False # 事件配置 self.event_config = { "enable_event_system": True, "max_event_queue_size": 10000, "enable_event_filtering": True, "event_processing_interval": 0.01, # 10ms "enable_async_processing": True, "max_concurrent_events": 100, "enable_event_prioritization": True } # 事件状态 self.event_state = { "is_processing": False, "pending_events": 0, "processed_events": 0, "dropped_events": 0, "last_event_time": 0.0 } # 事件队列 self.event_queue = queue.Queue(maxsize=self.event_config["max_event_queue_size"]) # 事件处理器存储 self.event_handlers = {} # 事件统计 self.event_stats = { "events_received": 0, "events_processed": 0, "events_dropped": 0, "handler_errors": 0, "async_events": 0 } # 事件过滤器 self.event_filters = {} # 回调函数 self.event_callbacks = { "event_received": [], "event_processed": [], "event_dropped": [], "event_error": [] } # 事件处理线程 self.event_thread = None self.event_thread_running = False # 时间戳记录 self.last_event_process = 0.0 self.last_stats_reset = 0.0 print("✓ 事件处理器已创建") def initialize(self) -> bool: """ 初始化事件处理器 Returns: 是否初始化成功 """ try: print("正在初始化事件处理器...") # 注册默认事件处理器 self._register_default_handlers() # 启动事件处理线程 self._start_event_thread() self.initialized = True print("✓ 事件处理器初始化完成") return True except Exception as e: print(f"✗ 事件处理器初始化失败: {e}") self.event_stats["handler_errors"] += 1 import traceback traceback.print_exc() return False def _register_default_handlers(self): """注册默认事件处理器""" try: # 注册系统事件处理器 self.register_event_handler("player_queued", self._handle_player_queued) self.register_event_handler("player_dequeued", self._handle_player_dequeued) self.register_event_handler("match_found", self._handle_match_found) self.register_event_handler("match_completed", self._handle_match_completed) self.register_event_handler("match_cancelled", self._handle_match_cancelled) self.register_event_handler("queue_timeout", self._handle_queue_timeout) print("✓ 默认事件处理器已注册") except Exception as e: print(f"✗ 默认事件处理器注册失败: {e}") self.event_stats["handler_errors"] += 1 def _start_event_thread(self): """启动事件处理线程""" try: self.event_thread_running = True self.event_thread = threading.Thread(target=self._event_loop, daemon=True) self.event_thread.start() print("✓ 事件处理线程已启动") except Exception as e: print(f"✗ 事件处理线程启动失败: {e}") self.event_stats["handler_errors"] += 1 def _event_loop(self): """事件处理循环""" try: while self.event_thread_running: try: if self.enabled and self.event_config["enable_event_system"]: # 处理事件队列 self._process_event_queue() # 短暂休眠 time.sleep(self.event_config["event_processing_interval"]) except Exception as e: print(f"✗ 事件处理循环错误: {e}") self.event_stats["handler_errors"] += 1 time.sleep(1.0) # 出错时延长休眠 except Exception as e: print(f"✗ 事件处理线程失败: {e}") self.event_stats["handler_errors"] += 1 def enable(self) -> bool: """ 启用事件处理器 Returns: 是否启用成功 """ try: if not self.initialized: print("✗ 事件处理器未初始化") return False self.enabled = True print("✓ 事件处理器已启用") return True except Exception as e: print(f"✗ 事件处理器启用失败: {e}") self.event_stats["handler_errors"] += 1 import traceback traceback.print_exc() return False def disable(self): """禁用事件处理器""" try: self.enabled = False # 停止事件处理线程 if self.event_thread_running: self.event_thread_running = False if self.event_thread and self.event_thread.is_alive(): self.event_thread.join(timeout=5.0) print("✓ 事件处理器已禁用") except Exception as e: print(f"✗ 事件处理器禁用失败: {e}") self.event_stats["handler_errors"] += 1 import traceback traceback.print_exc() def finalize(self): """清理事件处理器资源""" try: # 禁用事件处理器 if self.enabled: self.disable() # 清理回调和处理器 self.event_callbacks.clear() self.event_handlers.clear() self.event_filters.clear() self.initialized = False print("✓ 事件处理器资源已清理") except Exception as e: print(f"✗ 事件处理器资源清理失败: {e}") import traceback traceback.print_exc() def update(self, dt: float): """ 更新事件处理器状态 Args: dt: 时间增量（秒） """ try: if not self.enabled: return current_time = time.time() self.event_state["last_event_time"] = current_time except Exception as e: print(f"✗ 事件处理器更新失败: {e}") self.event_stats["handler_errors"] += 1 import traceback traceback.print_exc() def _process_event_queue(self): """处理事件队列""" try: processed_count = 0 max_process_per_loop = 100 # 每次循环最多处理100个事件 while not self.event_queue.empty() and processed_count < max_process_per_loop: try: # 从队列获取事件 event_data = self.event_queue.get_nowait() # 处理事件 self._handle_event_internal(event_data) processed_count += 1 self.event_stats["events_processed"] += 1 except queue.Empty: break except Exception as e: print(f"✗ 事件队列处理失败: {e}") self.event_stats["handler_errors"] += 1 self.event_state["pending_events"] = self.event_queue.qsize() except Exception as e: print(f"✗ 事件队列处理失败: {e}") self.event_stats["handler_errors"] += 1 def _handle_event_internal(self, event_data: Dict[str, Any]): """ 内部事件处理 Args: event_data: 事件数据 """ try: event_type = event_data.get("type") event_payload = event_data.get("payload", {}) event_priority = event_data.get("priority", 0) event_timestamp = event_data.get("timestamp", time.time()) # 应用事件过滤器 if self.event_config["enable_event_filtering"]: if not self._apply_event_filters(event_type, event_payload): # 事件被过滤掉 return # 查找事件处理器 if event_type in self.event_handlers: handlers = self.event_handlers[event_type] # 按优先级排序处理器 if self.event_config["enable_event_prioritization"]: handlers = sorted(handlers, key=lambda x: x.get("priority", 0), reverse=True) # 调用所有处理器 for handler_info in handlers: try: handler_func = handler_info["function"] handler_result = handler_func(event_payload) # 检查是否需要停止传播 if handler_result is False: break except Exception as e: print(f"✗ 事件处理器执行失败: {event_type} - {e}") self.event_stats["handler_errors"] += 1 # 触发事件处理回调 self._trigger_event_callback("event_processed", { "event_type": event_type, "event_payload": event_payload, "processing_time": time.time() - event_timestamp, "timestamp": time.time() }) except Exception as e: print(f"✗ 内部事件处理失败: {e}") self.event_stats["handler_errors"] += 1 def _apply_event_filters(self, event_type: str, event_payload: Dict[str, Any]) -> bool: """ 应用事件过滤器 Args: event_type: 事件类型 event_payload: 事件载荷 Returns: 是否通过过滤器 """ try: if event_type in self.event_filters: filters = self.event_filters[event_type] for filter_func in filters: if not filter_func(event_payload): return False return True except Exception as e: print(f"✗ 事件过滤器应用失败: {e}") self.event_stats["handler_errors"] += 1 return True def emit_event(self, event_type: str, event_payload: Dict[str, Any] = None, priority: int = 0, async_process: bool = None) -> bool: """ 发出事件 Args: event_type: 事件类型 event_payload: 事件载荷 priority: 事件优先级 async_process: 是否异步处理 Returns: 是否发出成功 """ try: if not self.enabled or not self.event_config["enable_event_system"]: return False # 使用默认异步处理设置或指定设置 if async_process is None: async_process = self.event_config["enable_async_processing"] event_data = { "type": event_type, "payload": event_payload or {}, "priority": priority, "timestamp": time.time(), "async": async_process } # 触发事件接收回调 self._trigger_event_callback("event_received", { "event_type": event_type, "event_payload": event_payload, "priority": priority, "timestamp": time.time() }) # 更新统计 self.event_stats["events_received"] += 1 if async_process: # 异步处理：添加到队列 try: self.event_queue.put_nowait(event_data) self.event_stats["async_events"] += 1 return True except queue.Full: # 队列已满，丢弃事件 self.event_stats["events_dropped"] += 1 self.event_state["dropped_events"] += 1 # 触发事件丢弃回调 self._trigger_event_callback("event_dropped", { "event_type": event_type, "event_payload": event_payload, "reason": "queue_full", "timestamp": time.time() }) return False else: # 同步处理：立即处理 self._handle_event_internal(event_data) return True except Exception as e: print(f"✗ 事件发出失败: {e}") self.event_stats["handler_errors"] += 1 return False def register_event_handler(self, event_type: str, handler: Callable, priority: int = 0): """ 注册事件处理器 Args: event_type: 事件类型 handler: 处理器函数 priority: 处理器优先级 """ try: if event_type not in self.event_handlers: self.event_handlers[event_type] = [] handler_info = { "function": handler, "priority": priority } self.event_handlers[event_type].append(handler_info) print(f"✓ 事件处理器已注册: {event_type} (优先级: {priority})") except Exception as e: print(f"✗ 事件处理器注册失败: {e}") self.event_stats["handler_errors"] += 1 def unregister_event_handler(self, event_type: str, handler: Callable): """ 注销事件处理器 Args: event_type: 事件类型 handler: 处理器函数 """ try: if event_type in self.event_handlers: handlers = self.event_handlers[event_type] for i, handler_info in enumerate(handlers): if handler_info["function"] == handler: del handlers[i] print(f"✓ 事件处理器已注销: {event_type}") return print(f"✗ 事件处理器不存在: {event_type}") except Exception as e: print(f"✗ 事件处理器注销失败: {e}") self.event_stats["handler_errors"] += 1 def register_event_filter(self, event_type: str, filter_func: Callable): """ 注册事件过滤器 Args: event_type: 事件类型 filter_func: 过滤器函数 """ try: if event_type not in self.event_filters: self.event_filters[event_type] = [] self.event_filters[event_type].append(filter_func) print(f"✓ 事件过滤器已注册: {event_type}") except Exception as e: print(f"✗ 事件过滤器注册失败: {e}") self.event_stats["handler_errors"] += 1 def unregister_event_filter(self, event_type: str, filter_func: Callable): """ 注销事件过滤器 Args: event_type: 事件类型 filter_func: 过滤器函数 """ try: if event_type in self.event_filters: filters = self.event_filters[event_type] if filter_func in filters: filters.remove(filter_func) print(f"✓ 事件过滤器已注销: {event_type}") return print(f"✗ 事件过滤器不存在: {event_type}") except Exception as e: print(f"✗ 事件过滤器注销失败: {e}") self.event_stats["handler_errors"] += 1 # 默认事件处理器 def _handle_player_queued(self, payload: Dict[str, Any]): """处理玩家排队事件""" try: player_ids = payload.get("player_ids", []) queue_name = payload.get("queue_name", "default") print(f".players queued: {len(player_ids)} players in queue '{queue_name}'") # 可以在这里添加额外的处理逻辑 # 例如：记录排队时间、更新统计等 except Exception as e: print(f"✗ 玩家排队事件处理失败: {e}") self.event_stats["handler_errors"] += 1 def _handle_player_dequeued(self, payload: Dict[str, Any]): """处理玩家离队事件""" try: player_ids = payload.get("player_ids", []) match_id = payload.get("match_id") print(f".players dequeued: {len(player_ids)} players") # 可以在这里添加额外的处理逻辑 # 例如：更新统计、清理资源等 except Exception as e: print(f"✗ 玩家离队事件处理失败: {e}") self.event_stats["handler_errors"] += 1 def _handle_match_found(self, payload: Dict[str, Any]): """处理匹配找到事件""" try: match_id = payload.get("match_id") room_id = payload.get("room_id") player_ids = payload.get("player_ids", []) queue_name = payload.get("queue_name", "default") print(f"🎉 Match found: {match_id} with {len(player_ids)} players in queue '{queue_name}' -> Room: {room_id}") # 记录匹配队列时间 if self.plugin.monitor: queue_time = time.time() - payload.get("timestamp", time.time()) self.plugin.monitor.record_match_queue_time(queue_time) except Exception as e: print(f"✗ 匹配找到事件处理失败: {e}") self.event_stats["handler_errors"] += 1 def _handle_match_completed(self, payload: Dict[str, Any]): """处理匹配完成事件""" try: match_id = payload.get("match_id") room_id = payload.get("room_id") print(f"✅ Match completed: {match_id} -> Room: {room_id}") except Exception as e: print(f"✗ 匹配完成事件处理失败: {e}") self.event_stats["handler_errors"] += 1 def _handle_match_cancelled(self, payload: Dict[str, Any]): """处理匹配取消事件""" try: match_id = payload.get("match_id") print(f"❌ Match cancelled: {match_id}") except Exception as e: print(f"✗ 匹配取消事件处理失败: {e}") self.event_stats["handler_errors"] += 1 def _handle_queue_timeout(self, payload: Dict[str, Any]): """处理队列超时事件""" try: player_id = payload.get("player_id") print(f"⏰ Queue timeout for player: {player_id}") except Exception as e: print(f"✗ 队列超时事件处理失败: {e}") self.event_stats["handler_errors"] += 1 def get_event_stats(self) -> Dict[str, Any]: """ 获取事件统计信息 Returns: 事件统计字典 """ return { "state": self.event_state.copy(), "stats": self.event_stats.copy(), "config": self.event_config.copy(), "pending_events": self.event_queue.qsize() } def reset_stats(self): """重置事件统计信息""" try: self.event_stats = { "events_received": 0, "events_processed": 0, "events_dropped": 0, "handler_errors": 0, "async_events": 0 } print("✓ 事件统计信息已重置") except Exception as e: print(f"✗ 事件统计信息重置失败: {e}") def set_event_config(self, config: Dict[str, Any]) -> bool: """ 设置事件配置 Args: config: 事件配置字典 Returns: 是否设置成功 """ try: self.event_config.update(config) print(f"✓ 事件配置已更新: {self.event_config}") return True except Exception as e: print(f"✗ 事件配置设置失败: {e}") return False def get_event_config(self) -> Dict[str, Any]: """ 获取事件配置 Returns: 事件配置字典 """ return self.event_config.copy() def _trigger_event_callback(self, callback_type: str, data: Dict[str, Any]): """ 触发事件回调 Args: callback_type: 回调类型 data: 回调数据 """ try: if callback_type in self.event_callbacks: for callback in self.event_callbacks[callback_type]: try: callback(data) except Exception as e: print(f"✗ 事件回调执行失败: {callback_type} - {e}") except Exception as e: print(f"✗ 事件回调触发失败: {e}") def register_event_callback(self, callback_type: str, callback: callable): """ 注册事件回调 Args: callback_type: 回调类型 callback: 回调函数 """ try: if callback_type in self.event_callbacks: self.event_callbacks[callback_type].append(callback) print(f"✓ 事件回调已注册: {callback_type}") else: print(f"✗ 无效的回调类型: {callback_type}") except Exception as e: print(f"✗ 事件回调注册失败: {e}") def unregister_event_callback(self, callback_type: str, callback: callable): """ 注销事件回调 Args: callback_type: 回调类型 callback: 回调函数 """ try: if callback_type in self.event_callbacks: if callback in self.event_callbacks[callback_type]: self.event_callbacks[callback_type].remove(callback) print(f"✓ 事件回调已注销: {callback_type}") else: print(f"✗ 无效的回调类型: {callback_type}") except Exception as e: print(f"✗ 事件回调注销失败: {e}")