Sprout-Farm/SproutFarm-Backend/TCPGameServer.py

from TCPServer import TCPServer

import time
import json
import os
import glob
import threading
import datetime
import re
import random
#导入服务器外置插件模块
from module.SMYMongoDBAPI import SMYMongoDBAPI #导入MongoDB数据库模块
from module.QQEmailSendAPI import EmailVerification#导入QQ邮箱发送模块
from module import ConsoleCommandsAPI #导入控制台命令API模块
from module.SpecialFarm import SpecialFarmManager #导入特殊农场管理系统
from module import WSRemoteCmdApi #导入WebSocket远程命令API
from module.NetworkCore import MessageHandler
from module.WisdomTreeSystem import WisdomTreeMixin #导入网络通信核心模块

"""
萌芽农场TCP游戏服务器
====================================================================
- 协议：TCP长连接
- 数据格式：JSON消息
- 消息类型：请求/响应模式
====================================================================
"""
server_host: str = "0.0.0.0"
server_port: int = 7070
buffer_size: int = 4096
server_version: str = "2.2.0"

class TCPGameServer(WisdomTreeMixin, TCPServer):

    """
    萌芽农场TCP游戏服务器
    """
    
#==========================初始化和生命周期管理==========================
    #初始化操作
    def __init__(self, server_host=server_host, server_port=server_port, buffer_size=buffer_size):
        super().__init__(server_host, server_port, buffer_size)
        
        # 基础数据存储
        self.user_data = {}  # 存储用户相关数据
        self.crop_timer = None  # 作物生长计时器
        self.weed_timer = None  # 杂草生长计时器
        
        # 配置文件目录
        self.config_dir = "config"  # 配置文件存储目录
        
        # 初始化MongoDB API（优先使用MongoDB，失败则使用JSON文件）
        self._init_mongodb_api()
        
        # 初始化杂草系统配置
        self._init_weed_settings()
        
        # 禁用父类的日志输出，避免重复
        self._setup_game_server_logging()
        
        # 数据缓存
        self.crop_data_cache = None
        self.crop_data_cache_time = 0
        self.cache_expire_duration = 300  # 缓存过期时间5分钟
        
        # 偷菜免被发现临时计数器 {玩家名: {目标玩家名: 剩余免被发现次数}}
        self.steal_immunity_counters = {}
        
        # 初始化消息处理器
        self.message_handler = MessageHandler(self)
        
        self.log('INFO', f"萌芽农场TCP游戏服务器初始化完成 - 版本: {server_version}", 'SERVER')
        
        # 清理配置缓存，确保使用最新的配置数据
        self._clear_config_cache()
        
        # 初始化特殊农场管理系统
        self._init_special_farm_manager()
        
        # 初始化WebSocket远程命令API
        self._init_websocket_remote_api()
        
        # 启动定时器
        self.start_crop_growth_timer()
        self.start_weed_growth_timer()
        self.start_wisdom_tree_health_decay_timer()
        self.start_verification_code_cleanup_timer()
        self.start_offline_crop_update_timer()
    
    #初始化MongoDB API
    def _init_mongodb_api(self):
        try:
            # 根据配置决定使用测试环境还是生产环境
            # 检查是否在Docker容器中或生产环境
            import os
            if os.path.exists('/.dockerenv') or os.environ.get('PRODUCTION', '').lower() == 'true':
                environment = "production"
            else:
                environment = "test"
            
            # 保存环境信息供其他组件使用
            self.environment = environment
            
            self.mongo_api = SMYMongoDBAPI(environment)
            if self.mongo_api.is_connected():
                self.use_mongodb = True
                self.log('INFO', f"MongoDB API初始化成功 [{environment}]", 'SERVER')
            else:
                self.use_mongodb = False
                self.mongo_api = None
                self.log('WARNING', "MongoDB连接失败，将使用JSON配置文件", 'SERVER')
                
        except Exception as e:
            self.use_mongodb = False
            self.mongo_api = None
            self.log('ERROR', f"MongoDB API初始化异常: {e}，将使用JSON配置文件", 'SERVER')
    
    #初始化杂草系统配置
    def _init_weed_settings(self):
        # 杂草生长相关配置
        self.weed_check_interval = 86400  # 杂草检查间隔（24小时）
        self.offline_threshold_days = 3  # 离线多少天后开始长杂草
        self.max_weeds_per_check = 3  # 每次检查时最多长多少个杂草
        self.weed_growth_probability = 0.3  # 每个空地长杂草的概率（30%）
        self.last_weed_check_time = time.time()  # 上次检查杂草的时间
    
    #初始化特殊农场管理系统
    def _init_special_farm_manager(self):
        try:
            # 使用自动环境检测，确保与游戏服务器环境一致
            self.special_farm_manager = SpecialFarmManager()
            
            # 启动特殊农场定时任务
            self.special_farm_manager.start_scheduler()
            
            self.log('INFO', f"特殊农场管理系统初始化完成 - 环境: {self.special_farm_manager.environment}", 'SERVER')
            
        except Exception as e:
            self.log('ERROR', f"特殊农场管理系统初始化失败: {str(e)}", 'SERVER')
            self.special_farm_manager = None
    
    #初始化WebSocket远程命令API
    def _init_websocket_remote_api(self):
        try:
            # 创建WebSocket远程命令API实例
            ws_host = "0.0.0.0"
            ws_port = 7071
            auth_key = "mengya2024"  # 可以从配置文件读取
            
            self.ws_remote_api = WSRemoteCmdApi(
                game_server=self,
                host=ws_host,
                port=ws_port,
                auth_key=auth_key
            )
            
            # 启动WebSocket服务器
            self.ws_remote_api.start_server()
            
            self.log('INFO', f"WebSocket远程命令API初始化完成 - ws://{ws_host}:{ws_port}", 'SERVER')
            
        except Exception as e:
            self.log('ERROR', f"WebSocket远程命令API初始化失败: {str(e)}", 'SERVER')
            self.ws_remote_api = None
    
    #设置游戏服务器日志配置
    def _setup_game_server_logging(self):
        # 禁用父类logger的传播，避免重复输出
        if hasattr(self, 'logger') and self.logger:
            self.logger.propagate = False
    
    #启动作物生长计时器
    def start_crop_growth_timer(self):
        try:
            self.update_crops_growth()
        except Exception as e:
            self.log('ERROR', f"作物生长更新时出错: {str(e)}", 'SERVER')
        
        # 创建下一个计时器
        self.crop_timer = threading.Timer(1.0, self.start_crop_growth_timer)
        self.crop_timer.daemon = True
        self.crop_timer.start()
    
    #启动杂草生长计时器
    def start_weed_growth_timer(self):
        try:
            current_time = time.time()
            # 检查是否到了杂草检查时间
            if current_time - self.last_weed_check_time >= self.weed_check_interval:
                self.check_and_grow_weeds()
                self.last_weed_check_time = current_time
        except Exception as e:
            self.log('ERROR', f"杂草生长检查时出错: {str(e)}", 'SERVER')
        
        # 创建下一个杂草检查计时器（每小时检查一次是否到时间）
        self.weed_timer = threading.Timer(3600, self.start_weed_growth_timer)  # 每小时检查一次
        self.weed_timer.daemon = True
        self.weed_timer.start()

    #启动智慧树生命值衰减计时器
    def start_wisdom_tree_health_decay_timer(self):
        try:
            self.check_wisdom_tree_health_decay()
        except Exception as e:
            self.log('ERROR', f"智慧树生命值衰减检查时出错: {str(e)}", 'SERVER')
        
        # 创建下一个智慧树衰减检查计时器（每天检查一次）
        self.wisdom_tree_decay_timer = threading.Timer(86400, self.start_wisdom_tree_health_decay_timer)  # 每24小时检查一次
        self.wisdom_tree_decay_timer.daemon = True
        self.wisdom_tree_decay_timer.start()

    #启动验证码清理定时器
    def start_verification_code_cleanup_timer(self):
        try:

            EmailVerification.clean_expired_codes()
            self.log('INFO', "验证码清理完成", 'SERVER')
        except Exception as e:
            self.log('ERROR', f"验证码清理时出错: {str(e)}", 'SERVER')
        
        # 创建下一个验证码清理计时器（每30分钟检查一次）
        self.verification_cleanup_timer = threading.Timer(1800, self.start_verification_code_cleanup_timer)  # 每30分钟清理一次
        self.verification_cleanup_timer.daemon = True
        self.verification_cleanup_timer.start()

    #启动离线玩家作物更新定时器
    def start_offline_crop_update_timer(self):
        try:
            self.update_offline_players_crops()
        except Exception as e:
            self.log('ERROR', f"离线玩家作物更新时出错: {str(e)}", 'SERVER')
        
        # 创建下一个离线作物更新计时器（每1分钟检查一次）
        self.offline_crop_timer = threading.Timer(60, self.start_offline_crop_update_timer)  # 每1分钟更新一次
        self.offline_crop_timer.daemon = True
        self.offline_crop_timer.start()
    
    #获取服务器统计信息
    def get_server_stats(self):
        online_players = len([cid for cid in self.user_data if self.user_data[cid].get("logged_in", False)])
        return {
            "online_players": online_players,
            "total_connections": len(self.clients)
        }
    
    #停止服务器
    def stop(self):
        self.log('INFO', "正在停止服务器...", 'SERVER')
        
        # 停止作物生长计时器
        if self.crop_timer:
            self.crop_timer.cancel()
            self.crop_timer = None
            self.log('INFO', "作物生长计时器已停止", 'SERVER')
        
        # 停止杂草生长计时器
        if hasattr(self, 'weed_timer') and self.weed_timer:
            self.weed_timer.cancel()
            self.weed_timer = None
            self.log('INFO', "杂草生长计时器已停止", 'SERVER')
        
        # 停止智慧树生命值衰减计时器
        if hasattr(self, 'wisdom_tree_decay_timer') and self.wisdom_tree_decay_timer:
            self.wisdom_tree_decay_timer.cancel()
            self.wisdom_tree_decay_timer = None
            self.log('INFO', "智慧树生命值衰减计时器已停止", 'SERVER')
        
        # 停止验证码清理定时器
        if hasattr(self, 'verification_cleanup_timer') and self.verification_cleanup_timer:
            self.verification_cleanup_timer.cancel()
            self.verification_cleanup_timer = None
            self.log('INFO', "验证码清理定时器已停止", 'SERVER')
        
        # 停止离线作物更新定时器
        if hasattr(self, 'offline_crop_timer') and self.offline_crop_timer:
            self.offline_crop_timer.cancel()
            self.offline_crop_timer = None
            self.log('INFO', "离线作物更新定时器已停止", 'SERVER')
        
        # 停止特殊农场管理系统
        if hasattr(self, 'special_farm_manager') and self.special_farm_manager:
            try:
                # 停止特殊农场定时任务
                self.special_farm_manager.stop_scheduler()
                
                # 清理特殊农场管理器引用
                self.special_farm_manager = None
                
                self.log('INFO', "特殊农场管理系统已停止", 'SERVER')
            except Exception as e:
                self.log('ERROR', f"停止特殊农场管理系统时出错: {str(e)}", 'SERVER')
        
        # 停止WebSocket远程命令API服务器
        if hasattr(self, 'ws_remote_api') and self.ws_remote_api:
            try:
                self.ws_remote_api.stop_server()
                self.ws_remote_api = None
                self.log('INFO', "WebSocket远程命令API服务器已停止", 'SERVER')
            except Exception as e:
                self.log('ERROR', f"停止WebSocket远程命令API服务器时出错: {str(e)}", 'SERVER')
        
        # 显示服务器统计信息
        stats = self.get_server_stats()
        self.log('INFO', f"服务器统计 - 在线玩家: {stats['online_players']}, 总连接: {stats['total_connections']}", 'SERVER')
        
        # 调用父类方法完成实际停止
        super().stop()
#==========================初始化和生命周期管理==========================



#==========================客户端连接管理==========================
    #移除客户端
    def _remove_client(self, client_id):
        if client_id in self.clients:
            username = self.user_data.get(client_id, {}).get("username", client_id)
            
            # 处理已登录用户的离开
            if client_id in self.user_data and self.user_data[client_id].get("logged_in", False):
                self._update_player_logout_time(client_id, username)
                self.log('INFO', f"用户 {username} 登出", 'SERVER')
            
            # 清理用户数据
            if client_id in self.user_data:
                # 清理偷菜免被发现计数器
                self._clear_player_steal_immunity(username)
                del self.user_data[client_id]
                
            self.log('INFO', f"用户 {username} 已离开游戏", 'SERVER')
            
            # 先调用父类方法移除客户端，避免递归调用
            super()._remove_client(client_id)
            
            # 在客户端已移除后再广播用户离开消息，避免向已断开的客户端发送消息
            self.broadcast({
                "type": "user_left",
                "user_id": client_id,
                "timestamp": time.time(),
                "remaining_users": len(self.clients)
            })
        else:
            # 如果客户端不在列表中，直接调用父类方法
            super()._remove_client(client_id)
#==========================客户端连接管理==========================




#==========================验证和检查方法==========================
    #检查用户是否已登录的通用方法
    def _check_user_logged_in(self, client_id, action_name, action_type=None):
        if client_id not in self.user_data or not self.user_data[client_id].get("logged_in", False):
            self.log('WARNING', f"未登录用户 {client_id} 尝试{action_name}", 'SERVER')
            
            response = {
                "success": False,
                "message": "您需要先登录才能执行此操作"
            }
            
            if action_type:
                response["type"] = "action_response"
                response["action_type"] = action_type
            else:
                response["type"] = f"{action_name}_response"
            
            return False, response
        
        return True, None
    
#==========================验证和检查方法==========================



#=================================数据管理方法====================================
    #加载玩家数据
    def load_player_data(self, account_id):
        try:
            if not self.use_mongodb or not self.mongo_api:
                self.log('ERROR', 'MongoDB未配置或不可用，无法加载玩家数据', 'SERVER')
                return None
                
            player_data = self.mongo_api.get_player_data(account_id)
            if player_data:
                return player_data
            else:
                self.log('DEBUG', f"MongoDB中未找到玩家 {account_id} 的数据", 'SERVER')
                return None
            
        except Exception as e:
            self.log('ERROR', f"读取玩家 {account_id} 的数据时出错: {str(e)}", 'SERVER')
            return None
    
    #保存玩家数据
    def save_player_data(self, account_id, player_data):
        try:
            if not self.use_mongodb or not self.mongo_api:
                self.log('ERROR', 'MongoDB未配置或不可用，无法保存玩家数据', 'SERVER')
                return False
                
            success = self.mongo_api.save_player_data(account_id, player_data)
            if success:
                return True
            else:
                self.log('ERROR', f"MongoDB保存失败: {account_id}", 'SERVER')
                return False
            
        except Exception as e:
            self.log('ERROR', f"保存玩家 {account_id} 的数据时出错: {str(e)}", 'SERVER')
            return False
        
    #加载玩家数据
    def _load_player_data_with_check(self, client_id, action_type=None):
        username = self.user_data[client_id]["username"]
        player_data = self.load_player_data(username)
        
        if not player_data:
            self.log('ERROR', f"无法加载玩家 {username} 的数据", 'SERVER')
            
            response = {
                "success": False,
                "message": "无法加载玩家数据"
            }
            
            if action_type:
                response["type"] = "action_response"
                response["action_type"] = action_type
            else:
                response["type"] = "data_response"
            
            return None, username, response
        
        return player_data, username, None
    
    #加载作物配置数据（优化版本）
    def _clear_config_cache(self):
        self.crop_data_cache = None
        self.crop_data_cache_time = 0
        self.log('INFO', "配置缓存已清理", 'SERVER')

    #加载作物配置数据（优化版本）
    def _load_crop_data(self):
        current_time = time.time()
        
        # 检查缓存是否有效
        if (self.crop_data_cache is not None and 
            current_time - self.crop_data_cache_time < self.cache_expire_duration):
            return self.crop_data_cache
        
        # 缓存过期或不存在，重新加载
        if not self.use_mongodb or not self.mongo_api:
            self.log('ERROR', 'MongoDB未配置或不可用，无法加载作物配置数据', 'SERVER')
            return {}
            
        try:
            crop_data = self.mongo_api.get_crop_data_config()
            if crop_data:
                self.crop_data_cache = crop_data
                self.crop_data_cache_time = current_time
                self.log('INFO', "成功从MongoDB加载作物数据配置", 'SERVER')
                return self.crop_data_cache
            else:
                self.log('ERROR', "MongoDB中未找到作物数据配置", 'SERVER')
                return {}
        except Exception as e:
            self.log('ERROR', f"从MongoDB加载作物数据失败: {str(e)}", 'SERVER')
            return {}
    
    #更新玩家登录时间
    def _update_player_logout_time(self, client_id, username):
        login_timestamp = self.user_data[client_id].get("login_timestamp", time.time())
        play_time_seconds = int(time.time() - login_timestamp)
        
        # 清除访问状态
        self.user_data[client_id]["visiting_mode"] = False
        self.user_data[client_id]["visiting_target"] = ""
        
        # 加载和更新玩家数据
        player_data = self.load_player_data(username)
        if player_data:
            # 更新总游玩时间
            self._update_total_play_time(player_data, play_time_seconds)
            
            # 注意：在线礼包时间累计现在由新系统管理，此处不再需要更新旧格式
            
            self.save_player_data(username, player_data)
            self.log('INFO', f"用户 {username} 本次游玩时间: {play_time_seconds} 秒，总游玩时间: {player_data['总游玩时间']}", 'SERVER')
    
    #更新总游玩时间
    def _update_total_play_time(self, player_data, play_time_seconds):
        total_time_str = player_data.get("总游玩时间", "0时0分0秒")
        time_parts = re.match(r"(?:(\d+)时)?(?:(\d+)分)?(?:(\d+)秒)?", total_time_str)
        
        if time_parts:
            hours = int(time_parts.group(1) or 0)
            minutes = int(time_parts.group(2) or 0)
            seconds = int(time_parts.group(3) or 0)
            
            # 计算新的总游玩时间
            total_seconds = hours * 3600 + minutes * 60 + seconds + play_time_seconds
            new_hours = total_seconds // 3600
            new_minutes = (total_seconds % 3600) // 60
            new_seconds = total_seconds % 60
            
            # 更新总游玩时间
            player_data["总游玩时间"] = f"{new_hours}时{new_minutes}分{new_seconds}秒"
    
    # 检查玩家是否享受新玩家注册奖励
    def _is_new_player_bonus_active(self, player_data):
        register_time_str = player_data.get("注册时间", "")
        
        # 如果没有注册时间或者是默认的老玩家时间，则不享受奖励
        if not register_time_str or register_time_str == "2025年05月21日15时00分00秒":
            return False
        
        try:
            # 解析注册时间
            register_time = datetime.datetime.strptime(register_time_str, "%Y年%m月%d日%H时%M分%S秒")
            current_time = datetime.datetime.now()
            
            # 计算注册天数
            time_diff = current_time - register_time
            days_since_register = time_diff.total_seconds() / 86400  # 转换为天数
            
            # 3天内享受新玩家奖励
            if days_since_register <= 3:
                return True
            else:
                return False
                
        except ValueError as e:
            self.log('WARNING', f"解析注册时间格式错误: {register_time_str}, 错误: {str(e)}", 'SERVER')
            return False

    #更新离线玩家的作物生长
    def update_offline_players_crops(self):
        try:
            if not self.use_mongodb or not self.mongo_api:
                self.log('WARNING', 'MongoDB未配置或不可用，无法更新离线玩家作物', 'SERVER')
                return
            
            # 获取需要排除的玩家列表（在线玩家 + 被访问的玩家）
            exclude_players = []
            
            # 添加在线玩家
            for client_id, user_info in self.user_data.items():
                if user_info.get("logged_in", False) and user_info.get("username"):
                    exclude_players.append(user_info["username"])
            
            # 添加被访问的玩家（避免访问模式下的重复更新）
            visited_players = set()
            for client_id, user_info in self.user_data.items():
                if (user_info.get("logged_in", False) and 
                    user_info.get("visiting_mode", False) and 
                    user_info.get("visiting_target")):
                    visited_players.add(user_info["visiting_target"])
            
            # 将被访问的玩家也加入排除列表
            exclude_players.extend(list(visited_players))
            
            # 直接调用优化后的批量更新方法，传入排除玩家列表
            # 离线更新间隔为60秒，所以每次更新应该增长60秒
            updated_count = self.mongo_api.batch_update_offline_players_crops(
                growth_multiplier=60.0, 
                exclude_online_players=exclude_players
            )
            
            if updated_count > 0:
                self.log('INFO', f"成功更新了 {updated_count} 个离线玩家的作物生长（排除了 {len(exclude_players)} 个在线/被访问玩家）", 'SERVER')
            else:
                self.log('DEBUG', "没有离线玩家的作物需要更新", 'SERVER')
                
        except Exception as e:
            self.log('ERROR', f"更新离线玩家作物时出错: {str(e)}", 'SERVER')

#=================================数据管理方法====================================



#================================作物系统管理=========================================
    #作物生长更新系统
    def update_crops_growth(self):
        # 收集所有需要更新的玩家（在线玩家 + 被访问的玩家）
        players_to_update = set()
        
        # 添加在线玩家
        for client_id, user_info in self.user_data.items():
            if user_info.get("logged_in", False) and user_info.get("username"):
                players_to_update.add(user_info.get("username"))
        
        # 添加被访问的玩家（即使他们不在线）
        for client_id, user_info in self.user_data.items():
            if user_info.get("logged_in", False) and user_info.get("visiting_mode", False):
                visiting_target = user_info.get("visiting_target", "")
                if visiting_target:
                    players_to_update.add(visiting_target)
        
        # 更新所有需要更新的玩家的作物
        for username in players_to_update:
            try:
                player_data = self.load_player_data(username)
                if not player_data:
                    continue
                
                if self.update_player_crops(player_data, username):
                    # 确保数据保存成功后才推送更新
                    if self.save_player_data(username, player_data):
                        self._push_crop_update_to_player(username, player_data)
                    else:
                        self.log('ERROR', f"保存玩家 {username} 数据失败，跳过推送更新", 'SERVER')
                    
            except Exception as e:
                self.log('ERROR', f"更新玩家 {username} 作物时出错: {str(e)}", 'SERVER')
    
    #更新单个玩家的作物
    def update_player_crops(self, player_data, account_id):
        growth_updated = False
        
        for farm_lot in player_data.get("农场土地", []):
            if (farm_lot.get("crop_type") and farm_lot.get("is_planted") and 
                not farm_lot.get("is_dead") and farm_lot["grow_time"] < farm_lot["max_grow_time"]):
                
                # 计算生长速度增量（累加方式）
                growth_increase = 1  # 基础生长速度：每次更新增长1秒
                
                # 新玩家注册奖励：注册后3天内额外增加9秒（总共10倍速度）
                if self._is_new_player_bonus_active(player_data):
                    growth_increase += 9
                    
                # 土地等级影响 - 根据不同等级额外增加生长速度
                land_level = farm_lot.get("土地等级", 0)
                land_speed_bonus = {
                    0: 0,   # 默认土地：无额外加成
                    1: 1,   # 黄土地：额外+1秒（总共2倍速）
                    2: 3,   # 红土地：额外+3秒（总共4倍速）
                    3: 5,   # 紫土地：额外+5秒（总共6倍速）
                    4: 9    # 黑土地：额外+9秒（总共10倍速）
                }
                growth_increase += land_speed_bonus.get(land_level, 0)
                
                # 施肥影响 - 支持不同类型的道具施肥
                if farm_lot.get("已施肥", False) and "施肥时间" in farm_lot:
                    fertilize_time = farm_lot.get("施肥时间", 0)
                    current_time = time.time()
                    
                    # 获取施肥类型和对应的持续时间、倍数
                    fertilize_type = farm_lot.get("施肥类型", "普通施肥")
                    fertilize_duration = farm_lot.get("施肥持续时间", 600)  # 默认10分钟
                    fertilize_bonus = farm_lot.get("施肥加成", 1)  # 默认额外+1秒
                    
                    if current_time - fertilize_time <= fertilize_duration:
                        # 施肥效果仍在有效期内，累加施肥加成
                        growth_increase += fertilize_bonus
                    else:
                        # 施肥效果过期，清除施肥状态
                        farm_lot["已施肥"] = False
                        if "施肥时间" in farm_lot:
                            del farm_lot["施肥时间"]
                        if "施肥类型" in farm_lot:
                            del farm_lot["施肥类型"]
                        if "施肥倍数" in farm_lot:
                            del farm_lot["施肥倍数"]
                        if "施肥持续时间" in farm_lot:
                            del farm_lot["施肥持续时间"]
                        if "施肥加成" in farm_lot:
                            del farm_lot["施肥加成"]
                
                # 确保最小增长量为1
                if growth_increase < 1:
                    growth_increase = 1
                
                farm_lot["grow_time"] += growth_increase
                growth_updated = True
        
        return growth_updated
    
    #向在线玩家推送作物生长更新
    def _push_crop_update_to_player(self, account_id, player_data):
        client_id = self._find_client_by_username(account_id)
        
        if client_id:
            visiting_mode = self.user_data[client_id].get("visiting_mode", False)
            visiting_target = self.user_data[client_id].get("visiting_target", "")
            
            if visiting_mode and visiting_target:
                self._send_visiting_update(client_id, visiting_target)
            else:
                self._send_normal_update(client_id, player_data)
        
        # 检查是否有其他玩家正在访问这个玩家的农场
        self._push_update_to_visitors(account_id, player_data)
    
    #根据用户名查找客户端ID
    def _find_client_by_username(self, username):
        for cid, user_info in self.user_data.items():
            if user_info.get("username") == username and user_info.get("logged_in", False):
                return cid
        return None
    
    #发送访问模式的更新
    def _send_visiting_update(self, client_id, visiting_target):
        target_player_data = self.load_player_data(visiting_target)
        if target_player_data:
            target_client_id = self._find_client_by_username(visiting_target)
            
            update_message = {
                "type": "crop_update",
                "农场土地": target_player_data.get("农场土地", []),
                "timestamp": time.time(),
                "is_visiting": True,
                "visited_player": visiting_target,
                "target_online": target_client_id is not None
            }
            self.send_data(client_id, update_message)
    
    #发送正常模式的更新
    def _send_normal_update(self, client_id, player_data):
        update_message = {
            "type": "crop_update",
            "农场土地": player_data.get("农场土地", []),
            "timestamp": time.time(),
            "is_visiting": False
        }
        self.send_data(client_id, update_message)
    
    #向正在访问某个玩家农场的其他玩家推送更新
    def _push_update_to_visitors(self, target_username, target_player_data):
        for visitor_client_id, visitor_info in self.user_data.items():
            if not visitor_info.get("logged_in", False):
                continue
                
            visiting_mode = visitor_info.get("visiting_mode", False)
            visiting_target = visitor_info.get("visiting_target", "")
            
            # 如果这个玩家正在访问目标玩家的农场，发送更新
            if visiting_mode and visiting_target == target_username:
                target_client_id = self._find_client_by_username(target_username)
                
                update_message = {
                    "type": "crop_update",
                    "农场土地": target_player_data.get("农场土地", []),
                    "timestamp": time.time(),
                    "is_visiting": True,
                    "visited_player": target_username,
                    "target_online": target_client_id is not None
                }
                self.send_data(visitor_client_id, update_message)
                self.log('DEBUG', f"向访问者 {visitor_info.get('username', 'unknown')} 推送 {target_username} 的农场更新", 'SERVER')
#================================作物系统管理=========================================





# =======================服务端与客户端通信注册==========================================
    #服务端与客户端通用消息处理-这个是服务端与客户端通信的核心中的核心
    def _handle_message(self, client_id, message):
        # 使用NetworkCore模块的MessageHandler处理消息
        return self.message_handler.handle_message(client_id, message)
# =======================服务端与客户端通信注册==========================================




#==========================用户认证相关==========================
    #处理问候消息
    def _handle_greeting(self, client_id, message):
        content = message.get("content", "")
        self.log('INFO', f"收到来自客户端 {client_id} 的问候: {content}", 'CLIENT')
        
        # 保存用户会话信息
        self.user_data[client_id] = {
            "last_active": time.time(),
            "messages_count": 0
        }
        
        # 回复欢迎消息
        response = {
            "type": "greeting_response",
            "content": f"欢迎 {client_id}!",
            "server_time": time.time(),
            "active_users": len(self.clients)
        }
        
        # 通知其他用户有新用户加入
        self.broadcast(
            {
                "type": "user_joined",
                "user_id": client_id,
                "timestamp": time.time(),
                "active_users": len(self.clients)
            },
            exclude=[client_id]
        )
        
        self.log('INFO', f"用户 {client_id} 已加入游戏", 'SERVER')
        return self.send_data(client_id, response)
    
    #处理玩家登录
    def _handle_login(self, client_id, message):
        username = message.get("username", "")
        password = message.get("password", "")
        client_version = message.get("client_version", "")
        
        # 验证客户端版本
        version_valid, version_response = self._check_client_version(client_version, f"用户 {username} 登录")
        if not version_valid:
            version_response["type"] = "login_response"
            version_response["status"] = "failed"
            return self.send_data(client_id, version_response)
        
        # 读取玩家数据
        player_data = self.load_player_data(username)
        
        if player_data and player_data.get("玩家密码") == password:
            # 检查禁用系统
            ban_system = player_data.get("禁用系统", {})
            is_banned = ban_system.get("是否被禁止登录", False)
            
            if is_banned:
                # 检查禁止登录是否已过期
                ban_end_time = ban_system.get("禁止登录截止", "")
                if ban_end_time:
                    try:
                        end_datetime = datetime.datetime.strptime(ban_end_time, "%Y-%m-%d %H:%M:%S")
                        current_datetime = datetime.datetime.now()
                        
                        if current_datetime >= end_datetime:
                            # 禁止登录已过期，解除禁止
                            player_data["禁用系统"] = {
                                "是否被禁止登录": False,
                                "禁止登录原因": "",
                                "禁止登录开始": "",
                                "禁止登录截止": ""
                            }
                            self.save_player_data(username, player_data)
                            self.log('INFO', f"用户 {username} 禁止登录已过期，自动解除", 'SERVER')
                        else:
                            # 仍在禁止期内
                            ban_reason = ban_system.get("禁止登录原因", "您已被管理员禁止登录")
                            self.log('WARNING', f"用户 {username} 登录失败: 账号被禁止登录", 'SERVER')
                            response = {
                                "type": "login_response",
                                "status": "banned",
                                "message": ban_reason,
                                "ban_end_time": ban_end_time
                            }
                            return self.send_data(client_id, response)
                    except Exception as e:
                        self.log('ERROR', f"解析禁止登录时间出错: {e}", 'SERVER')
                        # 如果解析出错，仍然禁止登录
                        ban_reason = ban_system.get("禁止登录原因", "您已被管理员禁止登录")
                        response = {
                            "type": "login_response",
                            "status": "banned",
                            "message": ban_reason
                        }
                        return self.send_data(client_id, response)
                else:
                    # 永久禁止或没有截止时间
                    ban_reason = ban_system.get("禁止登录原因", "您已被管理员禁止登录")
                    self.log('WARNING', f"用户 {username} 登录失败: 账号被永久禁止登录", 'SERVER')
                    response = {
                        "type": "login_response",
                        "status": "banned",
                        "message": ban_reason
                    }
                    return self.send_data(client_id, response)
            
            # 登录成功
            self.log('INFO', f"用户 {username} 登录成功", 'SERVER')
            
            # 更新最后登录时间
            current_time = datetime.datetime.now()
            player_data["最后登录时间"] = current_time.strftime("%Y年%m月%d日%H时%M分%S秒")
            
            # 检查并更新体力值
            stamina_updated = self._check_and_update_stamina(player_data)
            if stamina_updated:
                stamina_system = player_data.get("体力系统", {})
                current_stamina = stamina_system.get("当前体力值", 20)
                self.log('INFO', f"玩家 {username} 体力值已更新：{current_stamina}", 'SERVER')
            
            # 检查并更新每日点赞次数
            likes_updated = self._check_and_update_daily_likes(player_data)
            if likes_updated:
                like_system = player_data.get("点赞系统", {})
                remaining_likes = like_system.get("今日剩余点赞次数", 10)
                self.log('INFO', f"玩家 {username} 每日点赞次数已重置：{remaining_likes}", 'SERVER')
            
            # 检查并清理在线礼包历史数据
            self._cleanup_online_gift_history(player_data )
            
            # 检查并清理新手礼包历史数据
            self._cleanup_new_player_gift_history(player_data)
            
            # 检查并清理体力系统历史数据
            self._cleanup_stamina_system_history(player_data)
            
            # 检查并更新已存在玩家的注册时间
            self._check_and_update_register_time(player_data, username)
            
            # 检查并修复智慧树配置
            self._check_and_fix_wisdom_tree_config(player_data, username)
            
            # 注意：在线礼包数据已改为中文系统管理，不再需要初始化英文格式数据
            
            # 保存用户会话信息
            self.user_data[client_id] = {
                "username": username,
                "last_active": time.time(),
                "messages_count": 0,
                "logged_in": True,
                "login_timestamp": time.time()
            }
            
            # 保存更新后的玩家数据
            self.save_player_data(username, player_data)
            
            # 发送初始数据
            self._send_initial_login_data(client_id, player_data)
            
            # 返回登录成功消息，转换巡逻宠物和出战宠物数据
            response_player_data = player_data.copy()
            response_player_data["巡逻宠物"] = self._convert_patrol_pets_to_full_data(player_data)
            response_player_data["出战宠物"] = self._convert_battle_pets_to_full_data(player_data)
            
            # 获取点赞系统信息
            like_system = player_data.get("点赞系统", {})
            remaining_likes = like_system.get("今日剩余点赞次数", 10)
            
            response = {
                "type": "login_response",
                "status": "success",
                "message": "登录成功",
                "player_data": response_player_data,
                "remaining_likes": remaining_likes
            }
        else:
            # 登录失败
            self.log('WARNING', f"用户 {username} 登录失败: 账号或密码错误", 'SERVER')
            response = {
                "type": "login_response",
                "status": "failed",
                "message": "账号或密码错误"
            }
            
        return self.send_data(client_id, response)
    
    #辅助函数-发送登录后初始数据
    def _send_initial_login_data(self, client_id, player_data ):
        # 立即向客户端发送一次作物状态
        farm_lots = player_data.get("农场土地", [])
        initial_crop_update = {
            "type": "crop_update",
            "农场土地": farm_lots,
            "timestamp": time.time()
        }
        self.send_data(client_id, initial_crop_update)
        
        # 发送最新的作物数据配置
        crop_data = self._load_crop_data()
        if crop_data:
            crop_data_message = {
                "type": "crop_data_response",
                "success": True,
                "crop_data": crop_data
            }
            self.send_data(client_id, crop_data_message)
            self.log('INFO', f"已向登录用户发送作物数据配置", 'SERVER')
        
        # 发送最新的道具配置数据
        item_config = self._load_item_config()
        if item_config:
            item_config_message = {
                "type": "item_config_response",
                "success": True,
                "item_config": item_config
            }
            self.send_data(client_id, item_config_message)
            self.log('INFO', f"已向登录用户发送道具配置数据，道具种类：{len(item_config)}", 'SERVER')

    #处理注册消息
    def _handle_register(self, client_id, message):
        """处理注册消息"""
        username = message.get("username", "")
        password = message.get("password", "")
        farm_name = message.get("农场名称", "")
        player_name = message.get("玩家昵称", "")
        verification_code = message.get("verification_code", "")
        client_version = message.get("client_version", "")
        
        # 验证客户端版本
        version_valid, version_response = self._check_client_version(client_version, f"用户 {username} 注册")
        if not version_valid:
            version_response["type"] = "register_response"
            version_response["status"] = "failed"
            return self.send_data(client_id, version_response)
        
        # 验证必填字段
        if not username or not password:
            return self._send_register_error(client_id, "用户名或密码不能为空")
        
        # 验证用户名是否是QQ号
        if not self._validate_qq_number(username):
            return self._send_register_error(client_id, "用户名必须是5-12位的QQ号码")
        
        # 验证验证码
        if verification_code:

            success, verify_message = EmailVerification.verify_code(username, verification_code, "register")
            if not success:
                self.log('WARNING', f"QQ号 {username} 注册验证码验证失败: {verify_message}", 'SERVER')
                return self._send_register_error(client_id, f"验证码错误: {verify_message}")
            else:
                self.log('INFO', f"QQ号 {username} 注册验证码验证成功", 'SERVER')
        
        # 检查用户是否已存在
        file_path = os.path.join("game_saves", f"{username}.json")
        if os.path.exists(file_path):
            return self._send_register_error(client_id, "该用户名已被注册")
        
        # 创建新用户
        return self._create_new_user(client_id, username, password, farm_name, player_name)
    
        #检查客户端版本是否与服务端匹配
    
        #创建新用户
   
    #辅助函数-发送注册错误处理
    def _send_register_error(self, client_id, message):
        """发送注册错误响应"""
        self.log('WARNING', f"注册失败: {message}", 'SERVER')
        return self.send_data(client_id, {
            "type": "register_response",
            "status": "failed",
            "message": message
        })

    #辅助函数-创建新用户
    def _create_new_user(self, client_id, username, password, farm_name, player_name):
        """创建新用户（从MongoDB加载模板）"""
        try:
            # 从MongoDB加载初始玩家数据模板
            if not self.use_mongodb or not self.mongo_api:
                return self._send_register_error(client_id, "MongoDB未配置或不可用，无法注册新用户")
                
            try:
                player_data = self.mongo_api.get_initial_player_data_template()
                if not player_data:
                    return self._send_register_error(client_id, "MongoDB中未找到初始玩家数据模板，无法注册新用户")
                self.log('INFO', "成功从MongoDB加载初始玩家数据模板", 'SERVER')
            except Exception as e:
                self.log('ERROR', f"从MongoDB加载初始玩家数据模板失败: {str(e)}", 'SERVER')
                return self._send_register_error(client_id, f"加载初始玩家数据模板失败: {str(e)}")
            
            # 更新玩家基本信息
            current_time = datetime.datetime.now()
            time_str = current_time.strftime("%Y年%m月%d日%H时%M分%S秒")
            
            player_data.update({
                "玩家账号": username,
                "玩家密码": password,
                "农场名称": farm_name or "我的农场",
                "玩家昵称": player_name or username,
                "个人简介": "",
                "最后登录时间": time_str,
                "注册时间": time_str,
                "总游玩时间": player_data.get("总游玩时间", "0时0分0秒")
            })
            
            # 确保必要字段存在
            self._ensure_player_data_fields(player_data)
            
            # 保存新用户数据到MongoDB
            if not self.save_player_data(username, player_data):
                return self._send_register_error(client_id, "保存用户数据失败，注册失败")
                
            self.log('INFO', f"用户 {username} 注册成功，注册时间: {time_str}，享受3天新玩家10倍生长速度奖励", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "register_response",
                "status": "success",
                "message": "注册成功，请登录游戏！新玩家享受3天10倍作物生长速度奖励"
            })
            
        except Exception as e:
            self.log('ERROR', f"注册用户 {username} 时出错: {str(e)}", 'SERVER')
            return self._send_register_error(client_id, f"注册过程中出现错误: {str(e)}")

    #辅助函数-确保玩家数据包含所有必要字段
    def _ensure_player_data_fields(self, player_data):
        """确保玩家数据包含所有必要字段"""
        # 确保农场地块存在
        if "农场土地" not in player_data:
            player_data["农场土地"] = []
            for i in range(40):
                player_data["农场土地"].append({
                    "crop_type": "",
                    "grow_time": 0,
                    "is_dead": False,
                    "is_diged": i < 20,  # 默认开垦前20块地
                    "is_planted": False,
                    "max_grow_time": 5 if i >= 20 else 3,
                    "已浇水": False,
                    "已施肥": False,
                    "土地等级": 0
                })
        
        # 确保基本仓库存在
        for field in ["种子仓库", "作物仓库", "道具背包", "宠物背包", "巡逻宠物", "出战宠物"]:
            if field not in player_data:
                player_data[field] = []
    
    #辅助函数-客户端版本检查
    def _check_client_version(self, client_version, action_name="操作"):
        """检查客户端版本是否与服务端匹配"""
        if client_version != server_version:
            self.log('WARNING', f"{action_name}失败: 版本不匹配 (客户端: {client_version}, 服务端: {server_version})", 'SERVER')
            
            response = {
                "success": False,
                "message": f"版本不匹配！客户端版本: {client_version},\n 服务端版本: {server_version}，请更新客户端"
            }
            return False, response
        
        return True, None
    
    #处理验证码请求
    def _handle_verification_code_request(self, client_id, message):
        """处理验证码请求"""
        
        qq_number = message.get("qq_number", "")
        
        # 验证QQ号
        if not self._validate_qq_number(qq_number):
            return self.send_data(client_id, {
                "type": "verification_code_response",
                "success": False,
                "message": "QQ号格式无效，请输入5-12位数字"
            })
        
        # 生成验证码
        verification_code = EmailVerification.generate_verification_code()
        
        # 发送验证码邮件
        success, send_message = EmailVerification.send_verification_email(qq_number, verification_code)
        
        if success:
            # 保存验证码（注册类型）
            EmailVerification.save_verification_code(qq_number, verification_code, 300, "register")
            self.log('INFO', f"已向QQ号 {qq_number} 发送注册验证码: {verification_code}", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "verification_code_response",
                "success": True,
                "message": "验证码已发送到您的QQ邮箱，请查收"
            })
        else:
            self.log('ERROR', f"发送验证码失败: {send_message}", 'SERVER')
            return self.send_data(client_id, {
                "type": "verification_code_response",
                "success": False,
                "message": f"发送验证码失败: {send_message}"
            })
    
    #处理验证码验证
    def _handle_verify_code(self, client_id, message):
        """处理验证码验证"""
        
        qq_number = message.get("qq_number", "")
        input_code = message.get("code", "")
        
        if not input_code:
            return self.send_data(client_id, {
                "type": "verify_code_response",
                "success": False,
                "message": "验证码不能为空"
            })
        
        # 验证验证码
        success, verify_message = EmailVerification.verify_code(qq_number, input_code)
        
        if success:
            self.log('INFO', f"QQ号 {qq_number} 的验证码验证成功", 'SERVER')
            return self.send_data(client_id, {
                "type": "verify_code_response",
                "success": True,
                "message": "验证成功"
            })
        else:
            self.log('WARNING', f"QQ号 {qq_number} 的验证码验证失败: {verify_message}", 'SERVER')
            return self.send_data(client_id, {
                "type": "verify_code_response",
                "success": False,
                "message": verify_message
            })
    
        #验证QQ号格式
    
    #处理忘记密码验证码请求
    def _handle_forget_password_verification_code_request(self, client_id, message):
        """处理忘记密码验证码请求"""
        
        qq_number = message.get("qq_number", "")
        
        # 验证QQ号
        if not self._validate_qq_number(qq_number):
            return self.send_data(client_id, {
                "type": "forget_password_verification_code_response",
                "success": False,
                "message": "QQ号格式无效，请输入5-12位数字"
            })
        
        # 检查账号是否存在
        player_data = self.load_player_data(qq_number)
        if not player_data:
            return self.send_data(client_id, {
                "type": "forget_password_verification_code_response",
                "success": False,
                "message": "该账号不存在，请检查QQ号是否正确"
            })
        
        # 生成验证码
        verification_code = EmailVerification.generate_verification_code()
        
        # 发送验证码邮件（专门用于密码重置）
        success, send_message = EmailVerification.send_verification_email(qq_number, verification_code, "reset_password")
        
        if success:
            # 保存验证码（密码重置类型）
            EmailVerification.save_verification_code(qq_number, verification_code, 300, "reset_password")
            self.log('INFO', f"已向QQ号 {qq_number} 发送密码重置验证码: {verification_code}", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "forget_password_verification_code_response",
                "success": True,
                "message": "密码重置验证码已发送到您的QQ邮箱，请查收"
            })
        else:
            self.log('ERROR', f"发送密码重置验证码失败: {send_message}", 'SERVER')
            return self.send_data(client_id, {
                "type": "forget_password_verification_code_response",
                "success": False,
                "message": f"发送验证码失败: {send_message}"
            })

    #处理重置密码请求
    def _handle_reset_password_request(self, client_id, message):
        """处理重置密码请求"""
        
        username = message.get("username", "")
        new_password = message.get("new_password", "")
        verification_code = message.get("verification_code", "")
        
        # 验证必填字段
        if not username or not new_password or not verification_code:
            return self.send_data(client_id, {
                "type": "reset_password_response",
                "success": False,
                "message": "用户名、新密码或验证码不能为空"
            })
        
        # 验证QQ号格式
        if not self._validate_qq_number(username):
            return self.send_data(client_id, {
                "type": "reset_password_response",
                "success": False,
                "message": "用户名必须是5-12位的QQ号码"
            })
        
        # 检查账号是否存在
        player_data = self.load_player_data(username)
        if not player_data:
            return self.send_data(client_id, {
                "type": "reset_password_response",
                "success": False,
                "message": "该账号不存在，请检查QQ号是否正确"
            })
        
        # 验证验证码（密码重置类型）
        success, verify_message = EmailVerification.verify_code(username, verification_code, "reset_password")
        if not success:
            self.log('WARNING', f"QQ号 {username} 密码重置验证码验证失败: {verify_message}", 'SERVER')
            return self.send_data(client_id, {
                "type": "reset_password_response",
                "success": False,
                "message": f"验证码错误: {verify_message}"
            })
        else:
            self.log('INFO', f"QQ号 {username} 密码重置验证码验证成功", 'SERVER')
        
        # 更新密码
        try:
            player_data["玩家密码"] = new_password
            
            # 保存到文件
            self.save_player_data(username, player_data)
            
            self.log('INFO', f"用户 {username} 密码重置成功", 'ACCOUNT')
            
            return self.send_data(client_id, {
                "type": "reset_password_response",
                "success": True,
                "message": "密码重置成功，请使用新密码登录"
            })
            
        except Exception as e:
            self.log('ERROR', f"重置密码时出错: {str(e)}", 'ACCOUNT')
            return self.send_data(client_id, {
                "type": "reset_password_response",
                "success": False,
                "message": "密码重置失败，请稍后重试"
            })

    #辅助函数-验证QQ号格式
    def _validate_qq_number(self, qq_number):
        """验证QQ号格式"""
        return re.match(r'^\d{5,12}$', qq_number) is not None
    
#==========================用户认证相关==========================






#==========================收获作物处理==========================
    #处理收获作物请求
    def _handle_harvest_crop(self, client_id, message):
        """处理收获作物请求（优化版本）"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "收获作物", "harvest_crop")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取当前操作用户的数据
        current_player_data, current_username, response = self._load_player_data_with_check(client_id, "harvest_crop")
        if not current_player_data:
            return self.send_data(client_id, response)
        
        lot_index = message.get("lot_index", -1)
        target_username = message.get("target_username", "")
        
        # 预加载作物配置数据（只加载一次）
        crop_data = self._load_crop_data()
        if not crop_data:
            return self._send_action_error(client_id, "harvest_crop", "无法加载作物配置数据")
        
        # 确定操作目标：如果有target_username就是访问模式（偷菜），否则是自己的农场
        if target_username and target_username != current_username:
            # 访问模式：偷菜（收益给自己，清空目标玩家的作物）
            target_player_data = self.load_player_data(target_username)
            if not target_player_data:
                return self._send_action_error(client_id, "harvest_crop", f"无法找到玩家 {target_username} 的数据")
            
            # 验证地块索引
            if lot_index < 0 or lot_index >= len(target_player_data.get("农场土地", [])):
                return self._send_action_error(client_id, "harvest_crop", "无效的地块索引")
            
            target_lot = target_player_data["农场土地"][lot_index]
            
            # 检查地块状态
            if not target_lot.get("is_planted", False) or not target_lot.get("crop_type", ""):
                return self._send_action_error(client_id, "harvest_crop", "此地块没有种植作物")
            
            if target_lot.get("is_dead", False):
                # 处理已死亡的作物（只清理，不给收益）
                target_lot["is_planted"] = False
                target_lot["crop_type"] = ""
                target_lot["grow_time"] = 0
                
                self.save_player_data(target_username, target_player_data)
                self._push_crop_update_to_player(target_username, target_player_data)
                
                return self.send_data(client_id, {
                    "type": "action_response",
                    "action_type": "harvest_crop",
                    "success": True,
                    "message": f"已帮助 {target_username} 清理死亡的作物",
                    "updated_data": {
                        "钱币": current_player_data["钱币"],
                        "经验值": current_player_data["经验值"],
                        "等级": current_player_data["等级"]
                    }
                })
            
            if target_lot["grow_time"] < target_lot["max_grow_time"]:
                return self._send_action_error(client_id, "harvest_crop", "作物尚未成熟，无法偷菜")
            
            # 处理偷菜
            return self._process_steal_crop_optimized(client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, crop_data)
        else:
            # 正常模式：收获自己的作物
            # 验证地块索引
            if lot_index < 0 or lot_index >= len(current_player_data.get("农场土地", [])):
                return self._send_action_error(client_id, "harvest_crop", "无效的地块索引")
            
            lot = current_player_data["农场土地"][lot_index]
            
            # 检查地块状态
            if not lot.get("is_planted", False) or not lot.get("crop_type", ""):
                return self._send_action_error(client_id, "harvest_crop", "此地块没有种植作物")
            
            if lot.get("is_dead", False):
                # 处理已死亡的作物
                lot["is_planted"] = False
                lot["crop_type"] = ""
                lot["grow_time"] = 0
                
                self.save_player_data(current_username, current_player_data)
                self._push_crop_update_to_player(current_username, current_player_data)
                
                return self.send_data(client_id, {
                    "type": "action_response",
                    "action_type": "harvest_crop",
                    "success": True,
                    "message": "已铲除死亡的作物",
                    "updated_data": {
                        "钱币": current_player_data["钱币"],
                        "经验值": current_player_data["经验值"],
                        "等级": current_player_data["等级"]
                    }
                })
            
            if lot["grow_time"] < lot["max_grow_time"]:
                return self._send_action_error(client_id, "harvest_crop", "作物尚未成熟")
            
            # 处理正常收获
            return self._process_harvest_optimized(client_id, current_player_data, current_username, lot, lot_index, crop_data)

    #辅助函数-处理作物收获（优化版本）
    def _process_harvest_optimized(self, client_id, player_data, username, lot, lot_index, crop_data):
        """处理作物收获逻辑（优化版本）"""
        # 获取作物类型和基本信息
        crop_type = lot["crop_type"]
        crop_info = crop_data.get(crop_type, {})
        
        # 检查是否为杂草类型（杂草不能收获，只能铲除）
        is_weed = crop_info.get("是否杂草", False)
        if is_weed:
            return self._send_action_error(client_id, "harvest_crop", f"{crop_type}不能收获，只能铲除！请使用铲除功能清理杂草。")
        
        # 额外检查：如果作物收益为负数，也视为杂草
        crop_income = crop_info.get("收益", 100) + crop_info.get("花费", 0)
        if crop_income < 0:
            return self._send_action_error(client_id, "harvest_crop", f"{crop_type}不能收获，只能铲除！请使用铲除功能清理杂草。")
        
        # 获取作物经验
        crop_exp = crop_info.get("经验", 10)
        
        # 生成成熟物收获（1-5个）
        import random
        harvest_count = random.randint(1, 5)
        
        # 10%概率获得1-2个该作物的种子
        seed_reward = None
        if random.random() <= 0.1:
            seed_reward = {
                "name": crop_type,
                "count": random.randint(1, 2)
            }
        
        # 更新玩家经验
        player_data["经验值"] += crop_exp
        
        # 检查是否会获得成熟物
        mature_name = crop_info.get("成熟物名称")
        will_get_mature_item = mature_name is not None
        mature_item_name = mature_name if mature_name and mature_name.strip() else crop_type
        
        # 添加成熟物到作物仓库（如果允许）
        if will_get_mature_item:
            self._add_crop_to_warehouse_optimized(player_data, {"name": crop_type, "count": harvest_count}, crop_type, crop_info.get("品质", "普通"))
        
        # 添加种子奖励到背包
        if seed_reward:
            self._add_seeds_to_bag_optimized(player_data, seed_reward, crop_info.get("品质", "普通"))
        
        # 检查升级
        level_up_experience = 100 * player_data["等级"]
        if player_data["经验值"] >= level_up_experience:
            player_data["等级"] += 1
            player_data["经验值"] -= level_up_experience
            self.log('INFO', f"玩家 {username} 升级到 {player_data['等级']} 级", 'SERVER')
        
        # 清理地块（批量更新）
        lot.update({
            "is_planted": False,
            "crop_type": "",
            "grow_time": 0,
            "已浇水": False,
            "已施肥": False
        })
        
        # 清除施肥时间戳
        if "施肥时间" in lot:
            del lot["施肥时间"]
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        # 构建消息
        if will_get_mature_item:
            message = f"收获成功，获得 {mature_item_name} x{harvest_count} 和 {crop_exp} 经验"
        else:
            message = f"收获成功，获得 {crop_exp} 经验（{crop_type}无成熟物产出）"
        
        if seed_reward:
            message += f"，额外获得 {seed_reward['name']} 种子 x{seed_reward['count']}"
        
        self.log('INFO', f"玩家 {username} 从地块 {lot_index} 收获了作物，获得 {crop_type} x{harvest_count} 和 {crop_exp} 经验" + (f"，额外获得 {seed_reward['name']} 种子 x{seed_reward['count']}" if seed_reward else ""), 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "harvest_crop",
            "success": True,
            "message": message,
            "updated_data": {
                "钱币": player_data["钱币"],
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "种子仓库": player_data.get("种子仓库", []),
                "作物仓库": player_data.get("作物仓库", [])
            }
        })
    
    #辅助函数-处理偷菜逻辑（访问模式下收获其他玩家作物的操作）
    def _process_steal_crop_optimized(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, crop_data):
        """处理偷菜逻辑（收益给当前玩家，清空目标玩家的作物）"""
        # 偷菜体力值消耗
        stamina_cost = 1
        
        # 检查并更新当前玩家的体力值
        self._check_and_update_stamina(current_player_data)
        
        # 检查体力值是否足够
        if not self._check_stamina_sufficient(current_player_data, stamina_cost):
            return self._send_action_error(client_id, "harvest_crop", f"体力值不足，偷菜需要 {stamina_cost} 点体力，当前体力：{current_player_data.get('体力值', 0)}")
        
        # 检查是否被巡逻宠物发现（30%概率）
        patrol_pets = target_player_data.get("巡逻宠物", [])
        if patrol_pets and len(patrol_pets) > 0:
            # 先检查是否有免被发现次数
            immunity_count = self._get_steal_immunity_count(current_username, target_username)
            if immunity_count > 0:
                # 有免被发现次数，消耗一次
                self._consume_steal_immunity(current_username, target_username)
                self.log('INFO', f"玩家 {current_username} 使用免被发现次数偷菜 {target_username}，剩余次数：{immunity_count - 1}", 'SERVER')
            else:
                # 30%概率被发现
                import random
                if random.random() <= 0.3:
                    # 被巡逻宠物发现了！
                    return self._handle_steal_caught_by_patrol(
                        client_id, current_player_data, current_username, 
                        target_player_data, target_username, patrol_pets[0]
                    )
        
        # 获取作物类型和基本信息
        crop_type = target_lot["crop_type"]
        crop_info = crop_data.get(crop_type, {})
        
        # 检查是否为杂草类型（杂草不能偷取，只能铲除）
        is_weed = crop_info.get("是否杂草", False)
        if is_weed:
            return self._send_action_error(client_id, "harvest_crop", f"{crop_type}不能偷取，只能铲除！这是杂草，没有收益价值。")
        
        # 额外检查：如果作物收益为负数，也视为杂草
        crop_income = crop_info.get("收益", 100) + crop_info.get("花费", 0)
        if crop_income < 0:
            return self._send_action_error(client_id, "harvest_crop", f"{crop_type}不能偷取，只能铲除！这是杂草，没有收益价值。")
        
        # 获取作物经验（偷菜获得50%经验）
        crop_exp = int(crop_info.get("经验", 10) * 0.5)
        
        # 生成成熟物收获（偷菜获得较少，1-3个）
        import random
        harvest_count = random.randint(1, 3)
        
        # 10%概率获得1-2个该作物的种子（偷菜也有机会获得种子）
        seed_reward = None
        if random.random() <= 0.1:
            seed_reward = {
                "name": crop_type,
                "count": random.randint(1, 2)
            }
        
        # 消耗当前玩家的体力值
        stamina_success, stamina_message = self._consume_stamina(current_player_data, stamina_cost, "偷菜")
        if not stamina_success:
            return self._send_action_error(client_id, "harvest_crop", stamina_message)
        
        # 更新当前玩家数据（获得经验）
        current_player_data["经验值"] += crop_exp
        
        # 检查是否会获得成熟物
        mature_name = crop_info.get("成熟物名称")
        will_get_mature_item = mature_name is not None
        mature_item_name = mature_name if mature_name and mature_name.strip() else crop_type
        
        # 添加成熟物到作物仓库（如果允许）
        if will_get_mature_item:
            self._add_crop_to_warehouse_optimized(current_player_data, {"name": crop_type, "count": harvest_count}, crop_type, crop_info.get("品质", "普通"))
        
        # 添加种子奖励到背包
        if seed_reward:
            self._add_seeds_to_bag_optimized(current_player_data, seed_reward, crop_info.get("品质", "普通"))
        
        # 检查当前玩家升级
        level_up_experience = 100 * current_player_data["等级"]
        if current_player_data["经验值"] >= level_up_experience:
            current_player_data["等级"] += 1
            current_player_data["经验值"] -= level_up_experience
            self.log('INFO', f"玩家 {current_username} 升级到 {current_player_data['等级']} 级", 'SERVER')
        
        # 清理目标玩家的地块（批量更新）
        target_lot.update({
            "is_planted": False,
            "crop_type": "",
            "grow_time": 0,
            "已浇水": False,
            "已施肥": False
        })
        
        # 清除施肥时间戳
        if "施肥时间" in target_lot:
            del target_lot["施肥时间"]
        
        # 保存两个玩家的数据
        self.save_player_data(current_username, current_player_data)
        self.save_player_data(target_username, target_player_data)
        
        # 向目标玩家推送作物更新（如果在线）
        self._push_crop_update_to_player(target_username, target_player_data)
        
        # 构建消息
        if will_get_mature_item:
            message = f"偷菜成功！从 {target_username} 那里获得 {mature_item_name} x{harvest_count} 和 {crop_exp} 经验，{stamina_message}"
        else:
            message = f"偷菜成功！从 {target_username} 那里获得 {crop_exp} 经验，{stamina_message}（{crop_type}无成熟物产出）"
        
        if seed_reward:
            message += f"，额外获得 {seed_reward['name']} 种子 x{seed_reward['count']}"
        
        self.log('INFO', f"玩家 {current_username} 偷了玩家 {target_username} 地块 {lot_index} 的作物，获得 {crop_type} x{harvest_count} 和 {crop_exp} 经验" + (f"，额外获得 {seed_reward['name']} 种子 x{seed_reward['count']}" if seed_reward else ""), 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "harvest_crop",
            "success": True,
            "message": message,
            "updated_data": {
                "钱币": current_player_data["钱币"],
                "经验值": current_player_data["经验值"],
                "等级": current_player_data["等级"],
                "体力值": current_player_data.get("体力系统", {}).get("当前体力值", 20),
                "种子仓库": current_player_data.get("种子仓库", []),
                "作物仓库": current_player_data.get("作物仓库", [])
            }
        })
    
    # 处理偷菜被巡逻宠物发现的情况
    def _handle_steal_caught_by_patrol(self, client_id, current_player_data, current_username, target_player_data, target_username, patrol_pet_id):
        """处理偷菜被巡逻宠物发现的情况"""
        # 检查当前玩家是否有出战宠物
        battle_pets = current_player_data.get("出战宠物", [])
        
        if len(battle_pets) == 0:
            # 没有出战宠物，只能逃跑，支付1000金币
            escape_cost = 1000
            if current_player_data.get("钱币", 0) < escape_cost:
                # 金币不足，偷菜失败
                self.log('INFO', f"玩家 {current_username} 偷菜被发现，金币不足逃跑，偷菜失败", 'SERVER')
                return self.send_data(client_id, {
                    "type": "steal_caught",
                    "success": False,
                    "message": f"偷菜被 {target_username} 的巡逻宠物发现！金币不足支付逃跑费用（需要{escape_cost}金币），偷菜失败！",
                    "patrol_pet_data": self._get_patrol_pet_data(target_player_data, patrol_pet_id),
                    "has_battle_pet": False,
                    "escape_cost": escape_cost,
                    "current_money": current_player_data.get("钱币", 0)
                })
            else:
                # 自动逃跑，扣除金币
                current_player_data["钱币"] -= escape_cost
                target_player_data["钱币"] += escape_cost
                
                # 保存数据
                self.save_player_data(current_username, current_player_data)
                self.save_player_data(target_username, target_player_data)
                
                self.log('INFO', f"玩家 {current_username} 偷菜被发现，支付 {escape_cost} 金币逃跑", 'SERVER')
                return self.send_data(client_id, {
                    "type": "steal_caught",
                    "success": False,
                    "message": f"偷菜被 {target_username} 的巡逻宠物发现！支付了 {escape_cost} 金币逃跑",
                    "patrol_pet_data": self._get_patrol_pet_data(target_player_data, patrol_pet_id),
                    "has_battle_pet": False,
                    "escape_cost": escape_cost,
                    "updated_data": {
                        "钱币": current_player_data["钱币"]
                    }
                })
        else:
            # 有出战宠物，可以选择战斗或逃跑
            battle_pet_id = battle_pets[0]  # 取第一个出战宠物
            
            # 检查出战宠物是否与巡逻宠物是同一个（不应该发生，但保险起见）
            if battle_pet_id == patrol_pet_id:
                self.log('WARNING', f"玩家 {current_username} 的出战宠物与 {target_username} 的巡逻宠物是同一个，这不应该发生", 'SERVER')
                return self._send_action_error(client_id, "harvest_crop", "系统错误：宠物冲突")
            
            self.log('INFO', f"玩家 {current_username} 偷菜被发现，可以选择战斗或逃跑", 'SERVER')
            return self.send_data(client_id, {
                "type": "steal_caught",
                "success": False,
                "message": f"偷菜被 {target_username} 的巡逻宠物发现！",
                "patrol_pet_data": self._get_patrol_pet_data(target_player_data, patrol_pet_id),
                "battle_pet_data": self._get_battle_pet_data(current_player_data, battle_pet_id),
                "has_battle_pet": True,
                "escape_cost": 1000,
                "battle_cost": 1300,
                "target_username": target_username,
                "current_username": current_username
            })
    
    # 获取巡逻宠物数据
    def _get_patrol_pet_data(self, player_data, patrol_pet_id):
        """根据巡逻宠物ID获取完整宠物数据"""
        pet_bag = player_data.get("宠物背包", [])
        for pet in pet_bag:
            if pet.get("pet_id", "") == patrol_pet_id:
                # 添加场景路径
                import copy
                pet_data = copy.deepcopy(pet)
                # 直接从pet_image字段获取场景路径
                scene_path = pet.get("pet_image", "res://Scene/Pet/PetBase.tscn")
                pet_data["场景路径"] = scene_path
                return pet_data
        return None
    
    # 获取出战宠物数据
    def _get_battle_pet_data(self, player_data, battle_pet_id):
        """根据出战宠物ID获取完整宠物数据"""
        pet_bag = player_data.get("宠物背包", [])
        for pet in pet_bag:
            if pet.get("pet_id", "") == battle_pet_id:
                # 添加场景路径
                import copy
                pet_data = copy.deepcopy(pet)
                # 直接从pet_image字段获取场景路径
                scene_path = pet.get("pet_image", "res://Scene/Pet/PetBase.tscn")
                pet_data["场景路径"] = scene_path
                return pet_data
        return None
    
    # 生成收获种子奖励（10%概率获得1-2个种子）
    def _generate_harvest_seed_reward(self, crop_type):
        """生成收获作物时的种子奖励"""
        # 10%概率获得种子
        if random.random() > 0.1:
            return None
        
        # 随机获得1-2个种子
        seed_count = random.randint(1, 2)
        
        return {
            "name": crop_type,
            "count": seed_count
        }
    
    # 添加种子到玩家背包
    def _add_seeds_to_bag(self, player_data, seed_reward):
        """将种子奖励添加到玩家背包"""
        if not seed_reward:
            return
        
        seed_name = seed_reward["name"]
        seed_count = seed_reward["count"]
        
        # 确保背包存在
        if "种子仓库" not in player_data:
            player_data["种子仓库"] = []
        
        # 查找背包中是否已有该种子
        seed_found = False
        for item in player_data["种子仓库"]:
            if item.get("name") == seed_name:
                item["count"] += seed_count
                seed_found = True
                break
        
        # 如果背包中没有该种子，添加新条目
        if not seed_found:
            # 从作物数据获取品质信息
            crop_data = self._load_crop_data()
            quality = "普通"
            if crop_data and seed_name in crop_data:
                quality = crop_data[seed_name].get("品质", "普通")
            
            player_data["种子仓库"].append({
                "name": seed_name,
                "quality": quality,
                "count": seed_count
            })

    # 添加成熟物到玩家作物仓库
    def _add_crop_to_warehouse(self, player_data, crop_harvest):
        """将成熟物添加到玩家作物仓库"""
        if not crop_harvest:
            return
        
        crop_name = crop_harvest["name"]
        crop_count = crop_harvest["count"]
        
        # 从作物数据检查"成熟物名称"字段
        crop_data = self._load_crop_data()
        if crop_data and crop_name in crop_data:
            mature_name = crop_data[crop_name].get("成熟物名称")
            # 如果成熟物名称为null，则不添加成熟物到仓库
            if mature_name is None:
                self.log('DEBUG', f"作物 {crop_name} 的成熟物名称为null，跳过添加到作物仓库", 'SERVER')
                return
            
            # 如果有指定的成熟物名称，使用它作为仓库中的名称
            if mature_name and mature_name.strip():
                warehouse_item_name = mature_name
            else:
                warehouse_item_name = crop_name
        else:
            # 如果作物数据中没有该作物，使用原名称
            warehouse_item_name = crop_name
        
        # 确保作物仓库存在
        if "作物仓库" not in player_data:
            player_data["作物仓库"] = []
        
        # 查找仓库中是否已有该成熟物
        crop_found = False
        for item in player_data["作物仓库"]:
            if item.get("name") == warehouse_item_name:
                item["count"] += crop_count
                crop_found = True
                break
        
        # 如果仓库中没有该成熟物，添加新条目
        if not crop_found:
            # 从作物数据获取品质信息
            quality = "普通"
            if crop_data and crop_name in crop_data:
                quality = crop_data[crop_name].get("品质", "普通")
            
            player_data["作物仓库"].append({
                "name": warehouse_item_name,
                "quality": quality,
                "count": crop_count
            })
    
    # 添加种子到玩家背包（优化版本）
    def _add_seeds_to_bag_optimized(self, player_data, seed_reward, quality="普通"):
        """将种子奖励添加到玩家背包（优化版本）"""
        if not seed_reward:
            return
        
        seed_name = seed_reward["name"]
        seed_count = seed_reward["count"]
        
        # 确保背包存在
        if "种子仓库" not in player_data:
            player_data["种子仓库"] = []
        
        # 查找背包中是否已有该种子
        for item in player_data["种子仓库"]:
            if item.get("name") == seed_name:
                item["count"] += seed_count
                return
        
        # 如果背包中没有该种子，添加新条目
        player_data["种子仓库"].append({
            "name": seed_name,
            "quality": quality,
            "count": seed_count
        })

    # 添加成熟物到玩家作物仓库（优化版本）
    def _add_crop_to_warehouse_optimized(self, player_data, crop_harvest, warehouse_item_name, quality="普通"):
        """将成熟物添加到玩家作物仓库（优化版本）"""
        if not crop_harvest:
            return
        
        crop_count = crop_harvest["count"]
        
        # 确保作物仓库存在
        if "作物仓库" not in player_data:
            player_data["作物仓库"] = []
        
        # 查找仓库中是否已有该成熟物
        for item in player_data["作物仓库"]:
            if item.get("name") == warehouse_item_name:
                item["count"] += crop_count
                return
        
        # 如果仓库中没有该成熟物，添加新条目
        player_data["作物仓库"].append({
            "name": warehouse_item_name,
            "quality": quality,
            "count": crop_count
        })

#==========================收获作物处理==========================



#==========================杂草生长处理==========================
    # 定期检查并生长杂草
    def check_and_grow_weeds(self):
        """检查所有玩家的离线时间，并在长时间离线玩家的空地上随机生长杂草"""
        try:
            self.log('INFO', "开始检查杂草生长...", 'SERVER')
            current_time = time.time()
            affected_players = 0
            total_weeds_added = 0
            
            # 获取作物数据以验证杂草类型
            crop_data = self._load_crop_data()
            if not crop_data:
                self.log('ERROR', "无法加载作物数据，跳过杂草检查", 'SERVER')
                return
            
            # 可用的杂草类型（从作物数据中筛选标记为杂草的作物）
            available_weeds = []
            for crop_name, crop_info in crop_data.items():
                if crop_info.get("是否杂草", False):
                    available_weeds.append(crop_name)
            
            if not available_weeds:
                self.log('WARNING', "没有找到可用的杂草类型，跳过杂草检查", 'SERVER')
                return
            
            # 优先使用MongoDB获取离线玩家
            if self.use_mongodb and self.mongo_api:
                offline_players = self.mongo_api.get_offline_players(self.offline_threshold_days)
                
                for player_data in offline_players:
                    account_id = player_data.get("玩家账号")
                    if not account_id:
                        continue
                    
                    try:
                        # 获取完整玩家数据
                        full_player_data = self.mongo_api.get_player_data(account_id)
                        if not full_player_data:
                            continue
                        
                        # 为该玩家的空地生长杂草
                        weeds_added = self._grow_weeds_for_player(full_player_data, account_id, available_weeds)
                        if weeds_added > 0:
                            affected_players += 1
                            total_weeds_added += weeds_added
                            # 保存玩家数据
                            self.mongo_api.save_player_data(account_id, full_player_data)
                            
                    except Exception as e:
                        self.log('ERROR', f"处理玩家 {account_id} 的杂草生长时出错: {str(e)}", 'SERVER')
                        continue
            else:
                # 降级到文件系统
                game_saves_dir = "game_saves"
                if not os.path.exists(game_saves_dir):
                    return
                
                # 遍历所有玩家文件
                for filename in os.listdir(game_saves_dir):
                    if not filename.endswith('.json'):
                        continue
                    
                    account_id = filename[:-5]  # 移除.json后缀
                    
                    try:
                        # 加载玩家数据
                        player_data = self.load_player_data(account_id)
                        if not player_data:
                            continue
                        
                        # 检查玩家是否长时间离线
                        if self._is_player_long_offline(player_data, current_time):
                            # 为该玩家的空地生长杂草
                            weeds_added = self._grow_weeds_for_player(player_data, account_id, available_weeds)
                            if weeds_added > 0:
                                affected_players += 1
                                total_weeds_added += weeds_added
                                # 保存玩家数据
                                self.save_player_data(account_id, player_data)
                                
                    except Exception as e:
                        self.log('ERROR', f"处理玩家 {account_id} 的杂草生长时出错: {str(e)}", 'SERVER')
                        continue
            
            self.log('INFO', f"杂草检查完成，共为 {affected_players} 个玩家的农场添加了 {total_weeds_added} 个杂草", 'SERVER')
            
        except Exception as e:
            self.log('ERROR', f"杂草生长检查过程中出错: {str(e)}", 'SERVER')

    #检查玩家是否长时间不在线
    def _is_player_long_offline(self, player_data, current_time):
        """检查玩家是否长时间离线"""
        # 获取玩家最后登录时间
        last_login_time_str = player_data.get("最后登录时间", "")
        if not last_login_time_str:
            return False
        
        try:
            # 解析最后登录时间戳
            last_login_timestamp = self._parse_login_time_to_timestamp(last_login_time_str)
            if last_login_timestamp is None:
                return False
            
            # 计算离线天数
            offline_seconds = current_time - last_login_timestamp
            offline_days = offline_seconds / 86400  # 转换为天数
            
            return offline_days >= self.offline_threshold_days
            
        except Exception as e:
            self.log('ERROR', f"解析玩家登录时间时出错: {str(e)}", 'SERVER')
            return False

    #为指定玩家的空地生长杂草
    def _grow_weeds_for_player(self, player_data, account_id, available_weeds):
        """为指定玩家的空地生长杂草"""
        import random
        
        farm_lots = player_data.get("农场土地", [])
        if not farm_lots:
            return 0
        
        # 找到所有空的已开垦地块
        empty_lots = []
        for i, lot in enumerate(farm_lots):
            if (lot.get("is_diged", False) and 
                not lot.get("is_planted", False) and 
                lot.get("crop_type", "") == ""):
                empty_lots.append(i)
        
        if not empty_lots:
            return 0
        
        # 随机选择要长杂草的地块数量
        max_weeds = min(self.max_weeds_per_check, len(empty_lots))
        weeds_to_add = random.randint(1, max_weeds)
        
        # 随机选择地块
        selected_lots = random.sample(empty_lots, weeds_to_add)
        weeds_added = 0
        
        crop_data = self._load_crop_data()
        
        for lot_index in selected_lots:
            # 按概率决定是否在这个地块长杂草
            if random.random() < self.weed_growth_probability:
                # 随机选择杂草类型
                weed_type = random.choice(available_weeds)
                weed_info = crop_data.get(weed_type, {})
                
                # 在地块上种植杂草
                lot = farm_lots[lot_index]
                lot["is_planted"] = True
                lot["crop_type"] = weed_type
                lot["grow_time"] = weed_info.get("生长时间", 5)  # 杂草立即成熟
                lot["max_grow_time"] = weed_info.get("生长时间", 5)
                lot["已浇水"] = False
                lot["已施肥"] = False
                
                weeds_added += 1
        
        if weeds_added > 0:
            self.log('INFO', f"为玩家 {account_id} 的农场添加了 {weeds_added} 个杂草", 'SERVER')
        
        return weeds_added

#==========================杂草生长处理==========================



#==========================偷菜免被发现计数器管理==========================
    # 玩家免被发现计数器结构：{player_name: {target_player_name: count, ...}, ...}
    def _get_steal_immunity_count(self, player_name, target_player_name):
        """获取玩家对目标玩家的免被发现次数"""
        return self.steal_immunity_counters.get(player_name, {}).get(target_player_name, 0)

    #消耗一次免被发现次数
    def _consume_steal_immunity(self, player_name, target_player_name):
        """消耗一次免被发现次数"""
        if player_name not in self.steal_immunity_counters:
            return False
        
        if target_player_name not in self.steal_immunity_counters[player_name]:
            return False
        
        if self.steal_immunity_counters[player_name][target_player_name] > 0:
            self.steal_immunity_counters[player_name][target_player_name] -= 1
            
            # 如果计数器归零，清理该条目
            if self.steal_immunity_counters[player_name][target_player_name] == 0:
                del self.steal_immunity_counters[player_name][target_player_name]
                
                # 如果该玩家没有其他计数器，清理玩家条目
                if not self.steal_immunity_counters[player_name]:
                    del self.steal_immunity_counters[player_name]
            
            return True
        
        return False

    #设置免被发现次数（默认3次）
    def _set_steal_immunity(self, player_name, target_player_name, count=3):
        """设置玩家对目标玩家的免被发现次数"""
        if player_name not in self.steal_immunity_counters:
            self.steal_immunity_counters[player_name] = {}
        
        self.steal_immunity_counters[player_name][target_player_name] = count
        self.log('INFO', f"为玩家 {player_name} 设置对 {target_player_name} 的免被发现次数: {count}", 'SERVER')

    #清理免被发现计数器
    def _clear_player_steal_immunity(self, player_name):
        """清理玩家的所有免被发现计数器"""
        if player_name in self.steal_immunity_counters:
            del self.steal_immunity_counters[player_name]
            self.log('INFO', f"清理玩家 {player_name} 的所有免被发现计数器", 'SERVER')

    #清理特定目标的免被发现计数器
    def _clear_target_steal_immunity(self, player_name, target_player_name):
        """清理玩家对特定目标的免被发现计数器"""
        if player_name in self.steal_immunity_counters:
            if target_player_name in self.steal_immunity_counters[player_name]:
                del self.steal_immunity_counters[player_name][target_player_name]
                
                # 如果该玩家没有其他计数器，清理玩家条目
                if not self.steal_immunity_counters[player_name]:
                    del self.steal_immunity_counters[player_name]
                
                self.log('INFO', f"清理玩家 {player_name} 对 {target_player_name} 的免被发现计数器", 'SERVER')

#==========================偷菜免被发现计数器管理==========================



#==========================种植作物处理==========================
    #处理种植作物请求 
    def _handle_plant_crop(self, client_id, message):
        """处理种植作物请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "种植作物", "plant_crop")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "plant_crop")
        if not player_data:
            return self.send_data(client_id, response)
        
        lot_index = message.get("lot_index", -1)
        crop_name = message.get("crop_name", "")
        
        # 验证参数
        if lot_index < 0 or lot_index >= len(player_data.get("农场土地", [])):
            return self._send_action_error(client_id, "plant_crop", "无效的地块索引")
        
        lot = player_data["农场土地"][lot_index]
        
        # 检查地块状态
        if not lot.get("is_diged", False):
            return self._send_action_error(client_id, "plant_crop", "此地块尚未开垦")
        
        if lot.get("is_planted", False):
            return self._send_action_error(client_id, "plant_crop", "此地块已经种植了作物")
        
        # 处理种植
        return self._process_planting(client_id, player_data, username, lot, crop_name)
    
    #辅助函数-处理作物种植逻辑
    def _process_planting(self, client_id, player_data, username, lot, crop_name):
        """处理作物种植逻辑"""
        # 读取作物配置
        crop_data = self._load_crop_data()
        
        # 检查玩家背包中是否有此种子
        seed_found = False
        seed_index = -1
        
        for i, item in enumerate(player_data.get("种子仓库", [])):
            if item.get("name") == crop_name:
                seed_found = True
                seed_index = i
                break
        
        if not seed_found:
            return self._send_action_error(client_id, "plant_crop", "背包中没有此种子")
        
        # 获取作物生长时间
        if crop_name in crop_data:
            grow_time = crop_data[crop_name].get("生长时间", 600)
        else:
            grow_time = 600
        
        # 从背包中减少种子数量
        player_data["种子仓库"][seed_index]["count"] -= 1
        
        # 如果种子用完，从背包中移除
        if player_data["种子仓库"][seed_index]["count"] <= 0:
            player_data["种子仓库"].pop(seed_index)
        
        # 更新地块数据
        lot.update({
            "is_planted": True,
            "crop_type": crop_name,
            "grow_time": 0,
            "max_grow_time": grow_time,
            "is_dead": False,
            "已浇水": False,
            "已施肥": False
        })
        
        # 清除施肥时间戳
        if "施肥时间" in lot:
            del lot["施肥时间"]
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        self.log('INFO', f"玩家 {username} 种植了 {crop_name}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "plant_crop",
            "success": True,
            "message": f"成功种植 {crop_name}",
            "updated_data": {
                "种子仓库": player_data["种子仓库"]
            }
        })
#==========================种植作物处理==========================




#==========================购买种子处理==========================
    #处理购买种子请求
    def _handle_buy_seed(self, client_id, message):
        """处理购买种子请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "购买种子", "buy_seed")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "buy_seed")
        if not player_data:
            return self.send_data(client_id, response)
        
        crop_name = message.get("crop_name", "")
        quantity = max(1, int(message.get("quantity", 1)))  # 确保购买数量为正整数
        
        # 加载作物配置
        crop_data = self._load_crop_data()
        if not crop_data:
            return self._send_action_error(client_id, "buy_seed", "服务器无法加载作物数据")
        
        # 检查作物是否存在
        if crop_name not in crop_data:
            return self._send_action_error(client_id, "buy_seed", "该种子不存在")
        
        # 处理批量购买
        return self._process_seed_purchase(client_id, player_data, username, crop_name, crop_data[crop_name], quantity)
    
    #处理种子购买逻辑
    def _process_seed_purchase(self, client_id, player_data, username, crop_name, crop, quantity=1):
        """处理种子购买逻辑"""
        # 检查玩家等级
        player_level = int(player_data.get("等级", 1))
        required_level = int(crop.get("等级", 1))
        if player_level < required_level:
            return self._send_action_error(client_id, "buy_seed", "等级不足，无法购买此种子")
        
        # 计算总花费
        unit_cost = crop.get("花费", 0)
        total_cost = unit_cost * quantity
        
        # 检查玩家金钱
        if player_data["钱币"] < total_cost:
            return self._send_action_error(client_id, "buy_seed", f"金钱不足，无法购买此种子。需要{total_cost}元，当前只有{player_data['钱币']}元")
        
        # 扣除金钱
        player_data["钱币"] -= total_cost
        
        # 将种子添加到背包
        seed_found = False
        
        for item in player_data.get("种子仓库", []):
            if item.get("name") == crop_name:
                item["count"] += quantity
                seed_found = True
                break
        
        if not seed_found:
            if "种子仓库" not in player_data:
                player_data["种子仓库"] = []
                
            player_data["种子仓库"].append({
                "name": crop_name,
                "quality": crop.get("品质", "普通"),
                "count": quantity
            })
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        self.log('INFO', f"玩家 {username} 购买了 {quantity} 个种子 {crop_name}，花费 {total_cost} 元", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "buy_seed",
            "success": True,
            "message": f"成功购买 {quantity} 个 {crop_name} 种子",
            "updated_data": {
                "钱币": player_data["钱币"],
                "种子仓库": player_data["种子仓库"]
            }
        })
    
#==========================购买种子处理==========================



#==========================购买宠物处理==========================
    #处理购买宠物请求
    def _handle_buy_pet(self, client_id, message):
        """处理购买宠物请求"""
        # 检查用户登录状态
        logged_in, response = self._check_user_logged_in(client_id, "购买宠物", "buy_pet")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "buy_pet")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 获取请求参数
        pet_name = message.get("pet_name", "")
        pet_cost = message.get("pet_cost", 0)
        
        # 验证宠物购买条件
        validation_result = self._validate_pet_purchase(pet_name, pet_cost, player_data)
        if not validation_result["success"]:
            return self._send_action_error(client_id, "buy_pet", validation_result["message"])
        
        # 处理宠物购买
        return self._process_pet_purchase(client_id, player_data, username, pet_name, validation_result["pet_info"])

    #验证宠物购买条件
    def _validate_pet_purchase(self, pet_name, pet_cost, player_data):
        """验证宠物购买条件"""
        # 加载宠物配置
        pet_config = self._load_pet_config()
        if not pet_config:
            return {"success": False, "message": "服务器无法加载宠物数据"}
        
        # 检查宠物是否存在
        if pet_name not in pet_config:
            return {"success": False, "message": "该宠物不存在"}
        
        pet_info = pet_config[pet_name]
        
        # 从配置中获取宠物价格
        actual_cost = pet_info.get("cost", 1000)  # 默认价格1000
        if pet_cost != actual_cost:
            return {"success": False, "message": f"宠物价格验证失败，实际价格为{actual_cost}元"}
        
        # 检查玩家是否已拥有该宠物
        if self._player_has_pet(player_data, pet_name):
            return {"success": False, "message": f"你已经拥有 {pet_name} 了！"}
        
        return {"success": True, "pet_info": pet_info}
    
    #处理宠物购买逻辑
    def _process_pet_purchase(self, client_id, player_data, username, pet_name, pet_info):
        """处理宠物购买逻辑"""
        pet_cost = pet_info.get("cost", 1000)  # 从配置中获取价格，默认1000
        
        # 检查玩家金钱
        if player_data["钱币"] < pet_cost:
            return self._send_action_error(client_id, "buy_pet", 
                f"金钱不足，无法购买此宠物。需要{pet_cost}元，当前只有{player_data['钱币']}元")
        
        # 扣除金钱并添加宠物
        player_data["钱币"] -= pet_cost
        pet_instance = self._create_pet_instance(pet_info, username, pet_name)
        
        # 确保宠物背包存在并添加宠物
        if "宠物背包" not in player_data:
            player_data["宠物背包"] = []
        player_data["宠物背包"].append(pet_instance)
        
        # 保存数据并返回响应
        self.save_player_data(username, player_data)
        self.log('INFO', f"玩家 {username} 购买了宠物 {pet_name}，花费 {pet_cost} 元", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "buy_pet",
            "success": True,
            "message": f"成功购买宠物 {pet_name}！",
            "updated_data": {
                "钱币": player_data["钱币"],
                "宠物背包": player_data["宠物背包"]
            }
        })

    #创建宠物实例
    def _create_pet_instance(self, pet_info, username, pet_name):
        """创建宠物实例"""
        import copy
        import time
        import datetime
        
        # 复制宠物配置数据
        pet_instance = copy.deepcopy(pet_info)
        
        # 生成唯一ID和设置基本信息
        unique_id = str(int(time.time() * 1000))
        now = datetime.datetime.now()
        birthday = f"{now.year}-{now.month:02d}-{now.day:02d}"
        
        # 新格式：直接在根级别设置属性
        pet_instance.update({
            "pet_id": unique_id,
            "pet_name": f"{username}的{pet_name}",
            "pet_birthday": birthday,
            "pet_owner": username
        })
        
        # 初始化当前生命值为最大生命值
        max_health = pet_instance.get("max_health", 100)
        pet_instance["pet_current_health"] = max_health
        
        return pet_instance
    
    #检查玩家是否已拥有某种宠物
    def _player_has_pet(self, player_data, pet_name):
        """检查玩家是否已拥有指定类型的宠物"""
        pet_bag = player_data.get("宠物背包", [])
        for pet in pet_bag:
            pet_type = pet.get("pet_type", "")
            if pet_type == pet_name:
                return True
        return False
    
    #加载宠物配置数据
    def _load_pet_config(self):
        """从MongoDB加载宠物配置数据"""
        try:
            if not hasattr(self, 'mongo_api') or not self.mongo_api:
                self.log('ERROR', 'MongoDB未配置或不可用，无法加载宠物配置数据', 'SERVER')
                return {}
                
            config = self.mongo_api.get_pet_config()
            if config:
                self.log('INFO', "成功从MongoDB加载宠物配置", 'SERVER')
                return config
            else:
                self.log('ERROR', "MongoDB中未找到宠物配置", 'SERVER')
                return {}
                
        except Exception as e:
            self.log('ERROR', f"从MongoDB加载宠物配置失败: {str(e)}", 'SERVER')
            return {}

    #加载游戏小提示配置数据
    def _load_game_tips_config(self):
        """从MongoDB加载游戏小提示配置数据"""
        try:
            if not hasattr(self, 'mongo_api') or not self.mongo_api:
                self.log('ERROR', 'MongoDB未配置或不可用，无法加载游戏小提示配置数据', 'SERVER')
                return {}
                
            config = self.mongo_api.get_game_tips_config()
            if config:
                self.log('INFO', "成功从MongoDB加载游戏小提示配置", 'SERVER')
                return config
            else:
                self.log('ERROR', "MongoDB中未找到游戏小提示配置", 'SERVER')
                return {}
                
        except Exception as e:
            self.log('ERROR', f"从MongoDB加载游戏小提示配置失败: {str(e)}", 'SERVER')
            return {}
    
    # 将巡逻宠物ID转换为完整宠物数据
    def _convert_patrol_pets_to_full_data(self, player_data):
        """将存储的巡逻宠物ID转换为完整的宠物数据"""
        patrol_pets_data = []
        patrol_pets_ids = player_data.get("巡逻宠物", [])
        pet_bag = player_data.get("宠物背包", [])
        
        for patrol_pet_id in patrol_pets_ids:
            for pet in pet_bag:
                if pet.get("pet_id", "") == patrol_pet_id:
                    # 为巡逻宠物添加场景路径
                    import copy
                    patrol_pet_data = copy.deepcopy(pet)
                    
                    # 直接从pet_image字段获取场景路径
                    scene_path = pet.get("pet_image", "")
                    patrol_pet_data["场景路径"] = scene_path
                    
                    patrol_pets_data.append(patrol_pet_data)
                    break
        
        return patrol_pets_data
    
    # 将出战宠物ID转换为完整宠物数据
    def _convert_battle_pets_to_full_data(self, player_data):
        """将存储的出战宠物ID转换为完整的宠物数据"""
        battle_pets_data = []
        battle_pets_ids = player_data.get("出战宠物", [])
        pet_bag = player_data.get("宠物背包", [])
        
        for battle_pet_id in battle_pets_ids:
            for pet in pet_bag:
                if pet.get("pet_id", "") == battle_pet_id:
                    # 为出战宠物添加场景路径
                    import copy
                    battle_pet_data = copy.deepcopy(pet)
                    
                    # 直接从pet_image字段获取场景路径
                    scene_path = pet.get("pet_image", "")
                    battle_pet_data["场景路径"] = scene_path
                    
                    battle_pets_data.append(battle_pet_data)
                    break
        
        return battle_pets_data
#==========================购买宠物处理==========================


#==========================重命名宠物处理==========================
    #处理重命名宠物请求
    def _handle_rename_pet(self, client_id, message):
        """处理重命名宠物请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "重命名宠物", "rename_pet")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "rename_pet")
        if not player_data:
            return self.send_data(client_id, response)
        
        pet_id = message.get("pet_id", "")
        new_name = message.get("new_name", "")
        
        # 验证参数
        if not pet_id:
            return self._send_action_error(client_id, "rename_pet", "宠物ID不能为空")
        
        if not new_name:
            return self._send_action_error(client_id, "rename_pet", "宠物名字不能为空")
        
        # 验证名字长度
        if len(new_name) > 20:
            return self._send_action_error(client_id, "rename_pet", "宠物名字太长，最多20个字符")
        
        # 检查宠物是否存在
        pet_bag = player_data.get("宠物背包", [])
        pet_found = False
        
        for pet in pet_bag:
            if pet.get("pet_id", "") == pet_id:
                # 检查宠物主人是否正确
                if pet.get("pet_owner", "") != username:
                    return self._send_action_error(client_id, "rename_pet", "你不是该宠物的主人")
                
                # 更新宠物名字
                pet["pet_name"] = new_name
                pet_found = True
                break
        
        if not pet_found:
            return self._send_action_error(client_id, "rename_pet", "未找到指定ID的宠物")
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        self.log('INFO', f"玩家 {username} 重命名宠物 {pet_id} 为 {new_name}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "rename_pet",
            "success": True,
            "message": f"宠物名字已成功修改为 {new_name}",
            "pet_id": pet_id,
            "new_name": new_name,
            "updated_data": {
                "宠物背包": player_data["宠物背包"]
            }
        })
#==========================重命名宠物处理==========================


#==========================设置巡逻宠物处理==========================
    #处理设置巡逻宠物请求
    def _handle_set_patrol_pet(self, client_id, message):
        """处理设置或取消巡逻宠物的请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "设置巡逻宠物", "set_patrol_pet")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "set_patrol_pet")
        if not player_data:
            return self.send_data(client_id, response)
        
        pet_id = message.get("pet_id", "")
        is_patrolling = message.get("is_patrolling", False)
        
        self.log('INFO', f"处理巡逻宠物请求: pet_id={pet_id}, is_patrolling={is_patrolling}", client_id)
        
        # 验证参数
        if not pet_id:
            return self._send_action_error(client_id, "set_patrol_pet", "宠物ID不能为空")
        
        # 获取宠物背包和巡逻宠物列表
        pet_bag = player_data.get("宠物背包", [])
        patrol_pets = player_data.get("巡逻宠物", [])
        
        # 查找目标宠物
        target_pet = None
        for pet in pet_bag:
            if pet.get("pet_id", "") == pet_id:
                target_pet = pet
                break
        
        if not target_pet:
            return self._send_action_error(client_id, "set_patrol_pet", "未找到指定的宠物")
        
        # 检查宠物主人是否正确
        if target_pet.get("pet_owner", "") != username:
            return self._send_action_error(client_id, "set_patrol_pet", "你不是该宠物的主人")
        
        pet_name = target_pet.get("pet_name", target_pet.get("pet_type", "未知宠物"))
        
        if is_patrolling:
            # 添加到巡逻列表
            # 检查巡逻宠物数量限制（最多4个）
            if len(patrol_pets) >= 4:
                return self._send_action_error(client_id, "set_patrol_pet", "最多只能设置4个巡逻宠物")
            
            # 检查是否已在巡逻列表中（现在只检查ID）
            for patrol_pet_id in patrol_pets:
                if patrol_pet_id == pet_id:
                    return self._send_action_error(client_id, "set_patrol_pet", f"{pet_name} 已在巡逻列表中")
            
            # 添加到巡逻列表（只保存宠物ID）
            patrol_pets.append(pet_id)
            message_text = f"{pet_name} 已设置为巡逻宠物"
            self.log('INFO', f"玩家 {username} 设置宠物 {pet_name} 为巡逻宠物", 'SERVER')
            
        else:
            # 从巡逻列表移除
            original_count = len(patrol_pets)
            patrol_pets = [pid for pid in patrol_pets if pid != pet_id]
            
            if len(patrol_pets) == original_count:
                return self._send_action_error(client_id, "set_patrol_pet", f"{pet_name} 不在巡逻列表中")
            
            message_text = f"{pet_name} 已取消巡逻"
            self.log('INFO', f"玩家 {username} 取消宠物 {pet_name} 的巡逻", 'SERVER')
        
        # 更新玩家数据
        player_data["巡逻宠物"] = patrol_pets
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 构建返回给客户端的巡逻宠物数据（完整宠物数据）
        patrol_pets_data = []
        for patrol_pet_id in patrol_pets:
            for pet in pet_bag:
                if pet.get("pet_id", "") == patrol_pet_id:
                    # 为巡逻宠物添加场景路径
                    import copy
                    patrol_pet_data = copy.deepcopy(pet)
                    
                    # 新格式中场景路径已经在pet_image字段中
                    if "pet_image" in pet:
                        patrol_pet_data["scene_path"] = pet["pet_image"]
                    
                    patrol_pets_data.append(patrol_pet_data)
                    break
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "set_patrol_pet",
            "success": True,
            "message": message_text,
            "pet_id": pet_id,
            "is_patrolling": is_patrolling,
            "updated_data": {
                "巡逻宠物": patrol_pets_data
            }
        })
#==========================设置巡逻宠物处理==========================


#==========================设置出战宠物处理==========================
    #处理设置出战宠物请求
    def _handle_set_battle_pet(self, client_id, message):
        """处理设置出战宠物请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "设置出战宠物", "set_battle_pet")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "set_battle_pet")
        if not player_data:
            return self.send_data(client_id, response)
        
        pet_id = message.get("pet_id", "")
        is_battle = message.get("is_battle", True)  # 默认为设置出战
        
        if not pet_id:
            return self._send_action_error(client_id, "set_battle_pet", "宠物ID不能为空")
        
        # 获取宠物背包和出战宠物列表
        pet_bag = player_data.get("宠物背包", [])
        battle_pets = player_data.get("出战宠物", [])
        patrol_pets = player_data.get("巡逻宠物", [])
        
        # 查找宠物是否在背包中
        target_pet = None
        for pet in pet_bag:
            if pet.get("pet_id", "") == pet_id:
                target_pet = pet
                break
        
        if not target_pet:
            return self._send_action_error(client_id, "set_battle_pet", f"宠物背包中找不到ID为 {pet_id} 的宠物")
        
        pet_name = target_pet.get("pet_name", "未知宠物")
        
        if is_battle:
            # 添加到出战列表
            # 检查是否已在出战列表中
            if pet_id in battle_pets:
                return self._send_action_error(client_id, "set_battle_pet", f"{pet_name} 已在出战列表中")
            
            # 检查是否在巡逻列表中（出战宠物不能是巡逻宠物）
            if pet_id in patrol_pets:
                return self._send_action_error(client_id, "set_battle_pet", f"{pet_name} 正在巡逻，不能同时设置为出战宠物")
            
            # 检查出战宠物数量限制（最多4个）
            if len(battle_pets) >= 4:
                return self._send_action_error(client_id, "set_battle_pet", "最多只能设置4个出战宠物")
            
            # 添加到出战列表
            battle_pets.append(pet_id)
            message_text = f"{pet_name} 已设置为出战宠物"
            self.log('INFO', f"玩家 {username} 设置宠物 {pet_name} 为出战宠物", 'SERVER')
            
        else:
            # 从出战列表移除
            if pet_id not in battle_pets:
                return self._send_action_error(client_id, "set_battle_pet", f"{pet_name} 不在出战列表中")
            
            battle_pets.remove(pet_id)
            message_text = f"{pet_name} 已移除出战状态"
            self.log('INFO', f"玩家 {username} 移除宠物 {pet_name} 的出战状态", 'SERVER')
        
        # 更新玩家数据
        player_data["出战宠物"] = battle_pets
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 构建返回给客户端的出战宠物数据（完整宠物数据）
        battle_pets_data = []
        for battle_pet_id in battle_pets:
            for pet in pet_bag:
                if pet.get("pet_id", "") == battle_pet_id:
                    # 为出战宠物添加场景路径
                    import copy
                    battle_pet_data = copy.deepcopy(pet)
                    
                    # 新格式中场景路径已经在pet_image字段中
                    if "pet_image" in pet:
                        battle_pet_data["scene_path"] = pet["pet_image"]
                    
                    battle_pets_data.append(battle_pet_data)
                    break
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "set_battle_pet",
            "success": True,
            "message": message_text,
            "pet_id": pet_id,
            "is_battle": is_battle,
            "updated_data": {
                "出战宠物": battle_pets_data
            }
        })
#==========================设置出战宠物处理==========================


#==========================更新宠物对战数据处理==========================
    #处理更新宠物对战数据请求
    def _handle_update_battle_pet_data(self, client_id, message):
        """处理更新宠物对战数据请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "更新宠物对战数据", "update_battle_pet_data")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取请求参数
        pet_id = message.get("pet_id", "")
        attacker_name = message.get("attacker_name", "")
        exp_gained = message.get("exp_gained", 0)
        intimacy_gained = message.get("intimacy_gained", 0)
        new_level = message.get("new_level", 1)
        new_experience = message.get("new_experience", 0)
        new_max_experience = message.get("new_max_experience", 100)
        new_intimacy = message.get("new_intimacy", 0)
        level_ups = message.get("level_ups", 0)
        level_bonus_multiplier = message.get("level_bonus_multiplier", 1.0)
        is_steal_battle = message.get("is_steal_battle", False)
        battle_winner = message.get("battle_winner", "")
        
        if not pet_id or not attacker_name:
            return self._send_action_error(client_id, "update_battle_pet_data", "无效的宠物ID或进攻者名称")
        
        # 获取进攻者玩家数据
        player_data = self.load_player_data(attacker_name)
        if not player_data:
            return self._send_action_error(client_id, "update_battle_pet_data", "无法找到进攻者数据")
        
        # 更新宠物数据
        success = self._update_pet_battle_data(player_data, pet_id, exp_gained, intimacy_gained, 
                                               new_level, new_experience, new_max_experience, 
                                               new_intimacy, level_ups, level_bonus_multiplier)
        
        if success:
            # 检查是否是偷菜对战且玩家获胜，如果是则设置免被发现计数器
            if is_steal_battle and battle_winner == "team1":
                # 获取当前访问的目标玩家名称（从客户端连接信息中获取）
                target_player_name = self.user_data.get(client_id, {}).get("visiting_target", "")
                if target_player_name:
                    self._set_steal_immunity(attacker_name, target_player_name, 3)
                    self.log('INFO', f"玩家 {attacker_name} 战胜巡逻宠物，获得对 {target_player_name} 的3次免被发现机会", 'SERVER')
            
            # 保存玩家数据
            self.save_player_data(attacker_name, player_data)
            
            self.log('INFO', f"成功更新玩家 {attacker_name} 的宠物 {pet_id} 对战数据：经验+{exp_gained}，亲密度+{intimacy_gained}，升级{level_ups}级", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "action_response",
                "action_type": "update_battle_pet_data",
                "success": True,
                "message": f"成功更新宠物对战数据",
                "pet_id": pet_id,
                "exp_gained": exp_gained,
                "intimacy_gained": intimacy_gained,
                "level_ups": level_ups
            })
        else:
            return self._send_action_error(client_id, "update_battle_pet_data", f"无法找到宠物ID为 {pet_id} 的宠物")

    #辅助函数-更新宠物对战数据
    def _update_pet_battle_data(self, player_data, pet_id, exp_gained, intimacy_gained, 
                                new_level, new_experience, new_max_experience, 
                                new_intimacy, level_ups, level_bonus_multiplier):
        """更新宠物对战数据"""
        
        # 确保宠物背包存在
        if "宠物背包" not in player_data:
            player_data["宠物背包"] = []
        
        # 查找指定宠物
        target_pet = None
        for pet in player_data["宠物背包"]:
            if pet.get("pet_id") == pet_id:
                target_pet = pet
                break
        
        if not target_pet:
            return False
        
        # 更新等级经验数据
        target_pet["pet_level"] = new_level
        target_pet["pet_experience"] = new_experience
        target_pet["pet_max_experience"] = new_max_experience
        target_pet["pet_intimacy"] = new_intimacy
        
        # 如果有升级，更新属性
        if level_ups > 0:
            # 计算升级后的属性（每级10%加成）
            old_max_health = target_pet.get("pet_max_health", 100.0)
            old_max_armor = target_pet.get("pet_max_armor", 100.0)
            old_attack_damage = target_pet.get("pet_attack_damage", 20.0)
            
            # 应用升级加成
            new_max_health = old_max_health * level_bonus_multiplier
            new_max_armor = old_max_armor * level_bonus_multiplier
            new_attack_damage = old_attack_damage * level_bonus_multiplier
            
            target_pet["pet_max_health"] = new_max_health
            target_pet["pet_current_health"] = new_max_health  # 升级回满血
            target_pet["pet_max_armor"] = new_max_armor
            target_pet["pet_current_armor"] = new_max_armor  # 升级回满护甲
            target_pet["pet_attack_damage"] = new_attack_damage
        
        return True
#==========================更新宠物对战数据处理==========================


#==========================宠物喂食处理==========================
    #处理宠物喂食请求
    def _handle_feed_pet(self, client_id, message):
        """处理宠物喂食请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "宠物喂食", "feed_pet")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "feed_pet")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 获取请求参数
        pet_id = message.get("pet_id", "")
        crop_name = message.get("crop_name", "")
        feed_effects = message.get("feed_effects", {})
        
        # 验证参数
        if not pet_id:
            return self._send_action_error(client_id, "feed_pet", "宠物ID不能为空")
        
        if not crop_name:
            return self._send_action_error(client_id, "feed_pet", "作物名称不能为空")
        
        # 检查玩家是否有该作物
        crop_warehouse = player_data.get("作物仓库", [])
        crop_found = False
        crop_index = -1
        
        for i, crop_item in enumerate(crop_warehouse):
            if crop_item.get("name") == crop_name:
                if crop_item.get("count", 0) > 0:
                    crop_found = True
                    crop_index = i
                    break
        
        if not crop_found:
            return self._send_action_error(client_id, "feed_pet", f"没有足够的{crop_name}用于喂食")
        
        # 检查宠物是否存在
        pet_bag = player_data.get("宠物背包", [])
        target_pet = None
        
        for pet in pet_bag:
            if pet.get("pet_id", "") == pet_id:
                # 检查宠物主人是否正确
                if pet.get("pet_owner", "") != username:
                    return self._send_action_error(client_id, "feed_pet", "你不是该宠物的主人")
                target_pet = pet
                break
        
        if not target_pet:
            return self._send_action_error(client_id, "feed_pet", "未找到指定的宠物")
        
        # 验证作物是否有喂养效果
        crop_data = self._load_crop_data()
        if crop_name not in crop_data or "喂养效果" not in crop_data[crop_name]:
            return self._send_action_error(client_id, "feed_pet", f"{crop_name}没有喂养效果")
        
        # 获取作物的喂养效果
        crop_feed_effects = crop_data[crop_name]["喂养效果"]
        
        # 执行喂食
        success, applied_effects = self._process_pet_feeding(player_data, target_pet, crop_name, crop_index, crop_feed_effects)
        
        if success:
            # 保存玩家数据
            self.save_player_data(username, player_data)
            
            pet_name = target_pet.get("pet_name", "未知宠物")
            
            # 构建效果描述
            effect_descriptions = []
            for effect_name, effect_value in applied_effects.items():
                if effect_value > 0:
                    effect_descriptions.append(f"{effect_name}+{effect_value}")
            
            effect_text = "，".join(effect_descriptions) if effect_descriptions else "无效果"
            self.log('INFO', f"玩家 {username} 用{crop_name}喂食宠物 {pet_name}，获得：{effect_text}", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "action_response",
                "action_type": "feed_pet",
                "success": True,
                "message": f"成功喂食{pet_name}！获得：{effect_text}",
                "pet_id": pet_id,
                "crop_name": crop_name,
                "applied_effects": applied_effects,
                "updated_data": {
                    "宠物背包": player_data["宠物背包"],
                    "作物仓库": player_data["作物仓库"]
                }
            })
        else:
            return self._send_action_error(client_id, "feed_pet", "喂食失败")
    
    #辅助函数-处理宠物喂食逻辑
    def _process_pet_feeding(self, player_data, target_pet, crop_name, crop_index, feed_effects):
        """处理宠物喂食逻辑，支持多种属性提升"""
        try:
            # 消耗作物
            crop_warehouse = player_data.get("作物仓库", [])
            if crop_index >= 0 and crop_index < len(crop_warehouse):
                crop_warehouse[crop_index]["count"] -= 1
                # 如果数量为0，移除该作物
                if crop_warehouse[crop_index]["count"] <= 0:
                    crop_warehouse.pop(crop_index)
            
            # 记录实际应用的效果
            applied_effects = {}
            
            # 处理经验效果
            if "经验" in feed_effects:
                exp_gain = feed_effects["经验"]
                current_exp = target_pet.get("pet_experience", 0)
                max_exp = target_pet.get("pet_max_experience", 100)
                current_level = target_pet.get("pet_level", 1)
                
                new_exp = current_exp + exp_gain
                applied_effects["经验"] = exp_gain
                
                # 检查是否升级
                level_ups = 0
                while new_exp >= max_exp and current_level < 100:  # 假设最大等级为100
                    level_ups += 1
                    new_exp -= max_exp
                    current_level += 1
                    # 每升一级，最大经验增加20%
                    max_exp = int(max_exp * 1.2)
                
                # 更新经验数据
                target_pet["pet_experience"] = new_exp
                target_pet["pet_max_experience"] = max_exp
                target_pet["pet_level"] = current_level
                
                # 如果升级了，记录升级次数
                if level_ups > 0:
                    applied_effects["升级"] = level_ups
                    # 升级时应用属性加成
                    self._apply_level_up_bonus(target_pet, level_ups)
            
            # 处理生命值效果（增加最大生命值）
            if "生命值" in feed_effects:
                max_hp_gain = feed_effects["生命值"]
                # 增加最大生命值
                current_max_hp = target_pet.get("max_health", 100)
                new_max_hp = current_max_hp + max_hp_gain
                target_pet["max_health"] = new_max_hp
                
                # 同时恢复相应的当前生命值
                current_hp = target_pet.get("pet_current_health", current_max_hp)
                target_pet["pet_current_health"] = current_hp + max_hp_gain
                
                applied_effects["生命值"] = max_hp_gain
            
            # 处理攻击力效果
            if "攻击力" in feed_effects:
                attack_gain = feed_effects["攻击力"]
                current_attack = target_pet.get("base_attack_damage", 20)
                new_attack = current_attack + attack_gain
                target_pet["base_attack_damage"] = new_attack
                applied_effects["攻击力"] = attack_gain
            
            # 处理移动速度效果
            if "移动速度" in feed_effects:
                speed_gain = feed_effects["移动速度"]
                current_speed = target_pet.get("move_speed", 100)
                new_speed = current_speed + speed_gain
                target_pet["move_speed"] = new_speed
                applied_effects["移动速度"] = speed_gain
            
            # 处理亲密度效果
            if "亲密度" in feed_effects:
                intimacy_gain = feed_effects["亲密度"]
                current_intimacy = target_pet.get("pet_intimacy", 0)
                max_intimacy = target_pet.get("pet_max_intimacy", 1000)
                
                actual_intimacy_gain = min(intimacy_gain, max_intimacy - current_intimacy)
                if actual_intimacy_gain > 0:
                    target_pet["pet_intimacy"] = current_intimacy + actual_intimacy_gain
                    applied_effects["亲密度"] = actual_intimacy_gain
            
            # 处理护甲值效果
            if "护甲值" in feed_effects:
                armor_gain = feed_effects["护甲值"]
                current_armor = target_pet.get("current_armor", target_pet.get("max_armor", 10))
                max_armor = target_pet.get("max_armor", 10)
                
                actual_armor_gain = min(armor_gain, max_armor - current_armor)
                if actual_armor_gain > 0:
                    target_pet["current_armor"] = current_armor + actual_armor_gain
                    applied_effects["护甲值"] = actual_armor_gain
            
            # 处理暴击率效果
            if "暴击率" in feed_effects:
                crit_gain = feed_effects["暴击率"] / 100.0  # 转换为小数
                current_crit = target_pet.get("crit_rate", 0.1)
                new_crit = min(current_crit + crit_gain, 1.0)  # 最大100%
                target_pet["crit_rate"] = new_crit
                applied_effects["暴击率"] = feed_effects["暴击率"]
            
            # 处理闪避率效果
            if "闪避率" in feed_effects:
                dodge_gain = feed_effects["闪避率"] / 100.0  # 转换为小数
                current_dodge = target_pet.get("dodge_rate", 0.05)
                new_dodge = min(current_dodge + dodge_gain, 1.0)  # 最大100%
                target_pet["dodge_rate"] = new_dodge
                applied_effects["闪避率"] = feed_effects["闪避率"]
            
            # 处理护盾值效果
            if "护盾值" in feed_effects:
                shield_gain = feed_effects["护盾值"]
                current_shield = target_pet.get("current_shield", target_pet.get("max_shield", 0))
                max_shield = target_pet.get("max_shield", 0)
                
                actual_shield_gain = min(shield_gain, max_shield - current_shield)
                if actual_shield_gain > 0:
                    target_pet["current_shield"] = current_shield + actual_shield_gain
                    applied_effects["护盾值"] = actual_shield_gain
            
            return True, applied_effects
            
        except Exception as e:
            self.log('ERROR', f"宠物喂食处理失败: {str(e)}", 'SERVER')
            return False, {}
    
    #辅助函数-应用升级加成
    def _apply_level_up_bonus(self, target_pet, level_ups):
        """应用升级时的属性加成"""
        # 每升一级，属性增加10%
        level_bonus_multiplier = 1.1 ** level_ups
        
        # 更新生命和防御属性
        old_max_hp = target_pet.get("max_health", 100)
        old_max_armor = target_pet.get("max_armor", 10)
        old_max_shield = target_pet.get("max_shield", 0)
        
        new_max_hp = int(old_max_hp * level_bonus_multiplier)
        new_max_armor = int(old_max_armor * level_bonus_multiplier)
        new_max_shield = int(old_max_shield * level_bonus_multiplier)
        
        target_pet["max_health"] = new_max_hp
        target_pet["pet_current_health"] = new_max_hp  # 升级回满血
        target_pet["max_armor"] = new_max_armor
        target_pet["current_armor"] = new_max_armor  # 升级回满护甲
        
        # 如果有护盾系统，也更新护盾
        if old_max_shield > 0:
            target_pet["max_shield"] = new_max_shield
            target_pet["current_shield"] = new_max_shield  # 升级回满护盾
        
        # 更新攻击属性
        old_attack = target_pet.get("base_attack_damage", 20)
        new_attack = int(old_attack * level_bonus_multiplier)
        target_pet["base_attack_damage"] = new_attack
        
        # 更新移动速度
        old_speed = target_pet.get("move_speed", 100)
        new_speed = int(old_speed * level_bonus_multiplier)
        target_pet["move_speed"] = new_speed
#==========================宠物喂食处理==========================


#==========================宠物对战结果处理==========================
    def _handle_pet_battle_result(self, client_id, message):
        """处理宠物对战结果"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "提交宠物对战结果", "pet_battle_result")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "pet_battle_result")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 获取对战结果数据
        battle_data = message.get("battle_data", {})
        winner = battle_data.get("winner", "")
        attacker_name = battle_data.get("attacker_name", "")
        defender_name = battle_data.get("defender_name", "")
        battle_type = battle_data.get("battle_type", "")
        attacker_pets = battle_data.get("attacker_pets", [])
        defender_pets = battle_data.get("defender_pets", [])
        duration = battle_data.get("duration", 0)
        timestamp = battle_data.get("timestamp", time.time())
        
        # 验证必要参数
        if not winner or not attacker_name or not defender_name:
            return self._send_action_error(client_id, "pet_battle_result", "对战结果数据不完整")
        
        # 记录对战结果到日志
        self.log('INFO', f"宠物对战结果 - 获胜方: {winner}, 攻击方: {attacker_name}, 防守方: {defender_name}, 类型: {battle_type}, 持续时间: {duration}秒", 'BATTLE')
        
        # 初始化对战历史记录
        if "对战历史" not in player_data:
            player_data["对战历史"] = []
        
        # 添加对战记录
        battle_record = {
            "获胜方": winner,
            "攻击方": attacker_name,
            "防守方": defender_name,
            "对战类型": battle_type,
            "攻击方宠物": attacker_pets,
            "防守方宠物": defender_pets,
            "持续时间": duration,
            "时间戳": timestamp,
            "日期": datetime.datetime.fromtimestamp(timestamp).strftime("%Y年%m月%d日%H时%M分%S秒")
        }
        
        player_data["对战历史"].append(battle_record)
        
        # 限制历史记录数量（保留最近100条）
        if len(player_data["对战历史"]) > 100:
            player_data["对战历史"] = player_data["对战历史"][-100:]
        
        # 更新对战统计
        if "对战统计" not in player_data:
            player_data["对战统计"] = {
                "总对战次数": 0,
                "胜利次数": 0,
                "失败次数": 0,
                "胜率": 0.0
            }
        
        stats = player_data["对战统计"]
        stats["总对战次数"] += 1
        
        if winner == username:
            stats["胜利次数"] += 1
        else:
            stats["失败次数"] += 1
        
        # 计算胜率
        if stats["总对战次数"] > 0:
            stats["胜率"] = round(stats["胜利次数"] / stats["总对战次数"] * 100, 2)
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 如果是与其他玩家的对战，也更新对方的记录
        if defender_name != username and defender_name != "系统":
            defender_data = self.load_player_data(defender_name)
            if defender_data:
                # 初始化对方的对战历史和统计
                if "对战历史" not in defender_data:
                    defender_data["对战历史"] = []
                if "对战统计" not in defender_data:
                    defender_data["对战统计"] = {
                        "总对战次数": 0,
                        "胜利次数": 0,
                        "失败次数": 0,
                        "胜率": 0.0
                    }
                
                # 添加对战记录
                defender_data["对战历史"].append(battle_record)
                
                # 限制历史记录数量
                if len(defender_data["对战历史"]) > 100:
                    defender_data["对战历史"] = defender_data["对战历史"][-100:]
                
                # 更新对战统计
                defender_stats = defender_data["对战统计"]
                defender_stats["总对战次数"] += 1
                
                if winner == defender_name:
                    defender_stats["胜利次数"] += 1
                else:
                    defender_stats["失败次数"] += 1
                
                # 计算胜率
                if defender_stats["总对战次数"] > 0:
                    defender_stats["胜率"] = round(defender_stats["胜利次数"] / defender_stats["总对战次数"] * 100, 2)
                
                # 保存对方数据
                self.save_player_data(defender_name, defender_data)
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "pet_battle_result",
            "success": True,
            "message": "对战结果已记录",
            "updated_data": {
                "对战统计": player_data["对战统计"]
            }
        })
#==========================宠物对战结果处理==========================




#==========================开垦土地处理==========================
    #处理开垦土地请求
    def _handle_dig_ground(self, client_id, message):
        """处理开垦土地请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "开垦土地", "dig_ground")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "dig_ground")
        if not player_data:
            return self.send_data(client_id, response)
        
        lot_index = message.get("lot_index", -1)
        
        # 验证地块索引
        if lot_index < 0 or lot_index >= len(player_data.get("农场土地", [])):
            return self._send_action_error(client_id, "dig_ground", "无效的地块索引")
        
        lot = player_data["农场土地"][lot_index]
        
        # 检查地块是否已开垦
        if lot.get("is_diged", False):
            return self._send_action_error(client_id, "dig_ground", "此地块已经开垦过了")
        
        # 处理开垦
        return self._process_digging(client_id, player_data, username, lot, lot_index)
    
    #辅助函数-处理土地开垦逻辑
    def _process_digging(self, client_id, player_data, username, lot, lot_index):
        """处理土地开垦逻辑"""
        
        # 计算开垦费用 - 基于已开垦地块数量
        digged_count = sum(1 for l in player_data.get("农场土地", []) if l.get("is_diged", False))
        dig_money = digged_count * 1000
        
        # 检查玩家金钱是否足够
        if player_data["钱币"] < dig_money:
            return self._send_action_error(client_id, "dig_ground", f"金钱不足，开垦此地块需要 {dig_money} 金钱")
        
        # 执行开垦操作
        player_data["钱币"] -= dig_money
        lot["is_diged"] = True
        
        # 生成开垦随机奖励
        rewards = self._generate_dig_rewards()
        
        # 应用奖励
        player_data["钱币"] += rewards["钱币"]
        player_data["经验值"] += rewards["经验值"]
        
        # 添加种子到背包
        if "种子仓库" not in player_data:
            player_data["种子仓库"] = []
        
        for seed_name, quantity in rewards["seeds"].items():
            # 查找是否已有该种子
            found = False
            for item in player_data["种子仓库"]:
                if item.get("name") == seed_name:
                    item["count"] += quantity
                    found = True
                    break
            
            # 如果没有找到，添加新种子
            if not found:
                player_data["种子仓库"].append({
                    "name": seed_name,
                    "count": quantity
                })
        
        # 检查是否升级
        self._check_level_up(player_data)
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        # 构建奖励消息
        reward_message = f"获得 {rewards['钱币']} 金钱、{rewards['经验值']} 经验"
        if rewards["seeds"]:
            seed_list = [f"{name} x{qty}" for name, qty in rewards["seeds"].items()]
            reward_message += f"、种子：{', '.join(seed_list)}"
        
        self.log('INFO', f"玩家 {username} 成功开垦地块 {lot_index}，花费 {dig_money} 金钱，{reward_message}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "dig_ground",
            "success": True,
            "message": f"成功开垦地块，花费 {dig_money} 金钱！{reward_message}",
            "updated_data": {
                "钱币": player_data["钱币"],
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "农场土地": player_data["农场土地"],
                "种子仓库": player_data["种子仓库"]
            }
        })
    
    #辅助函数-生成开垦土地随机奖励
    def _generate_dig_rewards(self):
        """生成开垦土地的随机奖励"""
        
        rewards = {
            "钱币": 0,
            "经验值": 0,
            "seeds": {}
        }
        
        # 随机金钱：200-500元
        rewards["钱币"] = random.randint(200, 500)
        
        # 随机经验：300-600经验
        rewards["经验值"] = random.randint(300, 600)
        
        # 随机种子：0-3种种子
        seed_types_count = random.randint(0, 3)
        
        if seed_types_count > 0:
            # 获取作物数据
            crop_data = self._load_crop_data()
            if crop_data:
                # 获取所有可购买的种子
                all_seeds = []
                for crop_name, crop_info in crop_data.items():
                    if crop_info.get("能否购买", False):
                        all_seeds.append(crop_name)
                
                if all_seeds:
                    # 随机选择种子类型
                    selected_seeds = random.sample(all_seeds, min(seed_types_count, len(all_seeds)))
                    
                    for seed_name in selected_seeds:
                        # 每种种子1-3个
                        quantity = random.randint(1, 3)
                        rewards["seeds"][seed_name] = quantity
        
        return rewards

#==========================开垦土地处理==========================




#==========================铲除作物处理==========================
    #处理铲除作物请求
    def _handle_remove_crop(self, client_id, message):
        """处理铲除作物请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "铲除作物", "remove_crop")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "remove_crop")
        if not player_data:
            return self.send_data(client_id, response)
        
        lot_index = message.get("lot_index", -1)
        
        # 验证地块索引
        if lot_index < 0 or lot_index >= len(player_data.get("农场土地", [])):
            return self._send_action_error(client_id, "remove_crop", "无效的地块索引")
        
        lot = player_data["农场土地"][lot_index]
        
        # 检查地块状态
        if not lot.get("is_planted", False) or not lot.get("crop_type", ""):
            return self._send_action_error(client_id, "remove_crop", "此地块没有种植作物")
        
        # 处理铲除
        return self._process_crop_removal(client_id, player_data, username, lot, lot_index)
    
    #辅助函数-处理铲除作物逻辑
    def _process_crop_removal(self, client_id, player_data, username, lot, lot_index):
        """处理铲除作物逻辑"""
        # 铲除费用
        removal_cost = 500
        
        # 检查玩家金钱是否足够
        if player_data["钱币"] < removal_cost:
            return self._send_action_error(client_id, "remove_crop", f"金钱不足，铲除作物需要 {removal_cost} 金钱")
        
        # 获取作物名称用于日志
        crop_type = lot.get("crop_type", "未知作物")
        
        # 执行铲除操作
        player_data["钱币"] -= removal_cost
        lot["is_planted"] = False
        lot["crop_type"] = ""
        lot["grow_time"] = 0
        lot["is_dead"] = False  # 重置死亡状态
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        self.log('INFO', f"玩家 {username} 铲除了地块 {lot_index} 的作物 {crop_type}，花费 {removal_cost} 金钱", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "remove_crop",
            "success": True,
            "message": f"成功铲除作物 {crop_type}，花费 {removal_cost} 金钱",
            "updated_data": {
                "钱币": player_data["钱币"],
                "农场土地": player_data["农场土地"]
            }
        })
    
#==========================铲除作物处理==========================




#==========================浇水作物处理==========================
    #处理浇水请求
    def _handle_water_crop(self, client_id, message):
        """处理浇水作物请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "浇水作物", "water_crop")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取当前操作用户的数据
        current_player_data, current_username, response = self._load_player_data_with_check(client_id, "water_crop")
        if not current_player_data:
            return self.send_data(client_id, response)
        
        lot_index = message.get("lot_index", -1)
        target_username = message.get("target_username", "")
        
        # 确定操作目标：如果有target_username就是访问模式，否则是自己的农场
        if target_username and target_username != current_username:
            # 访问模式：浇水别人的作物，但花自己的钱
            target_player_data = self.load_player_data(target_username)
            if not target_player_data:
                return self._send_action_error(client_id, "water_crop", f"无法找到玩家 {target_username} 的数据")
            
            # 验证地块索引
            if lot_index < 0 or lot_index >= len(target_player_data.get("农场土地", [])):
                return self._send_action_error(client_id, "water_crop", "无效的地块索引")
            
            target_lot = target_player_data["农场土地"][lot_index]
            
            # 检查地块状态
            if not target_lot.get("is_planted", False) or not target_lot.get("crop_type", ""):
                return self._send_action_error(client_id, "water_crop", "此地块没有种植作物")
            
            # 处理访问模式浇水（花自己的钱，效果作用在目标玩家作物上）
            return self._process_visiting_watering(client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index)
        else:
            # 正常模式：浇水自己的作物
            # 验证地块索引
            if lot_index < 0 or lot_index >= len(current_player_data.get("农场土地", [])):
                return self._send_action_error(client_id, "water_crop", "无效的地块索引")
            
            lot = current_player_data["农场土地"][lot_index]
            
            # 检查地块状态
            if not lot.get("is_planted", False) or not lot.get("crop_type", ""):
                return self._send_action_error(client_id, "water_crop", "此地块没有种植作物")
            
            # 处理正常浇水
            return self._process_watering(client_id, current_player_data, current_username, lot, lot_index)
    
    #辅助函数-处理浇水逻辑
    def _process_watering(self, client_id, player_data, username, lot, lot_index):
        """处理浇水逻辑"""
        # 浇水费用
        water_cost = 50
        
        # 检查玩家金钱是否足够
        if player_data["钱币"] < water_cost:
            return self._send_action_error(client_id, "water_crop", f"金钱不足，浇水需要 {water_cost} 金钱")
        
        # 检查作物是否已死亡
        if lot.get("is_dead", False):
            return self._send_action_error(client_id, "water_crop", "死亡的作物无法浇水")
        
        # 检查是否已经成熟
        if lot["grow_time"] >= lot["max_grow_time"]:
            return self._send_action_error(client_id, "water_crop", "作物已经成熟，无需浇水")
        
        # 检查是否在1小时内已经浇过水（3600秒 = 1小时）
        current_time = time.time()
        last_water_time = lot.get("浇水时间", 0)
        water_cooldown = 3600  # 1小时冷却时间
        
        if current_time - last_water_time < water_cooldown:
            remaining_time = water_cooldown - (current_time - last_water_time)
            remaining_minutes = int(remaining_time // 60)
            remaining_seconds = int(remaining_time % 60)
            return self._send_action_error(client_id, "water_crop", f"浇水冷却中，还需等待 {remaining_minutes} 分钟 {remaining_seconds} 秒")
        
        # 执行浇水操作
        player_data["钱币"] -= water_cost
        
        # 生成随机经验奖励（100-300）
        experience_reward = random.randint(100, 300)
        player_data["经验值"] += experience_reward
        
        # 检查是否升级
        self._check_level_up(player_data)
        
        # 计算浇水效果：增加1%的生长进度
        growth_increase = int(lot["max_grow_time"] * 0.01)  # 1%的生长时间
        if growth_increase < 1:
            growth_increase = 1  # 至少增加1秒
        
        lot["grow_time"] += growth_increase
        
        # 确保不超过最大生长时间
        if lot["grow_time"] > lot["max_grow_time"]:
            lot["grow_time"] = lot["max_grow_time"]
        
        # 记录浇水时间戳
        lot["浇水时间"] = current_time
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        crop_type = lot.get("crop_type", "未知作物")
        progress = (lot["grow_time"] / lot["max_grow_time"]) * 100
        
        self.log('INFO', f"玩家 {username} 给地块 {lot_index} 的 {crop_type} 浇水，花费 {water_cost} 金钱，获得 {experience_reward} 经验，生长进度: {progress:.1f}%", 'SERVER')
        
        message = f"浇水成功！{crop_type} 生长了 {growth_increase} 秒，当前进度: {progress:.1f}%，获得 {experience_reward} 经验"
        if lot["grow_time"] >= lot["max_grow_time"]:
            message += "，作物已成熟！"
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "water_crop",
            "success": True,
            "message": message,
            "updated_data": {
                "钱币": player_data["钱币"],
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "农场土地": player_data["农场土地"]
            }
        })
    
    #处理访问模式浇水逻辑
    def _process_visiting_watering(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index):
        """处理访问模式浇水逻辑（花自己的钱，效果作用在目标玩家作物上）"""
        # 浇水费用
        water_cost = 50
        
        # 检查当前玩家金钱是否足够
        if current_player_data["钱币"] < water_cost:
            return self._send_action_error(client_id, "water_crop", f"金钱不足，帮助浇水需要 {water_cost} 金钱")
        
        # 检查目标作物是否已死亡
        if target_lot.get("is_dead", False):
            return self._send_action_error(client_id, "water_crop", "死亡的作物无法浇水")
        
        # 检查是否已经成熟
        if target_lot["grow_time"] >= target_lot["max_grow_time"]:
            return self._send_action_error(client_id, "water_crop", "作物已经成熟，无需浇水")
        
        # 检查是否在1小时内已经浇过水
        current_time = time.time()
        last_water_time = target_lot.get("浇水时间", 0)
        water_cooldown = 3600  # 1小时冷却时间
        
        if current_time - last_water_time < water_cooldown:
            remaining_time = water_cooldown - (current_time - last_water_time)
            remaining_minutes = int(remaining_time // 60)
            remaining_seconds = int(remaining_time % 60)
            return self._send_action_error(client_id, "water_crop", f"浇水冷却中，还需等待 {remaining_minutes} 分钟 {remaining_seconds} 秒")
        
        # 执行浇水操作：扣除当前玩家的钱
        current_player_data["钱币"] -= water_cost
        
        # 生成随机经验奖励（100-300）给当前玩家
        experience_reward = random.randint(100, 300)
        current_player_data["经验值"] += experience_reward
        
        # 检查当前玩家是否升级
        self._check_level_up(current_player_data)
        
        # 计算浇水效果：增加目标作物的生长进度
        growth_increase = int(target_lot["max_grow_time"] * 0.01)  # 1%的生长时间
        if growth_increase < 1:
            growth_increase = 1  # 至少增加1秒
        
        target_lot["grow_time"] += growth_increase
        
        # 确保不超过最大生长时间
        if target_lot["grow_time"] > target_lot["max_grow_time"]:
            target_lot["grow_time"] = target_lot["max_grow_time"]
        
        # 记录浇水时间戳
        target_lot["浇水时间"] = current_time
        
        # 保存两个玩家的数据
        self.save_player_data(current_username, current_player_data)
        self.save_player_data(target_username, target_player_data)
        
        # 向目标玩家推送作物更新（如果在线）
        self._push_crop_update_to_player(target_username, target_player_data)
        
        crop_type = target_lot.get("crop_type", "未知作物")
        progress = (target_lot["grow_time"] / target_lot["max_grow_time"]) * 100
        
        self.log('INFO', f"玩家 {current_username} 帮助玩家 {target_username} 给地块 {lot_index} 的 {crop_type} 浇水，花费 {water_cost} 金钱，获得 {experience_reward} 经验，生长进度: {progress:.1f}%", 'SERVER')
        
        message = f"帮助浇水成功！{target_username} 的 {crop_type} 生长了 {growth_increase} 秒，当前进度: {progress:.1f}%，获得 {experience_reward} 经验"
        if target_lot["grow_time"] >= target_lot["max_grow_time"]:
            message += "，作物已成熟！"
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "water_crop",
            "success": True,
            "message": message,
            "updated_data": {
                "钱币": current_player_data["钱币"],
                "经验值": current_player_data["经验值"],
                "等级": current_player_data["等级"]
            }
        })
    
#==========================浇水作物处理==========================



#==========================施肥作物处理==========================
    #处理施肥请求
    def _handle_fertilize_crop(self, client_id, message):
        """处理施肥作物请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "施肥作物", "fertilize_crop")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取当前操作用户的数据
        current_player_data, current_username, response = self._load_player_data_with_check(client_id, "fertilize_crop")
        if not current_player_data:
            return self.send_data(client_id, response)
        
        lot_index = message.get("lot_index", -1)
        target_username = message.get("target_username", "")
        
        # 确定操作目标：如果有target_username就是访问模式，否则是自己的农场
        if target_username and target_username != current_username:
            # 访问模式：施肥别人的作物，但花自己的钱
            target_player_data = self.load_player_data(target_username)
            if not target_player_data:
                return self._send_action_error(client_id, "fertilize_crop", f"无法找到玩家 {target_username} 的数据")
            
            # 验证地块索引
            if lot_index < 0 or lot_index >= len(target_player_data.get("农场土地", [])):
                return self._send_action_error(client_id, "fertilize_crop", "无效的地块索引")
            
            target_lot = target_player_data["农场土地"][lot_index]
            
            # 检查地块状态
            if not target_lot.get("is_planted", False) or not target_lot.get("crop_type", ""):
                return self._send_action_error(client_id, "fertilize_crop", "此地块没有种植作物")
            
            # 处理访问模式施肥
            return self._process_visiting_fertilizing(client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index)
        else:
            # 正常模式：施肥自己的作物
            # 验证地块索引
            if lot_index < 0 or lot_index >= len(current_player_data.get("农场土地", [])):
                return self._send_action_error(client_id, "fertilize_crop", "无效的地块索引")
            
            lot = current_player_data["农场土地"][lot_index]
            
            # 检查地块状态
            if not lot.get("is_planted", False) or not lot.get("crop_type", ""):
                return self._send_action_error(client_id, "fertilize_crop", "此地块没有种植作物")
            
            # 处理正常施肥
            return self._process_fertilizing(client_id, current_player_data, current_username, lot, lot_index)

    #辅助函数-处理访问模式施肥逻辑
    def _process_visiting_fertilizing(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index):
        """处理访问模式施肥逻辑（花自己的钱，效果作用在目标玩家作物上）"""
        # 施肥费用
        fertilize_cost = 150
        
        # 检查当前玩家金钱是否足够
        if current_player_data["钱币"] < fertilize_cost:
            return self._send_action_error(client_id, "fertilize_crop", f"金钱不足，帮助施肥需要 {fertilize_cost} 金钱")
        
        # 检查目标作物是否已死亡
        if target_lot.get("is_dead", False):
            return self._send_action_error(client_id, "fertilize_crop", "死亡的作物无法施肥")
        
        # 检查是否已经成熟
        if target_lot["grow_time"] >= target_lot["max_grow_time"]:
            return self._send_action_error(client_id, "fertilize_crop", "作物已经成熟，无需施肥")
        
        # 检查是否已经施过肥
        if target_lot.get("已施肥", False):
            return self._send_action_error(client_id, "fertilize_crop", "此作物已经施过肥了")
        
        # 执行施肥操作：扣除当前玩家的钱
        current_player_data["钱币"] -= fertilize_cost
        
        # 生成随机经验奖励（100-300）给当前玩家
        experience_reward = random.randint(100, 300)
        current_player_data["经验值"] += experience_reward
        
        # 检查当前玩家是否升级
        self._check_level_up(current_player_data)
        
        # 标记目标作物已施肥，施肥效果会在作物生长更新时生效
        target_lot["已施肥"] = True
        
        # 记录施肥时间戳，用于计算10分钟的双倍生长效果
        target_lot["施肥时间"] = time.time()
        
        # 保存两个玩家的数据
        self.save_player_data(current_username, current_player_data)
        self.save_player_data(target_username, target_player_data)
        
        # 向目标玩家推送作物更新（如果在线）
        self._push_crop_update_to_player(target_username, target_player_data)
        
        crop_type = target_lot.get("crop_type", "未知作物")
        
        self.log('INFO', f"玩家 {current_username} 帮助玩家 {target_username} 给地块 {lot_index} 的 {crop_type} 施肥，花费 {fertilize_cost} 金钱，获得 {experience_reward} 经验", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "fertilize_crop",
            "success": True,
            "message": f"帮助施肥成功！{target_username} 的 {crop_type} 将在10分钟内以双倍速度生长，获得 {experience_reward} 经验",
            "updated_data": {
                "钱币": current_player_data["钱币"],
                "经验值": current_player_data["经验值"],
                "等级": current_player_data["等级"]
            }
        })
    
    #辅助函数-处理施肥逻辑
    def _process_fertilizing(self, client_id, player_data, username, lot, lot_index):
        """处理施肥逻辑"""
        # 施肥费用
        fertilize_cost = 150
        
        # 检查玩家金钱是否足够
        if player_data["钱币"] < fertilize_cost:
            return self._send_action_error(client_id, "fertilize_crop", f"金钱不足，施肥需要 {fertilize_cost} 金钱")
        
        # 检查作物是否已死亡
        if lot.get("is_dead", False):
            return self._send_action_error(client_id, "fertilize_crop", "死亡的作物无法施肥")
        
        # 检查是否已经成熟
        if lot["grow_time"] >= lot["max_grow_time"]:
            return self._send_action_error(client_id, "fertilize_crop", "作物已经成熟，无需施肥")
        
        # 检查是否已经施过肥
        if lot.get("已施肥", False):
            return self._send_action_error(client_id, "fertilize_crop", "此作物已经施过肥了")
        
        # 执行施肥操作
        player_data["钱币"] -= fertilize_cost
        
        # 生成随机经验奖励（100-300）
        experience_reward = random.randint(100, 300)
        player_data["经验值"] += experience_reward
        
        # 检查是否升级
        self._check_level_up(player_data)
        
        # 标记已施肥，施肥效果会在作物生长更新时生效
        lot["已施肥"] = True
        
        # 记录施肥时间戳，用于计算10分钟的双倍生长效果
        lot["施肥时间"] = time.time()
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        crop_type = lot.get("crop_type", "未知作物")
        
        self.log('INFO', f"玩家 {username} 给地块 {lot_index} 的 {crop_type} 施肥，花费 {fertilize_cost} 金钱，获得 {experience_reward} 经验", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "fertilize_crop",
            "success": True,
            "message": f"施肥成功！{crop_type} 将在10分钟内以双倍速度生长，获得 {experience_reward} 经验",
            "updated_data": {
                "钱币": player_data["钱币"],
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "农场土地": player_data["农场土地"]
            }
        })
    
#==========================施肥作物处理==========================



#==========================购买道具处理==========================
    #处理购买道具请求
    def _handle_buy_item(self, client_id, message):
        """处理购买道具请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "购买道具", "buy_item")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "buy_item")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 解析请求参数
        item_name = message.get("item_name", "")
        item_cost = message.get("item_cost", 0)
        quantity = max(1, int(message.get("quantity", 1)))  # 确保购买数量为正整数
        
        # 验证道具配置
        item_config = self._load_item_config()
        if not item_config:
            return self._send_action_error(client_id, "buy_item", "服务器无法加载道具数据")
        
        if item_name not in item_config:
            return self._send_action_error(client_id, "buy_item", "该道具不存在")
        
        # 验证价格
        actual_cost = item_config[item_name].get("花费", 0)
        if item_cost != actual_cost:
            return self._send_action_error(client_id, "buy_item", f"道具价格验证失败，实际价格为{actual_cost}元")
        
        # 处理购买
        return self._process_item_purchase(client_id, player_data, username, item_name, item_config[item_name], quantity)
    
    #处理道具购买逻辑
    def _process_item_purchase(self, client_id, player_data, username, item_name, item_info, quantity=1):
        """处理道具购买逻辑"""
        unit_cost = item_info.get("花费", 0)
        total_cost = unit_cost * quantity
        
        # 检查金钱是否足够
        if player_data["钱币"] < total_cost:
            return self._send_action_error(client_id, "buy_item", 
                f"金钱不足，需要{total_cost}元，当前只有{player_data['money']}元")
        
        # 扣除金钱并添加道具
        player_data["钱币"] -= total_cost
        self._add_item_to_inventory(player_data, item_name, quantity)
        
        # 保存数据并记录日志
        self.save_player_data(username, player_data)
        self.log('INFO', f"玩家 {username} 购买了 {quantity} 个道具 {item_name}，花费 {total_cost} 元", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "buy_item",
            "success": True,
            "message": f"成功购买 {quantity} 个 {item_name}",
            "updated_data": {
                "钱币": player_data["钱币"],
                "道具背包": player_data["道具背包"]
            }
        })

    #辅助函数-将道具添加到背包
    def _add_item_to_inventory(self, player_data, item_name, quantity):
        """将道具添加到玩家背包"""
        if "道具背包" not in player_data:
            player_data["道具背包"] = []
        
        # 查找是否已有该道具
        for item in player_data["道具背包"]:
            if item.get("name") == item_name:
                item["count"] += quantity
                return
        
        # 添加新道具
        player_data["道具背包"].append({
            "name": item_name,
            "count": quantity
        })
    
    #加载道具配置数据
    def _load_item_config(self):
        """从MongoDB加载道具配置数据"""
        if not self.mongo_api or not self.mongo_api.is_connected():
            self.log('ERROR', 'MongoDB未配置或不可用，无法加载道具配置数据', 'SERVER')
            return {}
            
        try:
            config = self.mongo_api.get_item_config()
            if config:
                self.log('INFO', '成功从MongoDB加载道具配置', 'SERVER')
                return config
            else:
                self.log('ERROR', 'MongoDB中未找到道具配置', 'SERVER')
                return {}
        except Exception as e:
            self.log('ERROR', f'从MongoDB加载道具配置失败: {e}', 'SERVER')
            return {}
#==========================购买道具处理==========================



#==========================道具使用处理==========================
    #处理使用道具请求
    def _handle_use_item(self, client_id, message):
        """处理使用道具请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "使用道具", "use_item")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "use_item")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 解析请求参数
        lot_index = message.get("lot_index", -1)
        item_name = message.get("item_name", "")
        use_type = message.get("use_type", "")
        target_username = message.get("target_username", "")
        
        # 验证参数
        if not item_name or not use_type:
            return self._send_action_error(client_id, "use_item", "道具名称和使用类型不能为空")
        
        # 检查玩家是否拥有该道具
        if not self._has_item_in_inventory(player_data, item_name):
            return self._send_action_error(client_id, "use_item", f"您没有 {item_name}")
        
        # 确定操作目标并处理
        if target_username and target_username != username:
            # 访问模式：对别人的作物使用道具
            return self._handle_visiting_item_use(client_id, player_data, username, target_username, lot_index, item_name, use_type)
        else:
            # 正常模式：对自己的作物使用道具
            return self._handle_normal_item_use(client_id, player_data, username, lot_index, item_name, use_type)

    #辅助函数-处理道具使用逻辑
    def _handle_normal_item_use(self, client_id, player_data, username, lot_index, item_name, use_type):
        """处理正常模式下的道具使用"""
        if lot_index < 0 or lot_index >= len(player_data.get("农场土地", [])):
            return self._send_action_error(client_id, "use_item", "无效的地块索引")
        
        lot = player_data["农场土地"][lot_index]
        return self._process_item_use_normal(client_id, player_data, username, lot, lot_index, item_name, use_type)

    #辅助函数-处理访问模式道具使用逻辑
    def _handle_visiting_item_use(self, client_id, player_data, username, target_username, lot_index, item_name, use_type):
        """处理访问模式下的道具使用"""
        target_player_data = self.load_player_data(target_username)
        if not target_player_data:
            return self._send_action_error(client_id, "use_item", f"无法找到玩家 {target_username} 的数据")
        
        if lot_index < 0 or lot_index >= len(target_player_data.get("农场土地", [])):
            return self._send_action_error(client_id, "use_item", "无效的地块索引")
        
        target_lot = target_player_data["农场土地"][lot_index]
        return self._process_item_use_visiting(client_id, player_data, username, target_player_data, target_username, target_lot, lot_index, item_name, use_type)

    #辅助函数-检查玩家是否拥有指定道具
    def _has_item_in_inventory(self, player_data, item_name):
        """检查玩家是否拥有指定道具"""
        item_bag = player_data.get("道具背包", [])
        for item in item_bag:
            if item.get("name", "") == item_name and item.get("count", 0) > 0:
                return True
        return False

    #辅助函数-从玩家背包中移除指定道具
    def _remove_item_from_inventory(self, player_data, item_name, count=1):
        """从玩家道具背包中移除指定数量的道具"""
        item_bag = player_data.get("道具背包", [])
        for i, item in enumerate(item_bag):
            if item.get("name", "") == item_name and item.get("count", 0) >= count:
                item["count"] -= count
                if item["count"] <= 0:
                    item_bag.pop(i)
                return True
        return False

    #处理正常模式下的道具使用逻辑
    def _process_item_use_normal(self, client_id, player_data, username, lot, lot_index, item_name, use_type):
        """处理正常模式下的道具使用"""
        # 检查地块状态
        if not lot.get("is_planted", False) or not lot.get("crop_type", ""):
            return self._send_action_error(client_id, "use_item", "此地块没有种植作物")
        
        # 检查作物是否已死亡
        if lot.get("is_dead", False):
            return self._send_action_error(client_id, "use_item", "死亡的作物无法使用道具")
        
        # 根据使用类型和道具名称执行不同逻辑
        if use_type == "fertilize":
            # 检查是否已经成熟（施肥道具需要检查）
            if lot.get("grow_time", 0) >= lot.get("max_grow_time", 1):
                return self._send_action_error(client_id, "use_item", "作物已经成熟，无需施肥")
            return self._use_fertilizer_item(client_id, player_data, username, lot, lot_index, item_name)
        elif use_type == "water":
            # 检查是否已经成熟（浇水道具需要检查）
            if lot.get("grow_time", 0) >= lot.get("max_grow_time", 1):
                return self._send_action_error(client_id, "use_item", "作物已经成熟，无需浇水")
            return self._use_watering_item(client_id, player_data, username, lot, lot_index, item_name)
        elif use_type == "remove":
            # 铲子可以清除任何作物，包括成熟的
            return self._use_removal_item(client_id, player_data, username, lot, lot_index, item_name)
        elif use_type == "weed_killer":
            # 除草剂可以清除任何杂草，包括成熟的
            return self._use_weed_killer_item(client_id, player_data, username, lot, lot_index, item_name)
        elif use_type == "harvest":
            # 采集道具只能对成熟的作物使用
            if lot.get("grow_time", 0) < lot.get("max_grow_time", 1):
                return self._send_action_error(client_id, "use_item", "作物还未成熟，无法使用采集道具")
            return self._use_harvest_item(client_id, player_data, username, lot, lot_index, item_name)
        else:
            return self._send_action_error(client_id, "use_item", f"不支持的使用类型: {use_type}")

    #处理访问模式下的道具使用逻辑
    def _process_item_use_visiting(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name, use_type):
        """处理访问模式下的道具使用"""
        # 检查地块状态
        if not target_lot.get("is_planted", False) or not target_lot.get("crop_type", ""):
            return self._send_action_error(client_id, "use_item", "此地块没有种植作物")
        
        # 检查作物是否已死亡
        if target_lot.get("is_dead", False):
            return self._send_action_error(client_id, "use_item", "死亡的作物无法使用道具")
        
        # 根据使用类型和道具名称执行不同逻辑
        if use_type == "fertilize":
            # 检查是否已经成熟（施肥道具需要检查）
            if target_lot.get("grow_time", 0) >= target_lot.get("max_grow_time", 1):
                return self._send_action_error(client_id, "use_item", "作物已经成熟，无需施肥")
            return self._use_fertilizer_item_visiting(client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name)
        elif use_type == "water":
            # 检查是否已经成熟（浇水道具需要检查）
            if target_lot.get("grow_time", 0) >= target_lot.get("max_grow_time", 1):
                return self._send_action_error(client_id, "use_item", "作物已经成熟，无需浇水")
            return self._use_watering_item_visiting(client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name)
        elif use_type == "remove":
            # 铲子可以清除任何作物，包括成熟的
            return self._use_removal_item_visiting(client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name)
        elif use_type == "weed_killer":
            # 除草剂可以清除任何杂草，包括成熟的
            return self._use_weed_killer_item_visiting(client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name)
        elif use_type == "harvest":
            # 采集道具只能对成熟的作物使用
            if target_lot.get("grow_time", 0) < target_lot.get("max_grow_time", 1):
                return self._send_action_error(client_id, "use_item", "作物还未成熟，无法使用采集道具")
            return self._use_harvest_item_visiting(client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name)
        else:
            return self._send_action_error(client_id, "use_item", f"不支持的使用类型: {use_type}")

    #使用施肥类道具
    def _use_fertilizer_item(self, client_id, player_data, username, lot, lot_index, item_name):
        """使用施肥类道具"""
        # 检查是否已经施过肥
        if lot.get("已施肥", False):
            return self._send_action_error(client_id, "use_item", "此作物已经施过肥了")
        
        # 移除道具
        if not self._remove_item_from_inventory(player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 生成随机经验奖励
        experience_reward = random.randint(50, 150)
        player_data["经验值"] += experience_reward
        
        # 检查是否升级
        self._check_level_up(player_data)
        
        # 根据道具类型设置不同的施肥效果
        current_time = time.time()
        
        if item_name == "农家肥":
            # 30分钟内额外+1秒/次生长
            lot["已施肥"] = True
            lot["施肥时间"] = current_time
            lot["施肥类型"] = "农家肥"
            lot["施肥加成"] = 1
            lot["施肥持续时间"] = 1800  # 30分钟
            message = f"使用 {item_name} 成功！作物将在30分钟内获得额外生长加成"
        elif item_name == "金坷垃":
            # 5分钟内额外+4秒/次生长
            lot["已施肥"] = True
            lot["施肥时间"] = current_time
            lot["施肥类型"] = "金坷垃"
            lot["施肥加成"] = 4
            lot["施肥持续时间"] = 300  # 5分钟
            message = f"使用 {item_name} 成功！作物将在5分钟内获得强力生长加成"
        elif item_name == "生长素":
            # 10分钟内额外+2秒/次生长
            lot["已施肥"] = True
            lot["施肥时间"] = current_time
            lot["施肥类型"] = "生长素"
            lot["施肥加成"] = 2
            lot["施肥持续时间"] = 600  # 10分钟
            message = f"使用 {item_name} 成功！作物将在10分钟内获得中等生长加成"
        else:
            return self._send_action_error(client_id, "use_item", f"不支持的施肥道具: {item_name}")
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        crop_type = lot.get("crop_type", "未知作物")
        self.log('INFO', f"玩家 {username} 对地块 {lot_index} 的 {crop_type} 使用了 {item_name}，获得 {experience_reward} 经验", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": f"{message}，获得 {experience_reward} 经验",
            "updated_data": {
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "农场土地": player_data["农场土地"],
                "道具背包": player_data["道具背包"]
            }
        })

    #使用浇水类道具
    def _use_watering_item(self, client_id, player_data, username, lot, lot_index, item_name):
        """使用浇水类道具"""
        # 移除道具
        if not self._remove_item_from_inventory(player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 生成随机经验奖励
        experience_reward = random.randint(30, 100)
        player_data["经验值"] += experience_reward
        
        # 检查是否升级
        self._check_level_up(player_data)
        
        # 根据道具类型计算浇水效果
        if item_name == "水壶":
            # 增加1%的生长进度
            growth_increase = int(lot["max_grow_time"] * 0.01)
            message = f"使用 {item_name} 成功！作物生长进度增加了1%"
        elif item_name == "水桶":
            # 增加2%的生长进度
            growth_increase = int(lot["max_grow_time"] * 0.02)
            message = f"使用 {item_name} 成功！作物生长进度增加了2%"
        else:
            return self._send_action_error(client_id, "use_item", f"不支持的浇水道具: {item_name}")
        
        if growth_increase < 1:
            growth_increase = 1  # 至少增加1秒
        
        lot["grow_time"] += growth_increase
        
        # 确保不超过最大生长时间
        if lot["grow_time"] > lot["max_grow_time"]:
            lot["grow_time"] = lot["max_grow_time"]
        
        # 记录浇水时间戳
        lot["浇水时间"] = time.time()
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        crop_type = lot.get("crop_type", "未知作物")
        progress = (lot["grow_time"] / lot["max_grow_time"]) * 100
        
        self.log('INFO', f"玩家 {username} 对地块 {lot_index} 的 {crop_type} 使用了 {item_name}，生长进度: {progress:.1f}%，获得 {experience_reward} 经验", 'SERVER')
        
        final_message = f"{message}，当前进度: {progress:.1f}%，获得 {experience_reward} 经验"
        if lot["grow_time"] >= lot["max_grow_time"]:
            final_message += "，作物已成熟！"
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": final_message,
            "updated_data": {
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "农场土地": player_data["农场土地"],
                "道具背包": player_data["道具背包"]
            }
        })

    #访问模式下使用施肥类道具
    def _use_fertilizer_item_visiting(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name):
        """访问模式下使用施肥类道具"""
        # 检查是否已经施过肥
        if target_lot.get("已施肥", False):
            return self._send_action_error(client_id, "use_item", "此作物已经施过肥了")
        
        # 移除当前玩家的道具
        if not self._remove_item_from_inventory(current_player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 生成随机经验奖励给当前玩家
        experience_reward = random.randint(50, 150)
        current_player_data["经验值"] += experience_reward
        
        # 检查当前玩家是否升级
        self._check_level_up(current_player_data)
        
        # 根据道具类型设置不同的施肥效果
        current_time = time.time()
        
        if item_name == "农家肥":
            # 30分钟内额外+1秒/次生长
            target_lot["已施肥"] = True
            target_lot["施肥时间"] = current_time
            target_lot["施肥类型"] = "农家肥"
            target_lot["施肥加成"] = 1
            target_lot["施肥持续时间"] = 1800  # 30分钟
            message = f"帮助施肥成功！{target_username} 的作物将在30分钟内获得额外生长加成"
        elif item_name == "金坷垃":
            # 5分钟内额外+4秒/次生长
            target_lot["已施肥"] = True
            target_lot["施肥时间"] = current_time
            target_lot["施肥类型"] = "金坷垃"
            target_lot["施肥加成"] = 4
            target_lot["施肥持续时间"] = 300  # 5分钟
            message = f"帮助施肥成功！{target_username} 的作物将在5分钟内获得强力生长加成"
        elif item_name == "生长素":
            # 10分钟内额外+2秒/次生长
            target_lot["已施肥"] = True
            target_lot["施肥时间"] = current_time
            target_lot["施肥类型"] = "生长素"
            target_lot["施肥加成"] = 2
            target_lot["施肥持续时间"] = 600  # 10分钟
            message = f"帮助施肥成功！{target_username} 的作物将在10分钟内获得中等生长加成"
        else:
            return self._send_action_error(client_id, "use_item", f"不支持的施肥道具: {item_name}")
        
        # 保存两个玩家的数据
        self.save_player_data(current_username, current_player_data)
        self.save_player_data(target_username, target_player_data)
        
        # 向目标玩家推送作物更新
        self._push_crop_update_to_player(target_username, target_player_data)
        
        crop_type = target_lot.get("crop_type", "未知作物")
        self.log('INFO', f"玩家 {current_username} 帮助玩家 {target_username} 对地块 {lot_index} 的 {crop_type} 使用了 {item_name}，获得 {experience_reward} 经验", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": f"{message}，获得 {experience_reward} 经验",
            "updated_data": {
                "经验值": current_player_data["经验值"],
                "等级": current_player_data["等级"],
                "道具背包": current_player_data["道具背包"]
            }
        })
    
    def _use_watering_item_visiting(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name):
        """访问模式下使用浇水类道具"""
        # 移除当前玩家的道具
        if not self._remove_item_from_inventory(current_player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 生成随机经验奖励给当前玩家
        experience_reward = random.randint(30, 100)
        current_player_data["经验值"] += experience_reward
        
        # 检查当前玩家是否升级
        self._check_level_up(current_player_data)
        
        # 根据道具类型计算浇水效果
        if item_name == "水壶":
            # 增加1%的生长进度
            growth_increase = int(target_lot["max_grow_time"] * 0.01)
            message = f"帮助浇水成功！{target_username} 的作物生长进度增加了1%"
        elif item_name == "水桶":
            # 增加2%的生长进度
            growth_increase = int(target_lot["max_grow_time"] * 0.02)
            message = f"帮助浇水成功！{target_username} 的作物生长进度增加了2%"
        else:
            return self._send_action_error(client_id, "use_item", f"不支持的浇水道具: {item_name}")
        
        if growth_increase < 1:
            growth_increase = 1  # 至少增加1秒
        
        target_lot["grow_time"] += growth_increase
        
        # 确保不超过最大生长时间
        if target_lot["grow_time"] > target_lot["max_grow_time"]:
            target_lot["grow_time"] = target_lot["max_grow_time"]
        
        # 记录浇水时间戳
        target_lot["浇水时间"] = time.time()
        
        # 保存两个玩家的数据
        self.save_player_data(current_username, current_player_data)
        self.save_player_data(target_username, target_player_data)
        
        # 向目标玩家推送作物更新
        self._push_crop_update_to_player(target_username, target_player_data)
        
        crop_type = target_lot.get("crop_type", "未知作物")
        progress = (target_lot["grow_time"] / target_lot["max_grow_time"]) * 100
        
        self.log('INFO', f"玩家 {current_username} 帮助玩家 {target_username} 对地块 {lot_index} 的 {crop_type} 使用了 {item_name}，生长进度: {progress:.1f}%，获得 {experience_reward} 经验", 'SERVER')
        
        final_message = f"{message}，当前进度: {progress:.1f}%，获得 {experience_reward} 经验"
        if target_lot["grow_time"] >= target_lot["max_grow_time"]:
            final_message += "，作物已成熟！"
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": final_message,
            "updated_data": {
                "经验值": current_player_data["经验值"],
                "等级": current_player_data["等级"],
                "道具背包": current_player_data["道具背包"]
            }
        })
    
    def _use_removal_item(self, client_id, player_data, username, lot, lot_index, item_name):
        """使用铲除类道具（铲子）"""
        # 检查玩家是否有这个道具
        if not self._has_item_in_inventory(player_data, item_name):
            return self._send_action_error(client_id, "use_item", f"您没有 {item_name}")
        
        # 移除道具
        if not self._remove_item_from_inventory(player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 生成随机经验奖励
        experience_reward = random.randint(20, 60)
        player_data["经验值"] += experience_reward
        
        # 检查是否升级
        self._check_level_up(player_data)
        
        # 获取作物名称用于日志
        crop_type = lot.get("crop_type", "未知作物")
        
        # 执行铲除操作
        lot["is_planted"] = False
        lot["crop_type"] = ""
        lot["grow_time"] = 0
        lot["is_dead"] = False  # 重置死亡状态
        lot["已浇水"] = False  # 重置浇水状态
        lot["已施肥"] = False  # 重置施肥状态
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        self.log('INFO', f"玩家 {username} 使用 {item_name} 铲除了地块 {lot_index} 的作物 {crop_type}，获得 {experience_reward} 经验", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": f"使用 {item_name} 成功铲除作物 {crop_type}，获得 {experience_reward} 经验",
            "updated_data": {
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "农场土地": player_data["农场土地"],
                "道具背包": player_data["道具背包"]
            }
        })
    
    def _use_weed_killer_item(self, client_id, player_data, username, lot, lot_index, item_name):
        """使用除草剂"""
        # 检查是否为杂草
        crop_type = lot.get("crop_type", "")
        crop_data = self._load_crop_data()
        
        if not crop_data or crop_type not in crop_data:
            return self._send_action_error(client_id, "use_item", f"未知的作物类型: {crop_type}")
        
        is_weed = crop_data[crop_type].get("是否杂草", False)
        if not is_weed:
            return self._send_action_error(client_id, "use_item", "除草剂只能用于清除杂草，此作物不是杂草")
        
        # 检查玩家是否有这个道具
        if not self._has_item_in_inventory(player_data, item_name):
            return self._send_action_error(client_id, "use_item", f"您没有 {item_name}")
        
        # 移除道具
        if not self._remove_item_from_inventory(player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 生成随机经验奖励
        experience_reward = random.randint(15, 50)
        player_data["经验值"] += experience_reward
        
        # 检查是否升级
        self._check_level_up(player_data)
        
        # 执行除草操作
        lot["is_planted"] = False
        lot["crop_type"] = ""
        lot["grow_time"] = 0
        lot["is_dead"] = False  # 重置死亡状态
        lot["已浇水"] = False  # 重置浇水状态
        lot["已施肥"] = False  # 重置施肥状态
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        self.log('INFO', f"玩家 {username} 使用 {item_name} 清除了地块 {lot_index} 的杂草 {crop_type}，获得 {experience_reward} 经验", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": f"使用 {item_name} 成功清除杂草 {crop_type}，获得 {experience_reward} 经验",
            "updated_data": {
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "农场土地": player_data["农场土地"],
                "道具背包": player_data["道具背包"]
            }
        })
    
    def _use_removal_item_visiting(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name):
        """访问模式下使用铲除道具"""
        # 检查当前玩家是否有这个道具
        if not self._has_item_in_inventory(current_player_data, item_name):
            return self._send_action_error(client_id, "use_item", f"您没有 {item_name}")
        
        # 移除当前玩家的道具
        if not self._remove_item_from_inventory(current_player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 生成随机经验奖励给当前玩家
        experience_reward = random.randint(20, 60)
        current_player_data["经验值"] += experience_reward
        
        # 检查当前玩家是否升级
        self._check_level_up(current_player_data)
        
        # 获取作物名称用于日志
        crop_type = target_lot.get("crop_type", "未知作物")
        
        # 执行铲除操作
        target_lot["is_planted"] = False
        target_lot["crop_type"] = ""
        target_lot["grow_time"] = 0
        target_lot["is_dead"] = False  # 重置死亡状态
        target_lot["已浇水"] = False  # 重置浇水状态
        target_lot["已施肥"] = False  # 重置施肥状态
        
        # 保存两个玩家的数据
        self.save_player_data(current_username, current_player_data)
        self.save_player_data(target_username, target_player_data)
        
        # 向目标玩家推送作物更新
        self._push_crop_update_to_player(target_username, target_player_data)
        
        self.log('INFO', f"玩家 {current_username} 帮助玩家 {target_username} 使用 {item_name} 铲除了地块 {lot_index} 的作物 {crop_type}，获得 {experience_reward} 经验", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": f"帮助 {target_username} 铲除作物 {crop_type} 成功，获得 {experience_reward} 经验",
            "updated_data": {
                "经验值": current_player_data["经验值"],
                "等级": current_player_data["等级"],
                "道具背包": current_player_data["道具背包"]
            }
        })
    
    def _use_weed_killer_item_visiting(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name):
        """访问模式下使用除草剂"""
        # 检查是否为杂草
        crop_type = target_lot.get("crop_type", "")
        crop_data = self._load_crop_data()
        
        if not crop_data or crop_type not in crop_data:
            return self._send_action_error(client_id, "use_item", f"未知的作物类型: {crop_type}")
        
        is_weed = crop_data[crop_type].get("是否杂草", False)
        if not is_weed:
            return self._send_action_error(client_id, "use_item", "除草剂只能用于清除杂草，此作物不是杂草")
        
        # 检查当前玩家是否有这个道具
        if not self._has_item_in_inventory(current_player_data, item_name):
            return self._send_action_error(client_id, "use_item", f"您没有 {item_name}")
        
        # 移除当前玩家的道具
        if not self._remove_item_from_inventory(current_player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 生成随机经验奖励给当前玩家
        experience_reward = random.randint(15, 50)
        current_player_data["经验值"] += experience_reward
        
        # 检查当前玩家是否升级
        self._check_level_up(current_player_data)
        
        # 执行除草操作
        target_lot["is_planted"] = False
        target_lot["crop_type"] = ""
        target_lot["grow_time"] = 0
        target_lot["is_dead"] = False  # 重置死亡状态
        target_lot["已浇水"] = False  # 重置浇水状态
        target_lot["已施肥"] = False  # 重置施肥状态
        
        # 保存两个玩家的数据
        self.save_player_data(current_username, current_player_data)
        self.save_player_data(target_username, target_player_data)
        
        # 向目标玩家推送作物更新
        self._push_crop_update_to_player(target_username, target_player_data)
        
        self.log('INFO', f"玩家 {current_username} 帮助玩家 {target_username} 使用 {item_name} 清除了地块 {lot_index} 的杂草 {crop_type}，获得 {experience_reward} 经验", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": f"帮助 {target_username} 清除杂草 {crop_type} 成功，获得 {experience_reward} 经验",
            "updated_data": {
                "经验值": current_player_data["经验值"],
                "等级": current_player_data["等级"],
                "道具背包": current_player_data["道具背包"]
            }
        })
    
    def _use_harvest_item(self, client_id, player_data, username, lot, lot_index, item_name):
        """使用采集道具（精准采集锄、时运锄）"""
        # 移除道具
        if not self._remove_item_from_inventory(player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 读取作物配置
        crop_data = self._load_crop_data()
        
        # 获取作物类型
        crop_type = lot["crop_type"]
        
        # 检查是否为杂草类型（杂草不能用采集道具收获）
        if crop_type in crop_data:
            crop_info = crop_data[crop_type]
            is_weed = crop_info.get("是否杂草", False)
            
            if is_weed:
                return self._send_action_error(client_id, "use_item", f"{crop_type}不能使用采集道具收获，只能铲除！")
            
            crop_exp = crop_info.get("经验", 10)
            
            # 额外检查：如果作物收益为负数，也视为杂草
            crop_income = crop_info.get("收益", 100) + crop_info.get("花费", 0)
            if crop_income < 0:
                return self._send_action_error(client_id, "use_item", f"{crop_type}不能使用采集道具收获，只能铲除！")
        else:
            # 默认经验
            crop_exp = 10
        
        # 道具特殊效果
        import random
        
        if item_name == "精准采集锄":
            # 精准采集锄：收获数量正常（1-5个），但必定掉落种子
            harvest_count = random.randint(1, 5)
            # 100%概率获得2-4个该作物的种子
            seed_reward = {
                "name": crop_type + "种子",
                "count": random.randint(2, 4)
            }
            message_suffix = "，精准采集锄确保了种子的获得"
            
        elif item_name == "时运锄":
            # 时运锄：收获数量更多（3-8个），种子掉落率正常
            harvest_count = random.randint(3, 8)
            # 15%概率获得1-3个该作物的种子（稍微提高）
            seed_reward = None
            if random.random() < 0.15:
                seed_reward = {
                    "name": crop_type + "种子",
                    "count": random.randint(1, 3)
                }
            message_suffix = "，时运锄增加了收获数量"
            
        else:
            return self._send_action_error(client_id, "use_item", f"不支持的采集道具: {item_name}")
        
        # 生成采集奖励经验
        experience_reward = random.randint(30, 80)
        crop_exp += experience_reward
        
        # 创建收获物
        crop_harvest = {
            "name": crop_type,
            "count": harvest_count
        }
        
        # 更新玩家经验
        player_data["经验值"] += crop_exp
        
        # 检查是否升级
        self._check_level_up(player_data)
        
        # 检查是否会获得成熟物
        crop_data = self._load_crop_data()
        will_get_mature_item = True
        mature_item_name = crop_type
        
        if crop_data and crop_type in crop_data:
            mature_name = crop_data[crop_type].get("成熟物名称")
            if mature_name is None:
                will_get_mature_item = False
            elif mature_name and mature_name.strip():
                mature_item_name = mature_name
        
        # 添加成熟物到作物仓库（如果允许）
        if will_get_mature_item:
            self._add_crop_to_warehouse(player_data, crop_harvest)
        
        # 添加种子奖励到背包
        if seed_reward:
            self._add_seeds_to_bag(player_data, seed_reward)
        
        # 清理地块
        lot["is_planted"] = False
        lot["crop_type"] = ""
        lot["grow_time"] = 0
        lot["已浇水"] = False
        lot["已施肥"] = False
        
        # 清除施肥时间戳
        if "施肥时间" in lot:
            del lot["施肥时间"]
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        # 构建消息
        if will_get_mature_item:
            message = f"使用 {item_name} 收获成功，获得 {mature_item_name} x{harvest_count} 和 {crop_exp} 经验{message_suffix}"
        else:
            message = f"使用 {item_name} 收获成功，获得 {crop_exp} 经验{message_suffix}（{crop_type}无成熟物产出）"
        
        if seed_reward:
            message += f"，额外获得 {seed_reward['name']} x{seed_reward['count']}"
        
        self.log('INFO', f"玩家 {username} 使用 {item_name} 从地块 {lot_index} 收获了作物，获得 {crop_type} x{harvest_count} 和 {crop_exp} 经验" + (f"，额外获得 {seed_reward['name']} x{seed_reward['count']}" if seed_reward else ""), 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": message,
            "updated_data": {
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "种子仓库": player_data.get("种子仓库", []),
                "作物仓库": player_data.get("作物仓库", []),
                "道具背包": player_data.get("道具背包", [])
            }
        })
    
    def _use_harvest_item_visiting(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index, item_name):
        """访问模式下使用采集道具"""
        # 移除当前玩家的道具
        if not self._remove_item_from_inventory(current_player_data, item_name, 1):
            return self._send_action_error(client_id, "use_item", f"移除道具 {item_name} 失败")
        
        # 读取作物配置
        crop_data = self._load_crop_data()
        
        # 获取作物类型
        crop_type = target_lot["crop_type"]
        
        # 检查是否为杂草类型（杂草不能用采集道具收获）
        if crop_type in crop_data:
            crop_info = crop_data[crop_type]
            is_weed = crop_info.get("是否杂草", False)
            
            if is_weed:
                return self._send_action_error(client_id, "use_item", f"{crop_type}不能使用采集道具收获，只能铲除！")
            
            crop_exp = int(crop_info.get("经验", 10) * 0.7)  # 访问模式获得70%经验
            
            # 额外检查：如果作物收益为负数，也视为杂草
            crop_income = crop_info.get("收益", 100) + crop_info.get("花费", 0)
            if crop_income < 0:
                return self._send_action_error(client_id, "use_item", f"{crop_type}不能使用采集道具收获，只能铲除！")
        else:
            # 默认经验
            crop_exp = 7
        
        # 道具特殊效果（访问模式稍微降低效果）
        import random
        
        if item_name == "精准采集锄":
            # 精准采集锄：收获数量稍少（1-4个），但必定掉落种子
            harvest_count = random.randint(1, 4)
            # 100%概率获得1-3个该作物的种子
            seed_reward = {
                "name": crop_type + "种子",
                "count": random.randint(1, 3)
            }
            message_suffix = "，精准采集锄确保了种子的获得"
            
        elif item_name == "时运锄":
            # 时运锄：收获数量较多（2-6个），种子掉落率正常
            harvest_count = random.randint(2, 6)
            # 10%概率获得1-2个该作物的种子
            seed_reward = None
            if random.random() < 0.10:
                seed_reward = {
                    "name": crop_type + "种子",
                    "count": random.randint(1, 2)
                }
            message_suffix = "，时运锄增加了收获数量"
            
        else:
            return self._send_action_error(client_id, "use_item", f"不支持的采集道具: {item_name}")
        
        # 生成帮助采集奖励经验
        experience_reward = random.randint(20, 60)
        crop_exp += experience_reward
        
        # 创建收获物
        crop_harvest = {
            "name": crop_type,
            "count": harvest_count
        }
        
        # 更新当前玩家经验
        current_player_data["经验值"] += crop_exp
        
        # 检查当前玩家是否升级
        self._check_level_up(current_player_data)
        
        # 检查是否会获得成熟物
        crop_data = self._load_crop_data()
        will_get_mature_item = True
        mature_item_name = crop_type
        
        if crop_data and crop_type in crop_data:
            mature_name = crop_data[crop_type].get("成熟物名称")
            if mature_name is None:
                will_get_mature_item = False
            elif mature_name and mature_name.strip():
                mature_item_name = mature_name
        
        # 收获物给当前玩家（如果允许）
        if will_get_mature_item:
            self._add_crop_to_warehouse(current_player_data, crop_harvest)
        
        # 种子奖励给当前玩家
        if seed_reward:
            self._add_seeds_to_bag(current_player_data, seed_reward)
        
        # 清理目标玩家的地块
        target_lot["is_planted"] = False
        target_lot["crop_type"] = ""
        target_lot["grow_time"] = 0
        target_lot["已浇水"] = False
        target_lot["已施肥"] = False
        
        # 清除施肥时间戳
        if "施肥时间" in target_lot:
            del target_lot["施肥时间"]
        
        # 保存两个玩家的数据
        self.save_player_data(current_username, current_player_data)
        self.save_player_data(target_username, target_player_data)
        
        # 向目标玩家推送作物更新（如果在线）
        self._push_crop_update_to_player(target_username, target_player_data)
        
        # 构建消息
        if will_get_mature_item:
            message = f"使用 {item_name} 帮助收获成功！从 {target_username} 那里获得 {mature_item_name} x{harvest_count} 和 {crop_exp} 经验{message_suffix}"
        else:
            message = f"使用 {item_name} 帮助收获成功！从 {target_username} 那里获得 {crop_exp} 经验{message_suffix}（{crop_type}无成熟物产出）"
        
        if seed_reward:
            message += f"，额外获得 {seed_reward['name']} x{seed_reward['count']}"
        
        self.log('INFO', f"玩家 {current_username} 使用 {item_name} 帮助玩家 {target_username} 收获地块 {lot_index} 的作物，获得 {crop_type} x{harvest_count} 和 {crop_exp} 经验" + (f"，额外获得 {seed_reward['name']} x{seed_reward['count']}" if seed_reward else ""), 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "use_item",
            "success": True,
            "message": message,
            "updated_data": {
                "经验值": current_player_data["经验值"],
                "等级": current_player_data["等级"],
                "种子仓库": current_player_data.get("种子仓库", []),
                "作物仓库": current_player_data.get("作物仓库", []),
                "道具背包": current_player_data.get("道具背包", [])
            }
        })
#==========================道具使用处理==========================



#==========================宠物使用道具处理==========================
    def _handle_use_pet_item(self, client_id, message):
        """处理宠物使用道具请求"""
        # 检查用户登录状态
        logged_in, response = self._check_user_logged_in(client_id, "宠物使用道具", "use_pet_item")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 验证请求参数
        item_name = message.get("item_name", "")
        pet_id = message.get("pet_id", "")
        if not item_name or not pet_id:
            return self._send_pet_item_error(client_id, "缺少必要参数")
        
        # 获取玩家数据
        username = self.user_data[client_id]["username"]
        player_data = self.load_player_data(username)
        if not player_data:
            return self._send_pet_item_error(client_id, "玩家数据加载失败")
        
        # 验证道具和宠物
        validation_result = self._validate_pet_item_use(player_data, item_name, pet_id)
        if not validation_result["success"]:
            return self._send_pet_item_error(client_id, validation_result["message"])
        
        # 处理道具使用
        return self._execute_pet_item_use(client_id, player_data, username, 
                                        validation_result["item_index"], 
                                        validation_result["pet_index"], 
                                        item_name, pet_id)
    
    def _validate_pet_item_use(self, player_data, item_name, pet_id):
        """验证宠物道具使用条件"""
        # 检查道具
        item_bag = player_data.get("道具背包", [])
        item_index = -1
        for i, item in enumerate(item_bag):
            if item.get("name") == item_name and item.get("count", 0) > 0:
                item_index = i
                break
        
        if item_index == -1:
            return {"success": False, "message": f"道具 {item_name} 不足"}
        
        # 检查宠物
        pet_bag = player_data.get("宠物背包", [])
        pet_index = -1
        for i, pet in enumerate(pet_bag):
            if pet.get("pet_id") == pet_id:
                pet_index = i
                break
        
        if pet_index == -1:
            return {"success": False, "message": "找不到指定的宠物"}
        
        return {"success": True, "item_index": item_index, "pet_index": pet_index}
    
    def _execute_pet_item_use(self, client_id, player_data, username, item_index, pet_index, item_name, pet_id):
        """执行宠物道具使用"""
        try:
            item_bag = player_data["道具背包"]
            pet_bag = player_data["宠物背包"]
            
            # 处理道具效果
            success, result_message, updated_pet = self._process_pet_item_use(item_name, pet_bag[pet_index])
            
            if success:
                # 更新数据
                pet_bag[pet_index] = updated_pet
                item_bag[item_index]["count"] -= 1
                if item_bag[item_index]["count"] <= 0:
                    item_bag.pop(item_index)
                
                # 保存并记录
                self.save_player_data(username, player_data)
                self.log('INFO', f"用户 {username} 对宠物 {pet_id} 使用道具 {item_name} 成功", 'PET_ITEM')
                
                return self.send_data(client_id, {
                    "type": "use_pet_item_response",
                    "success": True,
                    "message": result_message,
                    "updated_data": {"宠物背包": pet_bag, "道具背包": item_bag}
                })
            else:
                return self._send_pet_item_error(client_id, result_message)
                
        except Exception as e:
            self.log('ERROR', f"宠物使用道具处理失败: {str(e)}", 'PET_ITEM')
            return self._send_pet_item_error(client_id, "道具使用处理失败")
    
    def _send_pet_item_error(self, client_id, message):
        """发送宠物道具使用错误响应"""
        return self.send_data(client_id, {
            "type": "use_pet_item_response",
            "success": False,
            "message": message
        })
    
    def _process_pet_item_use(self, item_name, pet_data):
        """处理具体的宠物道具使用逻辑"""
        try:
            # 根据道具类型应用不同的效果
            if item_name == "不死图腾":
                # 启用死亡重生技能
                if "enable_death_respawn_skill" not in pet_data:
                    pet_data["enable_death_respawn_skill"] = True
                else:
                    pet_data["enable_death_respawn_skill"] = True
                if "respawn_health_percentage" not in pet_data:
                    pet_data["respawn_health_percentage"] = 0.5  # 重生时50%血量
                return True, f"宠物 {pet_data['pet_name']} 获得了死亡重生能力！", pet_data
                
            elif item_name == "荆棘护甲":
                # 启用反伤机制
                if "enable_damage_reflection_skill" not in pet_data:
                    pet_data["enable_damage_reflection_skill"] = True
                else:
                    pet_data["enable_damage_reflection_skill"] = True
                return True, f"宠物 {pet_data['pet_name']} 获得了荆棘护甲！", pet_data
                
            elif item_name == "狂暴药水":
                # 启用狂暴技能
                if "enable_berserker_skill" not in pet_data:
                    pet_data["enable_berserker_skill"] = True
                else:
                    pet_data["enable_berserker_skill"] = True
                return True, f"宠物 {pet_data['pet_name']} 获得了狂暴能力！", pet_data
                
            elif item_name == "援军令牌":
                # 启用召唤宠物技能
                if "enable_summon_pet_skill" not in pet_data:
                    pet_data["enable_summon_pet_skill"] = True
                else:
                    pet_data["enable_summon_pet_skill"] = True
                return True, f"宠物 {pet_data['pet_name']} 获得了援军召唤能力！", pet_data
                
            elif item_name in ["金刚图腾", "灵木图腾", "潮汐图腾", "烈焰图腾", "敦岩图腾"]:
                # 改变宠物元素
                element_map = {
                    "金刚图腾": "METAL",
                    "灵木图腾": "WOOD", 
                    "潮汐图腾": "WATER",
                    "烈焰图腾": "FIRE",
                    "敦岩图腾": "EARTH"
                }
                
                element_name_map = {
                    "金刚图腾": "金",
                    "灵木图腾": "木",
                    "潮汐图腾": "水", 
                    "烈焰图腾": "火",
                    "敦岩图腾": "土"
                }
                
                new_element = element_map[item_name]
                element_name = element_name_map[item_name]
                
                # 根据实际宠物数据结构更新元素类型
                pet_data["element_type"] = new_element
                # 如果没有元素伤害加成字段，则添加
                if "element_damage_bonus" not in pet_data:
                    pet_data["element_damage_bonus"] = 100.0
                
                return True, f"宠物 {pet_data['pet_name']} 的元素属性已改变为{element_name}元素！", pet_data
            
            else:
                return False, f"未知的宠物道具: {item_name}", None
                
        except Exception as e:
            self.log('ERROR', f"处理宠物道具效果失败: {str(e)}", 'PET_ITEM')
            return False, "道具效果处理失败", None
    
#==========================宠物使用道具处理==========================



#==========================农场道具使用处理==========================
    def _handle_use_farm_item(self, client_id, message):
        """处理农场道具使用请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "农场道具使用", "use_farm_item")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取请求参数
        item_name = message.get("item_name", "")
        
        if not item_name:
            return self.send_data(client_id, {
                "type": "use_farm_item_response",
                "success": False,
                "message": "缺少必要参数"
            })
        
        # 获取玩家数据
        username = self.user_data[client_id]["username"]
        player_data = self.load_player_data(username)
        
        if not player_data:
            return self.send_data(client_id, {
                "type": "use_farm_item_response",
                "success": False,
                "message": "玩家数据加载失败"
            })
        
        # 检查道具是否存在
        item_bag = player_data.get("道具背包", [])
        item_found = False
        item_index = -1
        
        for i, item in enumerate(item_bag):
            if item.get("name") == item_name:
                if item.get("count", 0) > 0:
                    item_found = True
                    item_index = i
                    break
        
        if not item_found:
            return self.send_data(client_id, {
                "type": "use_farm_item_response",
                "success": False,
                "message": f"道具 {item_name} 不足"
            })
        
        # 处理道具使用
        try:
            success, result_message, rewards = self._process_farm_item_use(item_name, player_data)
            
            if success:
                # 减少道具数量
                item_bag[item_index]["count"] -= 1
                if item_bag[item_index]["count"] <= 0:
                    item_bag.pop(item_index)
                
                # 应用奖励
                if "钱币" in rewards:
                    player_data["钱币"] += rewards["钱币"]
                if "经验值" in rewards:
                    player_data["经验值"] += rewards["经验值"]
                
                # 检查是否升级
                self._check_level_up(player_data)
                
                # 保存玩家数据
                self.save_player_data(username, player_data)
                
                # 发送成功响应
                response = {
                    "type": "use_farm_item_response",
                    "success": True,
                    "message": result_message,
                    "updated_data": {
                        "钱币": player_data["钱币"],
                        "经验值": player_data["经验值"],
                        "等级": player_data["等级"],
                        "道具背包": item_bag
                    }
                }
                
                self.log('INFO', f"用户 {username} 使用农场道具 {item_name} 成功", 'FARM_ITEM')
                
            else:
                # 发送失败响应
                response = {
                    "type": "use_farm_item_response",
                    "success": False,
                    "message": result_message
                }
            
            return self.send_data(client_id, response)
            
        except Exception as e:
            self.log('ERROR', f"农场道具使用处理失败: {str(e)}", 'FARM_ITEM')
            return self.send_data(client_id, {
                "type": "use_farm_item_response",
                "success": False,
                "message": "道具使用处理失败"
            })
    
    def _process_farm_item_use(self, item_name, player_data):
        """处理具体的农场道具使用逻辑"""
        try:
            rewards = {}
            
            if item_name == "小额经验卡":
                # 给玩家增加500经验
                rewards["经验值"] = 500
                return True, f"使用 {item_name} 成功！获得了500经验值", rewards
                
            elif item_name == "小额金币卡":
                # 给玩家增加500金币
                rewards["钱币"] = 500
                return True, f"使用 {item_name} 成功！获得了500金币", rewards
            
            else:
                return False, f"未知的农场道具: {item_name}", {}
                
        except Exception as e:
            self.log('ERROR', f"处理农场道具效果失败: {str(e)}", 'FARM_ITEM')
            return False, "道具效果处理失败", {}
    
#==========================农场道具使用处理==========================



#==========================道具配置数据处理==========================
    #处理客户端请求道具配置数据
    def _handle_item_config_request(self, client_id):
        """处理客户端请求道具配置数据"""
        item_config = self._load_item_config()
        
        if item_config:
            self.log('INFO', f"向客户端 {client_id} 发送道具配置数据，道具种类：{len(item_config)}", 'SERVER')
            return self.send_data(client_id, {
                "type": "item_config_response",
                "success": True,
                "item_config": item_config
            })
        else:
            return self.send_data(client_id, {
                "type": "item_config_response",
                "success": False,
                "message": "无法读取道具配置数据"
            })
    
    def _handle_pet_config_request(self, client_id):
        """处理客户端请求宠物配置数据"""
        pet_config = self._load_pet_config()
        
        if pet_config:
            self.log('INFO', f"向客户端 {client_id} 发送宠物配置数据，宠物种类：{len(pet_config)}", 'SERVER')
            return self.send_data(client_id, {
                "type": "pet_config_response",
                "success": True,
                "pet_config": pet_config
            })
        else:
            return self.send_data(client_id, {
                "type": "pet_config_response",
                "success": False,
                "message": "无法读取宠物配置数据"
            })
    
#==========================道具配置数据处理==========================

    #处理客户端请求游戏小提示配置数据
    def _handle_game_tips_config_request(self, client_id):
        """处理客户端请求游戏小提示配置数据"""
        game_tips_config = self._load_game_tips_config()
        
        if game_tips_config:
            self.log('INFO', f"向客户端 {client_id} 发送游戏小提示配置数据", 'SERVER')
            return self.send_data(client_id, {
                "type": "game_tips_config_response",
                "success": True,
                "game_tips_config": game_tips_config
            })
        else:
            return self.send_data(client_id, {
                "type": "game_tips_config_response",
                "success": False,
                "message": "无法读取游戏小提示配置数据"
            })


#==========================升级土地处理==========================
    #处理升级土地请求
    def _handle_upgrade_land(self, client_id, message):
        """处理升级土地请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "升级土地", "upgrade_land")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "upgrade_land")
        if not player_data:
            return self.send_data(client_id, response)
        
        lot_index = message.get("lot_index", -1)
        
        # 验证地块索引
        if lot_index < 0 or lot_index >= len(player_data.get("农场土地", [])):
            return self._send_action_error(client_id, "upgrade_land", "无效的地块索引")
        
        lot = player_data["农场土地"][lot_index]
        
        # 检查地块是否已开垦
        if not lot.get("is_diged", False):
            return self._send_action_error(client_id, "upgrade_land", "此地块尚未开垦")
        
        # 处理升级
        return self._process_land_upgrade(client_id, player_data, username, lot, lot_index)
    
    #辅助函数-处理土地升级逻辑
    def _process_land_upgrade(self, client_id, player_data, username, lot, lot_index):
        """处理土地升级逻辑"""
        # 土地升级配置
        upgrade_config = {
            0: {"cost": 1000, "name": "黄土地", "speed": 2.0},   # 0级->1级：1000元，2倍速
            1: {"cost": 2000, "name": "红土地", "speed": 4.0},   # 1级->2级：2000元，4倍速
            2: {"cost": 4000, "name": "紫土地", "speed": 6.0},   # 2级->3级：4000元，6倍速
            3: {"cost": 8000, "name": "黑土地", "speed": 10.0}   # 3级->4级：8000元，10倍速
        }
        
        # 获取当前土地等级
        current_level = lot.get("土地等级", 0)
        
        # 检查是否已达到最高等级
        if current_level >= 4:
            return self._send_action_error(client_id, "upgrade_land", "此土地已达到最高等级（黑土地）")
        
        # 检查升级配置是否存在
        if current_level not in upgrade_config:
            return self._send_action_error(client_id, "upgrade_land", f"土地等级数据异常，当前等级: {current_level}")
        
        # 获取升级配置
        config = upgrade_config[current_level]
        upgrade_cost = config["cost"]
        next_name = config["name"]
        next_level = current_level + 1
        speed_multiplier = config["speed"]
        
        # 检查玩家金钱是否足够
        if player_data["钱币"] < upgrade_cost:
            return self._send_action_error(client_id, "upgrade_land", f"金钱不足，升级到{next_name}需要 {upgrade_cost} 金钱")
        
        # 执行升级操作
        player_data["钱币"] -= upgrade_cost
        lot["土地等级"] = next_level
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        self.log('INFO', f"玩家 {username} 将地块 {lot_index} 升级到{next_level}级{next_name}，花费 {upgrade_cost} 金钱", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "upgrade_land",
            "success": True,
            "message": f"土地升级成功！升级到{next_level}级{next_name}，作物将以{speed_multiplier}倍速度生长",
            "updated_data": {
                "钱币": player_data["钱币"],
                "农场土地": player_data["农场土地"]
            }
        })
#==========================升级土地处理==========================



#==========================购买新地块处理==========================
    #处理购买新地块请求
    def _handle_buy_new_ground(self, client_id, message):
        """处理购买新地块请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "购买新地块", "buy_new_ground")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "buy_new_ground")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 处理购买新地块
        return self._process_buy_new_ground(client_id, player_data, username)
    
    #辅助函数-处理购买新地块逻辑
    def _process_buy_new_ground(self, client_id, player_data, username):
        """处理购买新地块逻辑"""
        # 购买新地块费用
        new_ground_cost = 2000
        
        # 检查玩家金钱是否足够
        if player_data["钱币"] < new_ground_cost:
            return self._send_action_error(client_id, "buy_new_ground", f"金钱不足，购买新地块需要 {new_ground_cost} 金钱")
        
        # 检查地块数量限制
        max_lots = 1000  # 最大地块数量限制
        current_lots = len(player_data.get("农场土地", []))
        if current_lots >= max_lots:
            return self._send_action_error(client_id, "buy_new_ground", f"已达到最大地块数量限制（{max_lots}个）")
        
        # 执行购买操作
        player_data["钱币"] -= new_ground_cost
        
        # 创建新的未开垦地块
        new_lot = {
            "crop_type": "",
            "grow_time": 0,
            "is_dead": False,
            "is_diged": False,  # 新购买的地块默认未开垦
            "is_planted": False,
            "max_grow_time": 5,
            "已浇水": False,
            "已施肥": False,
            "土地等级": 0
        }
        
        # 添加到农场地块数组
        if "农场土地" not in player_data:
            player_data["农场土地"] = []
        player_data["农场土地"].append(new_lot)
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 发送作物更新
        self._push_crop_update_to_player(username, player_data)
        
        new_lot_index = len(player_data["农场土地"])
        self.log('INFO', f"玩家 {username} 成功购买新地块，花费 {new_ground_cost} 金钱，新地块位置：{new_lot_index}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "buy_new_ground",
            "success": True,
            "message": f"购买新地块成功！花费 {new_ground_cost} 元，新地块位置：{new_lot_index}",
            "updated_data": {
                "钱币": player_data["钱币"],
                "农场土地": player_data["农场土地"]
            }
        })
    
#==========================购买新地块处理==========================



#==========================点赞玩家处理==========================
    #处理玩家点赞请求
    def _handle_like_player(self, client_id, message):
        """处理点赞请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "点赞玩家", "like_player")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "like_player")
        if not player_data:
            return self.send_data(client_id, response)
        
        target_username = message.get("target_username", "")
        
        if not target_username:
            return self.send_data(client_id, {
                "type": "like_player_response",
                "success": False,
                "message": "缺少目标用户名"
            })
        
        # 不能给自己点赞
        if target_username == username:
            return self.send_data(client_id, {
                "type": "like_player_response",
                "success": False,
                "message": "不能给自己点赞"
            })
        
        # 检查并更新每日点赞次数
        self._check_and_update_daily_likes(player_data)
        
        # 检查今日剩余点赞次数
        like_system = player_data.get("点赞系统", {})
        remaining_likes = like_system.get("今日剩余点赞次数", 10)
        if remaining_likes <= 0:
            return self.send_data(client_id, {
                "type": "like_player_response",
                "success": False,
                "message": "今日点赞次数已用完，明天再来吧！"
            })
        
        # 加载目标玩家数据
        target_player_data = self.load_player_data(target_username)
        
        if not target_player_data:
            return self.send_data(client_id, {
                "type": "like_player_response",
                "success": False,
                "message": f"无法找到玩家 {target_username} 的数据"
            })
        
        # 扣除点赞次数
        player_data["点赞系统"]["今日剩余点赞次数"] = remaining_likes - 1
        
        # 初始化目标玩家的点赞系统（如果不存在）
        if "点赞系统" not in target_player_data:
            target_player_data["点赞系统"] = {
                "今日剩余点赞次数": 10,
                "点赞上次刷新时间": datetime.datetime.now().strftime("%Y-%m-%d"),
                "总点赞数": 0
            }
        
        # 更新目标玩家的点赞数量
        target_player_data["点赞系统"]["总点赞数"] = target_player_data["点赞系统"].get("总点赞数", 0) + 1
        
        # 保存两个玩家的数据
        self.save_player_data(username, player_data)
        self.save_player_data(target_username, target_player_data)
        
        self.log('INFO', f"玩家 {username} 点赞了玩家 {target_username}，目标玩家点赞数：{target_player_data['点赞系统']['总点赞数']}，剩余点赞次数：{player_data['点赞系统']['今日剩余点赞次数']}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "like_player_response",
            "success": True,
            "message": f"成功点赞玩家 {target_username}！剩余点赞次数：{player_data['点赞系统']['今日剩余点赞次数']}",
            "target_likes": target_player_data["点赞系统"]["总点赞数"],
            "remaining_likes": player_data["点赞系统"]["今日剩余点赞次数"]
        })
    #检查并更新每日点赞次数
    def _check_and_update_daily_likes(self, player_data):
        """检查并更新每日点赞次数（每天重置为10次）"""
        import datetime
        
        current_date = datetime.datetime.now().strftime("%Y-%m-%d")
        
        # 初始化点赞系统
        if "点赞系统" not in player_data:
            player_data["点赞系统"] = {
                "今日剩余点赞次数": 10,
                "点赞上次刷新时间": current_date,
                "总点赞数": 0
            }
            return True  # 发生了初始化
        
        like_system = player_data["点赞系统"]
        
        # 确保必要字段存在
        if "今日剩余点赞次数" not in like_system:
            like_system["今日剩余点赞次数"] = 10
        if "点赞上次刷新时间" not in like_system:
            like_system["点赞上次刷新时间"] = current_date
        if "总点赞数" not in like_system:
            like_system["总点赞数"] = 0
        
        # 检查是否需要每日重置
        last_refresh_date = like_system.get("点赞上次刷新时间", "")
        if last_refresh_date != current_date:
            # 新的一天，重置点赞次数
            like_system["今日剩余点赞次数"] = 10
            like_system["点赞上次刷新时间"] = current_date
            return True  # 发生了重置
        
        return False  # 没有重置

    #清理在线礼包历史数据
    def _cleanup_online_gift_history(self, player_data):
        """清理过期的在线礼包数据（只保留当天的数据）并删除旧的英文格式"""
        import datetime
        
        current_date = datetime.datetime.now().strftime("%Y-%m-%d")
        
        # 清理旧的英文格式数据
        if "online_gift" in player_data:
            del player_data["online_gift"]
            self.log('INFO', f"已清理玩家数据中的旧英文在线礼包格式", 'SERVER')
        
        # 初始化在线礼包数据
        if "在线礼包" not in player_data:
            player_data["在线礼包"] = {
                "当前日期": current_date,
                "今日在线时长": 0.0,
                "已领取礼包": [],
                "登录时间": time.time()
            }
            return
        
        online_gift_data = player_data["在线礼包"]
        
        # 检查是否是新的一天
        last_date = online_gift_data.get("当前日期", "")
        if last_date != current_date:
            # 新的一天，重置所有数据
            player_data["在线礼包"] = {
                "当前日期": current_date,
                "今日在线时长": 0.0,
                "已领取礼包": [],
                "登录时间": time.time()
            }
            self.log('INFO', f"在线礼包数据已重置到新日期：{current_date}", 'SERVER')
    
    #清理新手礼包历史数据
    def _cleanup_new_player_gift_history(self, player_data):
        """清理旧的英文新手礼包数据并转换为中文格式"""
        import datetime
        
        # 检查是否有旧的英文数据
        old_claimed = player_data.get("new_player_gift_claimed", False)
        old_time = player_data.get("new_player_gift_time", "")
        
        if old_claimed or old_time:
            # 转换为中文格式
            if "新手礼包" not in player_data:
                player_data["新手礼包"] = {}
            
            if old_claimed:
                player_data["新手礼包"]["已领取"] = True
                player_data["新手礼包"]["领取时间"] = old_time if old_time else datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            
            # 删除旧的英文字段
            if "new_player_gift_claimed" in player_data:
                del player_data["new_player_gift_claimed"]
            if "new_player_gift_time" in player_data:
                del player_data["new_player_gift_time"]
            
            self.log('INFO', f"已清理玩家数据中的旧英文新手礼包格式", 'SERVER')

    def _cleanup_stamina_system_history(self, player_data):
        """清理旧的体力系统数据，迁移到新的"体力系统"对象"""
        if "体力值" in player_data or "体力上次刷新时间" in player_data or "体力上次恢复时间" in player_data:
            # 加载体力系统配置
            stamina_config = self._load_stamina_config()
            max_stamina = stamina_config.get("最大体力值", 20)
            
            # 保存旧的体力数据
            old_stamina = player_data.get("体力值", 20)
            old_refresh_time = player_data.get("体力上次刷新时间", "")
            old_recovery_time = player_data.get("体力上次恢复时间", 0)
            
            # 创建新的体力系统对象
            if "体力系统" not in player_data:
                player_data["体力系统"] = {}
            
            stamina_system = player_data["体力系统"]
            
            # 迁移数据到新格式
            stamina_system["当前体力值"] = old_stamina
            stamina_system["最大体力值"] = max_stamina
            stamina_system["上次刷新时间"] = old_refresh_time
            stamina_system["上次恢复时间"] = old_recovery_time
            
            # 移除旧的体力数据
            if "体力值" in player_data:
                del player_data["体力值"]
            if "体力上次刷新时间" in player_data:
                del player_data["体力上次刷新时间"]
            if "体力上次恢复时间" in player_data:
                del player_data["体力上次恢复时间"]
                
            self.log('INFO', f"已清理玩家数据中的旧体力系统格式，迁移到新的体力系统对象", 'SERVER')

    def _load_stamina_config(self):
        """加载体力系统配置"""
        # 优先从MongoDB加载配置
        if self.use_mongodb and self.mongo_api and self.mongo_api.is_connected():
            try:
                config_data = self.mongo_api.get_stamina_config()
                if config_data:
                    self.log('INFO', '成功从MongoDB加载体力系统配置', 'SERVER')
                    return config_data.get("体力系统配置", {})
                else:
                    self.log('WARNING', '从MongoDB获取体力系统配置失败，回退到JSON文件', 'SERVER')
            except Exception as e:
                self.log('ERROR', f'从MongoDB加载体力系统配置时发生错误: {e}，回退到JSON文件', 'SERVER')
        
        # 回退到JSON文件
        try:
            config_path = os.path.join(os.path.dirname(__file__), "config", "stamina_config.json")
            with open(config_path, 'r', encoding='utf-8') as file:
                config_data = json.load(file)
                self.log('INFO', '从JSON文件加载体力系统配置', 'SERVER')
                return config_data.get("体力系统配置", {})
        except FileNotFoundError:
            self.log('WARNING', f"体力系统配置文件未找到，使用默认配置", 'SERVER')
            return {
                "最大体力值": 20,
                "每小时恢复体力": 1,
                "恢复间隔秒数": 3600,
                "新玩家初始体力": 20
            }
        except json.JSONDecodeError as e:
            self.log('ERROR', f"体力系统配置文件格式错误: {e}", 'SERVER')
            return {
                "最大体力值": 20,
                "每小时恢复体力": 1,
                "恢复间隔秒数": 3600,
                "新玩家初始体力": 20
            }
        except Exception as e:
            self.log('ERROR', f"加载体力系统配置时发生错误: {e}", 'SERVER')
            return {
                "最大体力值": 20,
                "每小时恢复体力": 1,
                "恢复间隔秒数": 3600,
                "新玩家初始体力": 20
            }

#==========================点赞玩家处理==========================



#==========================在线玩家处理==========================
    #处理请求在线玩家请求
    def _handle_online_players_request(self, client_id, message):
        """处理获取在线玩家数量的请求"""
        online_players = len([cid for cid in self.user_data if self.user_data[cid].get("logged_in", False)])
        return self.send_data(client_id, {
            "type": "online_players_response",
            "success": True,
            "online_players": online_players
        })
    
#==========================在线玩家处理==========================



#==========================玩家体力值处理==========================
    #检查并更新体力值
    def _check_and_update_stamina(self, player_data):
        """检查并更新体力值（每小时恢复1点，每天重置）"""
        import datetime
        
        current_time = time.time()
        current_date = datetime.datetime.now().strftime("%Y-%m-%d")
        
        # 加载体力系统配置
        stamina_config = self._load_stamina_config()
        max_stamina = stamina_config.get("最大体力值", 20)
        recovery_amount = stamina_config.get("每小时恢复体力", 1)
        recovery_interval = stamina_config.get("恢复间隔秒数", 3600)
        initial_stamina = stamina_config.get("新玩家初始体力", 20)
        
        # 获取或创建体力系统对象
        if "体力系统" not in player_data:
            player_data["体力系统"] = {
                "当前体力值": initial_stamina,
                "最大体力值": max_stamina,
                "上次刷新时间": current_date,
                "上次恢复时间": current_time
            }
        
        stamina_system = player_data["体力系统"]
        
        # 确保最大体力值与配置同步
        stamina_system["最大体力值"] = max_stamina
        
        # 检查是否需要每日重置
        last_refresh_date = stamina_system.get("上次刷新时间", "")
        if last_refresh_date != current_date:
            # 新的一天，重置体力值
            stamina_system["当前体力值"] = max_stamina
            stamina_system["上次刷新时间"] = current_date
            stamina_system["上次恢复时间"] = current_time
            return True  # 发生了重置
        
        # 检查每小时恢复
        last_recovery_time = stamina_system.get("上次恢复时间", current_time)
        time_diff = current_time - last_recovery_time
        
        # 如果超过恢复间隔时间，恢复体力值
        if time_diff >= recovery_interval:
            recovery_cycles = int(time_diff // recovery_interval)
            current_stamina = stamina_system.get("当前体力值", 0)
            
            # 体力值恢复，但不能超过最大值
            new_stamina = min(max_stamina, current_stamina + (recovery_cycles * recovery_amount))
            if new_stamina > current_stamina:
                stamina_system["当前体力值"] = new_stamina
                stamina_system["上次恢复时间"] = current_time
                return True  # 发生了恢复
        
        return False  # 没有变化
    
    #消耗体力值
    def _consume_stamina(self, player_data, amount, action_name):
        """消耗体力值"""
        stamina_system = player_data.get("体力系统", {})
        current_stamina = stamina_system.get("当前体力值", 20)
        
        if current_stamina < amount:
            return False, f"体力值不足！{action_name}需要 {amount} 点体力，当前体力：{current_stamina}"
        
        stamina_system["当前体力值"] = current_stamina - amount
        return True, f"消耗 {amount} 点体力，剩余体力：{stamina_system['当前体力值']}"
    
    #检查体力值是否足够
    def _check_stamina_sufficient(self, player_data, amount):
        """检查体力值是否足够"""
        stamina_system = player_data.get("体力系统", {})
        current_stamina = stamina_system.get("当前体力值", 20)
        return current_stamina >= amount


    def _check_and_update_register_time(self, player_data, username):
        """检查并更新已存在玩家的注册时间"""
        default_register_time = "2025年05月21日15时00分00秒"
        
        # 如果玩家没有注册时间字段，设为默认值（老玩家）
        if "注册时间" not in player_data:
            player_data["注册时间"] = default_register_time
            self.save_player_data(username, player_data)
            self.log('INFO', f"为已存在玩家 {username} 设置默认注册时间", 'SERVER')
    
    def _check_and_fix_wisdom_tree_config(self, player_data, username):
        """检查并修复智慧树配置"""
        import time
        current_time = int(time.time())
        
        # 初始化智慧树配置（如果不存在）
        if "智慧树配置" not in player_data:
            player_data["智慧树配置"] = {
                "距离上一次杀虫时间": current_time,
                "距离上一次除草时间": current_time,
                "智慧树显示的话": "",
                "等级": 1,
                "当前经验值": 0,
                "最大经验值": 100,
                "最大生命值": 100,
                "当前生命值": 100,
                "高度": 20
            }
            self.log('INFO', f"为玩家 {username} 初始化智慧树配置", 'SERVER')
        else:
            # 检查并修复已存在的智慧树配置
            wisdom_tree_config = player_data["智慧树配置"]
            config_fixed = False
            
            # 修复空字符串或无效的时间戳
            if "距离上一次除草时间" not in wisdom_tree_config or not wisdom_tree_config["距离上一次除草时间"] or wisdom_tree_config["距离上一次除草时间"] == "":
                wisdom_tree_config["距离上一次除草时间"] = current_time
                config_fixed = True
                
            if "距离上一次杀虫时间" not in wisdom_tree_config or not wisdom_tree_config["距离上一次杀虫时间"] or wisdom_tree_config["距离上一次杀虫时间"] == "":
                wisdom_tree_config["距离上一次杀虫时间"] = current_time
                config_fixed = True
                
            if "上次护理时间" not in wisdom_tree_config or not wisdom_tree_config["上次护理时间"]:
                wisdom_tree_config["上次护理时间"] = current_time
                config_fixed = True
                
            # 确保其他必需字段存在并转换旧格式
            if "等级" not in wisdom_tree_config:
                wisdom_tree_config["等级"] = 1
                config_fixed = True
            if "当前经验值" not in wisdom_tree_config:
                # 兼容旧的"经验"字段
                old_exp = wisdom_tree_config.get("经验", 0)
                wisdom_tree_config["当前经验值"] = old_exp
                if "经验" in wisdom_tree_config:
                    del wisdom_tree_config["经验"]
                config_fixed = True
            if "最大经验值" not in wisdom_tree_config:
                wisdom_tree_config["最大经验值"] = self._calculate_wisdom_tree_max_exp(wisdom_tree_config.get("等级", 1))
                config_fixed = True
            if "当前生命值" not in wisdom_tree_config:
                # 兼容旧的"生命值"字段
                old_health = wisdom_tree_config.get("生命值", 100)
                wisdom_tree_config["当前生命值"] = old_health
                if "生命值" in wisdom_tree_config:
                    del wisdom_tree_config["生命值"]  # 删除旧字段
                config_fixed = True
            if "最大生命值" not in wisdom_tree_config:
                wisdom_tree_config["最大生命值"] = 100
                config_fixed = True
            if "高度" not in wisdom_tree_config:
                wisdom_tree_config["高度"] = 20
                config_fixed = True
            if "智慧树显示的话" not in wisdom_tree_config:
                wisdom_tree_config["智慧树显示的话"] = ""
                config_fixed = True
                
            if config_fixed:
                self.log('INFO', f"为玩家 {username} 修复智慧树配置", 'SERVER')
    
    def _calculate_wisdom_tree_max_exp(self, level):
        """计算智慧树指定等级的最大经验值
        使用前期升级快，后期愈来愈慢的公式
        """
        if level <= 1:
            return 100
        # 使用指数增长公式：基础经验 * (等级^1.5) * 1.2
        base_exp = 50
        exp_multiplier = 1.2
        level_factor = pow(level, 1.5)
        max_exp = int(base_exp * level_factor * exp_multiplier)
        return max_exp
    
#==========================玩家体力值处理==========================



#==========================游戏设置处理==========================
    def _handle_save_game_settings(self, client_id, message):
        """处理保存游戏设置请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "保存游戏设置", "save_game_settings")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "save_game_settings")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 获取设置数据
        settings = message.get("settings", {})
        if not settings:
            return self.send_data(client_id, {
                "type": "save_game_settings_response",
                "success": False,
                "message": "设置数据为空"
            })
        
        # 验证设置数据格式
        valid_settings = {}
        
        # 验证背景音乐音量 (0.0-1.0)
        if "背景音乐音量" in settings:
            volume = settings["背景音乐音量"]
            if isinstance(volume, (int, float)) and 0.0 <= volume <= 1.0:
                valid_settings["背景音乐音量"] = float(volume)
            else:
                return self.send_data(client_id, {
                    "type": "save_game_settings_response",
                    "success": False,
                    "message": "背景音乐音量值无效，应在0.0-1.0之间"
                })
        
        # 验证天气显示设置
        if "天气显示" in settings:
            weather_display = settings["天气显示"]
            if isinstance(weather_display, bool):
                valid_settings["天气显示"] = weather_display
            else:
                return self.send_data(client_id, {
                    "type": "save_game_settings_response",
                    "success": False,
                    "message": "天气显示设置值无效，应为布尔值"
                })
        
        # 保存设置到玩家数据
        if "游戏设置" not in player_data:
            player_data["游戏设置"] = {}
        
        player_data["游戏设置"].update(valid_settings)
        
        # 保存到数据库
        if self.save_player_data(username, player_data):
            self.log('INFO', f"用户 {username} 保存游戏设置: {valid_settings}", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "save_game_settings_response",
                "success": True,
                "message": "游戏设置保存成功",
                "settings": valid_settings
            })
        else:
            return self.send_data(client_id, {
                "type": "save_game_settings_response",
                "success": False,
                "message": "保存游戏设置失败"
            })
#==========================游戏设置处理==========================
    


#==========================玩家游玩时间处理==========================
    #处理获取玩家游玩时间请求
    def _handle_get_play_time(self, client_id):
        """处理获取游玩时间请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "获取游玩时间")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "play_time")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 计算当前会话的游玩时间
        login_timestamp = self.user_data[client_id].get("login_timestamp", time.time())
        current_session_seconds = int(time.time() - login_timestamp)
        
        # 格式化当前会话时间
        current_hours = current_session_seconds // 3600
        current_minutes = (current_session_seconds % 3600) // 60
        current_seconds = current_session_seconds % 60
        current_session_time = f"{current_hours}时{current_minutes}分{current_seconds}秒"
        
        # 获取最后登录时间和总游玩时间
        last_login_time = player_data.get("最后登录时间", "未知")
        total_login_time = player_data.get("总游玩时间", "0时0分0秒")
        
        self.log('INFO', f"玩家 {username} 请求游玩时间统计", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "play_time_response",
            "success": True,
            "最后登录时间": last_login_time,
            "总游玩时间": total_login_time,
            "current_session_time": current_session_time
        })
    
    #处理更新游玩时间请求
    def _handle_update_play_time(self, client_id):
        """处理更新游玩时间请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "更新游玩时间", "update_time")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "update_time")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 计算当前会话的游玩时间
        login_timestamp = self.user_data[client_id].get("login_timestamp", time.time())
        play_time_seconds = int(time.time() - login_timestamp)
        
        # 解析现有的总游玩时间
        total_time_str = player_data.get("总游玩时间", "0时0分0秒")
        time_parts = re.match(r"(?:(\d+)时)?(?:(\d+)分)?(?:(\d+)秒)?", total_time_str)
        
        if time_parts:
            hours = int(time_parts.group(1) or 0)
            minutes = int(time_parts.group(2) or 0)
            seconds = int(time_parts.group(3) or 0)
            
            # 计算新的总游玩时间
            total_seconds = hours * 3600 + minutes * 60 + seconds + play_time_seconds
            new_hours = total_seconds // 3600
            new_minutes = (total_seconds % 3600) // 60
            new_seconds = total_seconds % 60
            
            # 更新总游玩时间
            player_data["总游玩时间"] = f"{new_hours}时{new_minutes}分{new_seconds}秒"
            
            # 保存玩家数据
            self.save_player_data(username, player_data)
            
            # 重置登录时间戳，以便下次计算
            self.user_data[client_id]["login_timestamp"] = time.time()
            
            self.log('INFO', f"已更新玩家 {username} 的游玩时间，当前游玩时间: {play_time_seconds} 秒，总游玩时间: {player_data['总游玩时间']}", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "update_time_response",
                "success": True,
                "message": "游玩时间已更新",
                "总游玩时间": player_data["总游玩时间"]
            })
        else:
            self.log('ERROR', f"解析玩家 {username} 的游玩时间失败", 'SERVER')
            return self.send_data(client_id, {
                "type": "update_time_response",
                "success": False,
                "message": "更新游玩时间失败，格式错误"
            })
#==========================玩家游玩时间处理==========================



#==========================玩家排行榜处理==========================
    #处理获取玩家排行榜请求
    def _handle_player_rankings_request(self, client_id, message):
        """处理获取玩家排行榜的请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "获取玩家排行榜", "player_rankings")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取排序和筛选参数
        sort_by = message.get("sort_by", "等级")  # 排序字段
        sort_order = message.get("sort_order", "desc")  # 排序顺序
        filter_online = message.get("filter_online", False)  # 是否只显示在线玩家
        search_qq = message.get("search_qq", "")  # 搜索的QQ号
        
        try:
            players_data = []
            total_registered_players = 0
            
            # 优先使用MongoDB
            if self.use_mongodb and self.mongo_api:
                # 获取所有玩家基本信息
                all_players = self.mongo_api.get_all_players_basic_info()
                total_registered_players = len(all_players)
                
                for player_data in all_players:
                    account_id = player_data.get("玩家账号", "")
                    
                    # 如果有搜索条件，先检查是否匹配
                    if search_qq and search_qq not in account_id:
                        continue
                    
                    # 统计背包中的种子数量
                    seed_count = sum(item.get("count", 0) for item in player_data.get("种子仓库", []))
                    
                    # 检查玩家是否在线
                    is_online = any(
                        user_info.get("username") == account_id and user_info.get("logged_in", False) 
                        for user_info in self.user_data.values()
                    )
                    
                    # 如果筛选在线玩家，跳过离线玩家
                    if filter_online and not is_online:
                        continue
                    
                    # 解析总游玩时间为秒数（用于排序）
                    total_time_str = player_data.get("总游玩时间", "0时0分0秒")
                    total_time_seconds = self._parse_time_to_seconds(total_time_str)
                    
                    # 解析最后登录时间为时间戳（用于排序）
                    last_login_str = player_data.get("最后登录时间", "未知")
                    last_login_timestamp = self._parse_login_time_to_timestamp(last_login_str)
                    
                    # 获取体力值
                    stamina_system = player_data.get("体力系统", {})
                    current_stamina = stamina_system.get("当前体力值", 20)
                    
                    player_info = {
                        "玩家账号": account_id,
                        "玩家昵称": player_data.get("玩家昵称", account_id),
                        "农场名称": player_data.get("农场名称", ""),
                        "等级": player_data.get("等级", 1),
                        "钱币": player_data.get("钱币", 0),
                        "经验值": player_data.get("经验值", 0),
                        "体力值": current_stamina,
                        "seed_count": seed_count,
                        "最后登录时间": last_login_str,
                        "last_login_timestamp": last_login_timestamp,
                        "总游玩时间": total_time_str,
                        "total_time_seconds": total_time_seconds,
                        "like_num": player_data.get("点赞系统", {}).get("总点赞数", 0),
                        "is_online": is_online
                    }
                    
                    players_data.append(player_info)
            else:
                # 降级到文件系统
                save_files = glob.glob(os.path.join("game_saves", "*.json"))
                total_registered_players = len(save_files)
                
                for save_file in save_files:
                    try:
                        # 从文件名提取账号ID
                        account_id = os.path.basename(save_file).split('.')[0]
                        
                        # 如果有搜索条件，先检查是否匹配
                        if search_qq and search_qq not in account_id:
                            continue
                        
                        # 加载玩家数据
                        with open(save_file, 'r', encoding='utf-8') as file:
                            player_data = json.load(file)
                        
                        if player_data:
                            # 统计背包中的种子数量
                            seed_count = sum(item.get("count", 0) for item in player_data.get("种子仓库", []))
                            
                            # 检查玩家是否在线
                            is_online = any(
                                user_info.get("username") == account_id and user_info.get("logged_in", False) 
                                for user_info in self.user_data.values()
                            )
                            
                            # 如果筛选在线玩家，跳过离线玩家
                            if filter_online and not is_online:
                                continue
                            
                            # 解析总游玩时间为秒数（用于排序）
                            total_time_str = player_data.get("总游玩时间", "0时0分0秒")
                            total_time_seconds = self._parse_time_to_seconds(total_time_str)
                            
                            # 解析最后登录时间为时间戳（用于排序）
                            last_login_str = player_data.get("最后登录时间", "未知")
                            last_login_timestamp = self._parse_login_time_to_timestamp(last_login_str)
                            
                            # 获取所需的玩家信息
                            stamina_system = player_data.get("体力系统", {})
                            current_stamina = stamina_system.get("当前体力值", 20)
                            
                            player_info = {
                                "玩家账号": player_data.get("玩家账号", account_id),
                                "玩家昵称": player_data.get("玩家昵称", player_data.get("玩家账号", account_id)),
                                "农场名称": player_data.get("农场名称", ""),
                                "等级": player_data.get("等级", 1),
                                "钱币": player_data.get("钱币", 0),
                                "经验值": player_data.get("经验值", 0),
                                "体力值": current_stamina,
                                "seed_count": seed_count,
                                "最后登录时间": last_login_str,
                                "last_login_timestamp": last_login_timestamp,
                                "总游玩时间": total_time_str,
                                "total_time_seconds": total_time_seconds,
                                "like_num": player_data.get("点赞系统", {}).get("总点赞数", 0),
                                "is_online": is_online
                            }
                            
                            players_data.append(player_info)
                    except Exception as e:
                        self.log('ERROR', f"读取玩家 {account_id} 的数据时出错: {str(e)}", 'SERVER')
            
            # 根据排序参数进行排序
            reverse_order = (sort_order == "desc")
            
            if sort_by == "seed_count":
                players_data.sort(key=lambda x: x["seed_count"], reverse=reverse_order)
            elif sort_by == "等级":
                players_data.sort(key=lambda x: x["等级"], reverse=reverse_order)
            elif sort_by == "online_time":
                players_data.sort(key=lambda x: x["total_time_seconds"], reverse=reverse_order)
            elif sort_by == "login_time":
                players_data.sort(key=lambda x: x["last_login_timestamp"], reverse=reverse_order)
            elif sort_by == "like_num":
                players_data.sort(key=lambda x: x["like_num"], reverse=reverse_order)
            elif sort_by == "钱币":
                players_data.sort(key=lambda x: x["钱币"], reverse=reverse_order)
            else:
                # 默认按等级排序
                players_data.sort(key=lambda x: x["等级"], reverse=True)
            
            # 统计在线玩家数量
            online_count = sum(1 for player in players_data if player.get("is_online", False))
            
            # 记录日志
            search_info = f"，搜索QQ：{search_qq}" if search_qq else ""
            filter_info = "，仅在线玩家" if filter_online else ""
            sort_info = f"，按{sort_by}{'降序' if reverse_order else '升序'}排序"
            
            self.log('INFO', f"玩家 {self.user_data[client_id].get('username')} 请求玩家排行榜{search_info}{filter_info}{sort_info}，返回 {len(players_data)} 个玩家数据，注册总人数：{total_registered_players}，在线人数：{online_count}", 'SERVER')
            
            # 返回排行榜数据（包含注册总人数）
            return self.send_data(client_id, {
                "type": "player_rankings_response",
                "success": True,
                "players": players_data,
                "total_registered_players": total_registered_players,
                "sort_by": sort_by,
                "sort_order": sort_order,
                "filter_online": filter_online,
                "search_qq": search_qq
            })
            
        except Exception as e:
            self.log('ERROR', f"处理玩家排行榜请求时出错: {str(e)}", 'SERVER')
            return self.send_data(client_id, {
                "type": "player_rankings_response",
                "success": False,
                "message": "获取排行榜数据失败"
            })
    
    # 辅助函数：将时间字符串转换为秒数
    def _parse_time_to_seconds(self, time_str):
        """将时间字符串（如'1时30分45秒'）转换为总秒数"""
        try:
            import re
            # 使用正则表达式提取时、分、秒
            pattern = r'(\d+)时(\d+)分(\d+)秒'
            match = re.match(pattern, time_str)
            if match:
                hours = int(match.group(1))
                minutes = int(match.group(2))
                seconds = int(match.group(3))
                return hours * 3600 + minutes * 60 + seconds
            return 0
        except:
            return 0
    
    # 辅助函数：将登录时间字符串转换为时间戳
    def _parse_login_time_to_timestamp(self, login_time_str):
        """将登录时间字符串转换为时间戳用于排序"""
        try:
            if login_time_str == "未知":
                return 0
            # 解析格式：2024年01月01日12时30分45秒
            import datetime
            dt = datetime.datetime.strptime(login_time_str, "%Y年%m月%d日%H时%M分%S秒")
            return dt.timestamp()
        except:
            return 0
#==========================玩家排行榜处理==========================



#==========================作物数据处理==========================
    #处理客户端请求作物数据
    def _handle_crop_data_request(self, client_id):
        """处理客户端请求作物数据"""
        crop_data = self._load_crop_data()
        
        if crop_data:
            self.log('INFO', f"向客户端 {client_id} 发送作物数据", 'SERVER')
            return self.send_data(client_id, {
                "type": "crop_data_response",
                "success": True,
                "crop_data": crop_data
            })
        else:
            return self.send_data(client_id, {
                "type": "crop_data_response",
                "success": False,
                "message": "无法读取作物数据"
            })
#==========================作物数据处理==========================


#==========================访问其他玩家农场处理==========================
    #处理访问其他玩家农场的请求
    def _handle_visit_player_request(self, client_id, message):
        """处理访问其他玩家农场的请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "访问玩家农场", "visit_player")
        if not logged_in:
            return self.send_data(client_id, response)
        
        target_username = message.get("target_username", "")
        
        if not target_username:
            return self.send_data(client_id, {
                "type": "visit_player_response",
                "success": False,
                "message": "缺少目标用户名"
            })
        
        # 加载目标玩家数据
        target_player_data = self.load_player_data(target_username)
        
        if not target_player_data:
            return self.send_data(client_id, {
                "type": "visit_player_response",
                "success": False,
                "message": f"无法找到玩家 {target_username} 的数据"
            })
        
        # 检查并修复目标玩家的智慧树配置格式
        self._check_and_fix_wisdom_tree_config(target_player_data, target_username)
        
        # 返回目标玩家的农场数据（只返回可见的数据，不包含敏感信息如密码）
        target_stamina_system = target_player_data.get("体力系统", {})
        target_current_stamina = target_stamina_system.get("当前体力值", 20)
        
        safe_player_data = {
            "玩家账号": target_player_data.get("玩家账号", target_username),
            "username": target_username,  # 添加username字段，用于购买商品时标识卖家
            "玩家昵称": target_player_data.get("玩家昵称", target_username),
            "农场名称": target_player_data.get("农场名称", ""),
            "等级": target_player_data.get("等级", 1),
            "钱币": target_player_data.get("钱币", 0),
            "经验值": target_player_data.get("经验值", 0),
            "体力值": target_current_stamina,
            "农场土地": target_player_data.get("农场土地", []),
            "种子仓库": target_player_data.get("种子仓库", []),
            "作物仓库": target_player_data.get("作物仓库", []),
            "道具背包": target_player_data.get("道具背包", []),
            "宠物背包": target_player_data.get("宠物背包", []),
            "巡逻宠物": self._convert_patrol_pets_to_full_data(target_player_data),
            "出战宠物": self._convert_battle_pets_to_full_data(target_player_data),
            "稻草人配置": target_player_data.get("稻草人配置", {}),
            "智慧树配置": target_player_data.get("智慧树配置", {}),
            "小卖部配置": target_player_data.get("小卖部配置", {"商品列表": [], "格子数": 10}),  # 添加小卖部配置
            "点赞数": target_player_data.get("点赞系统", {}).get("总点赞数", 0),  # 添加点赞数
            "最后登录时间": target_player_data.get("最后登录时间", "未知"),
            "总游玩时间": target_player_data.get("总游玩时间", "0时0分0秒"),
            "total_likes": target_player_data.get("total_likes", 0),
            "访问系统": target_player_data.get("访问系统", {
                "总访问人数": 0,
                "今日访问人数": 0,
                "访问记录": {}
            })  # 添加访问系统数据
        }
        
        current_username = self.user_data[client_id]["username"]
        
        # 更新被访问玩家的访问系统数据
        self._update_visit_system(target_username, current_username)
        
        self.log('INFO', f"玩家 {current_username} 访问了玩家 {target_username} 的农场", 'SERVER')
        
        # 记录玩家的访问状态
        self.user_data[client_id]["visiting_mode"] = True
        self.user_data[client_id]["visiting_target"] = target_username
        
        return self.send_data(client_id, {
            "type": "visit_player_response",
            "success": True,
            "message": f"成功获取玩家 {target_username} 的农场数据",
            "player_data": safe_player_data,
            "is_visiting": True
        })
#==========================访问其他玩家农场处理==========================

# ==========================返回自己农场处理==========================
    def _update_visit_system(self, target_username, visitor_username):
        """更新被访问玩家的访问系统数据"""
        try:
            # 加载被访问玩家的数据
            target_player_data = self.load_player_data(target_username)
            if not target_player_data:
                self.log('ERROR', f"无法加载被访问玩家 {target_username} 的数据", 'SERVER')
                return
            
            # 获取访问者的昵称
            visitor_player_data = self.load_player_data(visitor_username)
            visitor_nickname = visitor_player_data.get("玩家昵称", visitor_username) if visitor_player_data else visitor_username
            
            # 初始化访问系统（如果不存在）
            if "访问系统" not in target_player_data:
                target_player_data["访问系统"] = {
                    "总访问人数": 0,
                    "今日访问人数": 0,
                    "访问记录": {}
                }
            
            visit_system = target_player_data["访问系统"]
            
            # 获取今日日期
            from datetime import datetime
            today = datetime.now().strftime("%Y-%m-%d")
            
            # 更新总访问人数
            visit_system["总访问人数"] = visit_system.get("总访问人数", 0) + 1
            
            # 检查是否需要重置今日访问人数（新的一天）
            last_visit_date = visit_system.get("最后访问日期", "")
            if last_visit_date != today:
                visit_system["今日访问人数"] = 0
                visit_system["最后访问日期"] = today
            
            # 更新今日访问人数
            visit_system["今日访问人数"] = visit_system.get("今日访问人数", 0) + 1
            
            # 更新访问记录
            if "访问记录" not in visit_system:
                visit_system["访问记录"] = {}
            
            if today not in visit_system["访问记录"]:
                visit_system["访问记录"][today] = []
            
            # 添加访问者昵称到今日访问记录（避免重复）
            if visitor_nickname not in visit_system["访问记录"][today]:
                visit_system["访问记录"][today].append(visitor_nickname)
            
            # 保存更新后的数据
            if self.save_player_data(target_username, target_player_data):
                self.log('INFO', f"成功更新玩家 {target_username} 的访问系统数据，访问者: {visitor_nickname}", 'SERVER')
            else:
                self.log('ERROR', f"保存玩家 {target_username} 的访问系统数据失败", 'SERVER')
                
        except Exception as e:
            self.log('ERROR', f"更新访问系统数据时出错: {e}", 'SERVER')
    
    def _reset_daily_visit_count(self):
        """重置所有玩家的今日访问人数（凌晨调用）"""
        try:
            # 获取所有玩家的基本信息
            if hasattr(self, 'mongo_api') and self.mongo_api:
                players_info = self.mongo_api.get_all_players_basic_info()
                
                from datetime import datetime
                today = datetime.now().strftime("%Y-%m-%d")
                
                reset_count = 0
                for player_info in players_info:
                    username = player_info.get("玩家账号")
                    if username:
                        player_data = self.load_player_data(username)
                        if player_data and "访问系统" in player_data:
                            visit_system = player_data["访问系统"]
                            last_visit_date = visit_system.get("最后访问日期", "")
                            
                            # 如果不是今天，重置今日访问人数
                            if last_visit_date != today:
                                visit_system["今日访问人数"] = 0
                                visit_system["最后访问日期"] = today
                                
                                if self.save_player_data(username, player_data):
                                    reset_count += 1
                
                self.log('INFO', f"成功重置了 {reset_count} 个玩家的今日访问人数", 'SERVER')
            
        except Exception as e:
            self.log('ERROR', f"重置今日访问人数时出错: {e}", 'SERVER')
    
    def _handle_give_money_request(self, client_id, message):
        """处理送金币请求"""
        try:
            # 获取发送者信息
            sender_info = self.user_data.get(client_id)
            if not sender_info or not sender_info.get("logged_in", False):
                self.send_data(client_id, {
                    "type": "give_money_response",
                    "success": False,
                    "message": "请先登录"
                })
                return
            
            sender_username = sender_info.get("username")
            target_username = message.get("target_username", "")
            amount = message.get("amount", 0)
            
            # 验证参数
            if not target_username:
                self.send_data(client_id, {
                    "type": "give_money_response",
                    "success": False,
                    "message": "目标玩家用户名不能为空"
                })
                return
            
            if amount != 500:
                self.send_data(client_id, {
                    "type": "give_money_response",
                    "success": False,
                    "message": "每次只能送500金币"
                })
                return
            
            if sender_username == target_username:
                self.send_data(client_id, {
                    "type": "give_money_response",
                    "success": False,
                    "message": "不能给自己送金币"
                })
                return
            
            # 加载发送者数据
            sender_data = self.load_player_data(sender_username)
            if not sender_data:
                self.send_data(client_id, {
                    "type": "give_money_response",
                    "success": False,
                    "message": "无法加载发送者数据"
                })
                return
            
            # 检查发送者金币是否足够
            sender_money = sender_data.get("钱币", 0)
            if sender_money < amount:
                self.send_data(client_id, {
                    "type": "give_money_response",
                    "success": False,
                    "message": f"您的金币不足，当前拥有{sender_money}金币"
                })
                return
            
            # 加载接收者数据
            target_data = self.load_player_data(target_username)
            if not target_data:
                self.send_data(client_id, {
                    "type": "give_money_response",
                    "success": False,
                    "message": "目标玩家不存在"
                })
                return
            
            # 执行金币转移
            sender_data["钱币"] = sender_money - amount
            target_data["钱币"] = target_data.get("钱币", 0) + amount
            
            # 记录送金币日志
            from datetime import datetime
            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            log_message = f"[{current_time}] {sender_username} 送给 {target_username} {amount}金币"
            self.log('INFO', log_message, 'GIVE_MONEY')
            
            # 保存数据
            if self.save_player_data(sender_username, sender_data) and self.save_player_data(target_username, target_data):
                # 获取目标玩家昵称
                target_nickname = target_data.get("玩家昵称", target_username)
                
                # 发送成功响应
                self.send_data(client_id, {
                    "type": "give_money_response",
                    "success": True,
                    "message": f"成功送给 {target_nickname} {amount}金币！",
                    "updated_data": {
                        "钱币": sender_data["钱币"]
                    },
                    "target_updated_data": {
                        "钱币": target_data["钱币"]
                    }
                })
                
                # 如果目标玩家在线，通知他们收到金币
                target_client_id = None
                for cid, user_info in self.user_data.items():
                    if user_info.get("username") == target_username and user_info.get("logged_in", False):
                        target_client_id = cid
                        break
                
                if target_client_id:
                    sender_nickname = sender_data.get("玩家昵称", sender_username)
                    self.send_data(target_client_id, {
                        "type": "money_received_notification",
                        "sender_nickname": sender_nickname,
                        "amount": amount,
                        "new_money": target_data["钱币"]
                    })
            else:
                self.send_data(client_id, {
                    "type": "give_money_response",
                    "success": False,
                    "message": "数据保存失败，请重试"
                })
                
        except Exception as e:
            self.log('ERROR', f"处理送金币请求失败: {str(e)}", 'GIVE_MONEY')
            self.send_data(client_id, {
                "type": "give_money_response",
                "success": False,
                "message": "服务器内部错误"
            })
    #==========================访问系统处理==========================




#==========================返回自己农场处理==========================
    #处理玩家返回自己农场的请求
    def _handle_return_my_farm_request(self, client_id, message):
        """处理玩家返回自己农场的请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "返回自己农场", "return_my_farm")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "return_my_farm")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 清除访问状态
        self.user_data[client_id]["visiting_mode"] = False
        self.user_data[client_id]["visiting_target"] = ""
        
        # 清理偷菜免被发现计数器
        self._clear_player_steal_immunity(username)
        
        self.log('INFO', f"玩家 {username} 返回了自己的农场", 'SERVER')
        
        # 返回玩家自己的农场数据
        my_stamina_system = player_data.get("体力系统", {})
        my_current_stamina = my_stamina_system.get("当前体力值", 20)
        
        return self.send_data(client_id, {
            "type": "return_my_farm_response",
            "success": True,
            "message": "已返回自己的农场",
            "player_data": {
                "玩家账号": player_data.get("玩家账号", username),
                "玩家昵称": player_data.get("玩家昵称", username),
                "农场名称": player_data.get("农场名称", ""),
                "等级": player_data.get("等级", 1),
                "钱币": player_data.get("钱币", 0),
                "经验值": player_data.get("经验值", 0),
                "体力值": my_current_stamina,
                "农场土地": player_data.get("农场土地", []),
                "种子仓库": player_data.get("种子仓库", []),
                "宠物背包": player_data.get("宠物背包", []),
                "巡逻宠物": self._convert_patrol_pets_to_full_data(player_data),
                "出战宠物": self._convert_battle_pets_to_full_data(player_data),
                "稻草人配置": player_data.get("稻草人配置", {}),
                "total_likes": player_data.get("total_likes", 0)
            },
            "is_visiting": False
        })
#==========================返回自己农场处理==========================




#==========================在线礼包处理==========================
    #处理获取在线礼包数据请求
    def _handle_get_online_gift_data_request(self, client_id, message):
        """处理获取在线礼包数据请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "获取在线礼包数据", "get_online_gift_data")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "get_online_gift_data")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 确保在线礼包数据已初始化
        self._cleanup_online_gift_history(player_data)
        
        online_gift_data = player_data["在线礼包"]
        
        # 更新在线时间
        current_time = time.time()
        login_time = online_gift_data.get("登录时间", current_time)
        
        # 计算本次登录的在线时间并累加
        if client_id in self.user_data and self.user_data[client_id].get("logged_in", False):
            session_online_time = current_time - self.user_data[client_id].get("login_timestamp", current_time)
            online_gift_data["今日在线时长"] += session_online_time
            # 重置登录时间戳
            self.user_data[client_id]["login_timestamp"] = current_time
        
        # 保存数据
        self.save_player_data(username, player_data)
        
        return self.send_data(client_id, {
            "type": "online_gift_data_response",
            "success": True,
            "current_online_duration": online_gift_data["今日在线时长"],
            "claimed_gifts": {gift: True for gift in online_gift_data["已领取礼包"]}
        })
    
    #处理领取在线礼包请求
    def _handle_claim_online_gift_request(self, client_id, message):
        """处理领取在线礼包请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "领取在线礼包", "claim_online_gift")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "claim_online_gift")
        if not player_data:
            return self.send_data(client_id, response)
        
        gift_name = message.get("gift_name", "")
        if not gift_name:
            return self.send_data(client_id, {
                "type": "claim_online_gift_response",
                "success": False,
                "message": "礼包名称不能为空"
            })
        
        # 加载在线礼包配置
        config = self._load_online_gift_config()
        gift_config = config.get("在线礼包配置", {})
        
        if gift_name not in gift_config:
            return self.send_data(client_id, {
                "type": "claim_online_gift_response",
                "success": False,
                "message": "无效的礼包名称"
            })
        
        # 确保在线礼包数据已初始化
        self._cleanup_online_gift_history(player_data)
        online_gift_data = player_data["在线礼包"]
        
        # 检查是否已领取
        if gift_name in online_gift_data["已领取礼包"]:
            return self.send_data(client_id, {
                "type": "claim_online_gift_response",
                "success": False,
                "message": "该礼包今日已领取"
            })
        
        # 更新在线时间
        current_time = time.time()
        if client_id in self.user_data and self.user_data[client_id].get("logged_in", False):
            session_online_time = current_time - self.user_data[client_id].get("login_timestamp", current_time)
            online_gift_data["今日在线时长"] += session_online_time
            # 重置登录时间戳
            self.user_data[client_id]["login_timestamp"] = current_time
        
        # 检查在线时长是否满足条件
        gift_info = gift_config[gift_name]
        required_time = gift_info["时长秒数"]
        current_duration = online_gift_data["今日在线时长"]
        
        if current_duration < required_time:
            return self.send_data(client_id, {
                "type": "claim_online_gift_response",
                "success": False,
                "message": f"在线时间不足，还需要 {self._format_time(required_time - current_duration)}"
            })
        
        # 发放奖励
        rewards = gift_info["奖励"]
        self._apply_online_gift_rewards_new(player_data, rewards)
        
        # 记录领取状态
        online_gift_data["已领取礼包"].append(gift_name)
        
        # 保存数据
        self.save_player_data(username, player_data)
        
        self.log('INFO', f"玩家 {username} 领取在线礼包 {gift_name}，获得奖励: {rewards}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "claim_online_gift_response",
            "success": True,
            "message": f"成功领取 {gift_name} 礼包！",
            "gift_name": gift_name,
            "rewards": rewards,
            "updated_data": {
                "钱币": player_data["钱币"],
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "种子仓库": player_data.get("种子仓库", [])
            }
        })
    
    #发放在线礼包奖励（新版本 - 支持中文配置）
    def _apply_online_gift_rewards_new(self, player_data, rewards):
        """发放在线礼包奖励（中文配置格式）"""
        # 发放金币
        if "金币" in rewards:
            player_data["钱币"] = player_data.get("钱币", 0) + rewards["金币"]
        
        # 发放经验
        if "经验" in rewards:
            old_experience = player_data.get("经验值", 0)
            player_data["经验值"] = old_experience + rewards["经验"]
            
            # 检查是否升级
            self._check_level_up(player_data)
        
        # 发放种子
        if "种子" in rewards:
            player_bag = player_data.get("种子仓库", [])
            crop_data = self._load_crop_data()
            
            for seed_info in rewards["种子"]:
                seed_name = seed_info["名称"]
                seed_count = seed_info["数量"]
                
                # 从作物数据中获取品质信息
                quality = "普通"  # 默认品质
                if crop_data and seed_name in crop_data:
                    quality = crop_data[seed_name].get("品质", "普通")
                
                # 查找是否已有该种子
                found = False
                for item in player_bag:
                    if item.get("name") == seed_name:
                        item["count"] += seed_count
                        found = True
                        break
                
                # 如果没有找到，添加新种子
                if not found:
                    player_bag.append({
                        "name": seed_name,
                        "quality": quality,
                        "count": seed_count
                    })
            
            player_data["种子仓库"] = player_bag

    #发放在线礼包奖励（旧版本）
    def _apply_online_gift_rewards(self, player_data, rewards):
        """发放在线礼包奖励"""
        # 发放金币
        if "钱币" in rewards:
            player_data["钱币"] = player_data.get("钱币", 0) + rewards["钱币"]
        
        # 发放经验
        if "经验值" in rewards:
            old_experience = player_data.get("经验值", 0)
            player_data["经验值"] = old_experience + rewards["经验值"]
            
            # 检查是否升级
            self._check_level_up(player_data)
        
        # 发放种子
        if "seeds" in rewards:
            player_bag = player_data.get("种子仓库", [])
            crop_data = self._load_crop_data()
            
            for seed_info in rewards["seeds"]:
                seed_name = seed_info["name"]
                seed_count = seed_info["count"]
                
                # 从作物数据中获取品质信息
                quality = "普通"  # 默认品质
                if crop_data and seed_name in crop_data:
                    quality = crop_data[seed_name].get("品质", "普通")
                
                # 查找是否已有该种子
                found = False
                for item in player_bag:
                    if item["name"] == seed_name:
                        item["count"] += seed_count
                        found = True
                        break
                
                # 如果没有找到，添加新物品
                if not found:
                    player_bag.append({
                        "name": seed_name,
                        "count": seed_count,
                        "type": "seed",
                        "quality": quality
                    })
            
            player_data["种子仓库"] = player_bag
    
    #检查玩家是否升级
    def _check_level_up(self, player_data):
        """检查玩家是否升级"""
        current_level = player_data.get("等级", 1)
        current_experience = player_data.get("经验值", 0)
        
        # 计算升级所需经验 (每级需要的经验递增)
        experience_needed = current_level * 100
        
        # 检查是否可以升级
        while current_experience >= experience_needed:
            current_level += 1
            current_experience -= experience_needed
            experience_needed = current_level * 100
        
        player_data["等级"] = current_level
        player_data["经验值"] = current_experience
    
    #更新玩家今日在线时间
    def _update_daily_online_time(self, client_id, player_data):
        """更新玩家今日在线时间（现在由中文在线礼包系统管理）"""
        if client_id not in self.user_data or not self.user_data[client_id].get("logged_in", False):
            return 0
        
        # 使用新的中文在线礼包系统
        current_time = time.time()
        login_time = self.user_data[client_id].get("login_timestamp", current_time)
        session_online_time = current_time - login_time
        
        # 重置用户登录时间戳
        self.user_data[client_id]["login_timestamp"] = current_time
        
        # 确保在线礼包数据存在
        self._cleanup_online_gift_history(player_data)
        online_gift_data = player_data.get("在线礼包", {})
        
        if online_gift_data:
            # 更新中文在线礼包系统的在线时长
            online_gift_data["今日在线时长"] = online_gift_data.get("今日在线时长", 0.0) + session_online_time
            return online_gift_data["今日在线时长"]
        
        return session_online_time

    #格式化时间显示
    def _format_time(self, seconds):
        """格式化时间显示"""
        hours = int(seconds // 3600)
        minutes = int((seconds % 3600) // 60)
        secs = int(seconds % 60)
        
        if hours > 0:
            return f"{hours}小时{minutes}分钟{secs}秒"
        elif minutes > 0:
            return f"{minutes}分钟{secs}秒"
        else:
            return f"{secs}秒"

#==========================在线礼包处理==========================


#==========================PING延迟检测处理==========================
    #处理ping请求
    def _handle_ping_request(self, client_id, message):
        """处理客户端ping请求，立即返回pong响应"""
        timestamp = message.get("timestamp", time.time())
        
        # 立即返回pong响应
        pong_response = {
            "type": "pong",
            "timestamp": timestamp,
            "server_time": time.time()
        }
        
        return self.send_data(client_id, pong_response)

#==========================PING延迟检测处理==========================



#==========================全服大喇叭消息处理==========================
    #处理全服大喇叭消息
    def _handle_global_broadcast_message(self, client_id, message):
        """处理全服大喇叭消息"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "发送全服大喇叭消息", "global_broadcast")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取消息内容
        content = message.get("content", "").strip()
        if not content:
            return self.send_data(client_id, {
                "type": "global_broadcast_response",
                "success": False,
                "message": "消息内容不能为空"
            })
        
        # 检查消息长度
        if len(content) > 200:
            return self.send_data(client_id, {
                "type": "global_broadcast_response",
                "success": False,
                "message": "消息长度不能超过200字符"
            })
        
        # 获取发送者信息
        username = self.user_data[client_id]["username"]
        
        # 获取玩家数据以获取昵称
        player_data = self.load_player_data(username)
        player_name = ""
        if player_data:
            player_name = player_data.get("玩家昵称", "")
        
        # 获取当前时间戳
        current_timestamp = time.time()
        
        # 创建广播消息
        broadcast_message = {
            "type": "global_broadcast_message",
            "username": username,
            "玩家昵称": player_name,
            "content": content,
            "timestamp": current_timestamp
        }
        
        # 广播给所有在线用户
        self.broadcast(broadcast_message)
        
        # 保存消息到MongoDB
        if self.mongo_api and self.mongo_api.is_connected():
            success = self.mongo_api.save_chat_message(username, player_name, content)
            if not success:
                self.log('WARNING', f"保存聊天消息到MongoDB失败，尝试保存到本地文件", 'BROADCAST')
                self._save_broadcast_message_to_log(username, player_name, content)
        else:
            # 如果MongoDB不可用，保存到本地文件作为备份
            self.log('WARNING', f"MongoDB不可用，保存聊天消息到本地文件", 'BROADCAST')
            self._save_broadcast_message_to_log(username, player_name, content)
        
        # 发送成功响应给发送者
        self.send_data(client_id, {
            "type": "global_broadcast_response",
            "success": True,
            "message": "大喇叭消息发送成功"
        })
        
        self.log('INFO', f"用户 {username}({player_name}) 发送全服大喇叭消息: {content}", 'BROADCAST')
        
        return True
    
    #保存大喇叭消息到日志文件
    def _save_broadcast_message_to_log(self, username, player_name, content):
        """保存大喇叭消息到日志文件"""
        try:
            # 创建chat文件夹（如果不存在）
            import os
            chat_dir = os.path.join(os.path.dirname(__file__), "chat")
            if not os.path.exists(chat_dir):
                os.makedirs(chat_dir)
            
            # 获取当前日期作为文件名
            current_date = datetime.datetime.now().strftime("%Y-%m-%d")
            log_file_path = os.path.join(chat_dir, f"{current_date}.log")
            
            # 格式化时间戳
            timestamp = datetime.datetime.now().strftime("%Y年%m月%d日 %H:%M:%S")
            
            # 创建日志条目
            display_name = player_name if player_name else username
            log_entry = f"[{timestamp}] {display_name}({username}): {content}\n"
            
            # 追加到日志文件
            with open(log_file_path, 'a', encoding='utf-8') as f:
                f.write(log_entry)
                
        except Exception as e:
            self.log('ERROR', f"保存大喇叭消息到日志文件时出错: {str(e)}", 'BROADCAST')
    
    def _handle_request_broadcast_history(self, client_id, message):
        """处理请求全服大喇叭历史消息"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "请求全服大喇叭历史消息", "request_broadcast_history")
        if not logged_in:
            return self.send_data(client_id, response)
        
        try:
            days = message.get("days", 3)  # 默认加载3天
            limit = message.get("limit", 500)  # 默认限制500条
            if days > 30:  # 限制最多30天
                days = 30
            
            # 优先从MongoDB获取历史消息
            messages = []
            if self.mongo_api and self.mongo_api.is_connected():
                try:
                    messages = self.mongo_api.get_chat_history(days, limit)
                    # 转换数据格式以兼容客户端
                    for msg in messages:
                        msg["玩家昵称"] = msg.get("player_name", "")
                        msg["display_name"] = msg.get("player_name", "") if msg.get("player_name") else msg.get("username", "匿名")
                    self.log('INFO', f"从MongoDB获取了 {len(messages)} 条历史消息", 'SERVER')
                except Exception as e:
                    self.log('ERROR', f"从MongoDB获取历史消息失败: {str(e)}", 'SERVER')
                    messages = []
            
            # 如果MongoDB获取失败或没有数据，尝试从本地文件获取
            if not messages:
                self.log('INFO', f"尝试从本地文件获取历史消息", 'SERVER')
                messages = self._load_broadcast_history(days)
            
            # 发送历史消息响应
            response = {
                "type": "broadcast_history_response",
                "success": True,
                "messages": messages,
                "days": days
            }
            
            self.log('INFO', f"向客户端 {client_id} 发送了 {len(messages)} 条历史消息（最近{days}天）", 'SERVER')
            return self.send_data(client_id, response)
            
        except Exception as e:
            self.log('ERROR', f"处理全服大喇叭历史消息请求失败: {str(e)}", 'SERVER')
            error_response = {
                "type": "broadcast_history_response",
                "success": False,
                "message": "加载历史消息失败"
            }
            return self.send_data(client_id, error_response)
    
    def _load_broadcast_history(self, days):
        """从日志文件加载历史消息"""
        messages = []
        chat_dir = os.path.join(os.path.dirname(__file__), "chat")
        
        if not os.path.exists(chat_dir):
            return messages
        
        try:
            # 获取需要加载的日期范围
            end_date = datetime.datetime.now()
            start_date = end_date - datetime.timedelta(days=days-1)
            
            self.log('INFO', f"查找历史消息，日期范围: {start_date.strftime('%Y-%m-%d')} 到 {end_date.strftime('%Y-%m-%d')}", 'SERVER')
            
            # 遍历日期范围内的所有日志文件
            current_date = start_date
            while current_date <= end_date:
                date_str = current_date.strftime("%Y-%m-%d")
                log_file = os.path.join(chat_dir, f"{date_str}.log")
                
                self.log('INFO', f"检查日志文件: {log_file}", 'SERVER')
                
                if os.path.exists(log_file):
                    self.log('INFO', f"找到日志文件: {log_file}", 'SERVER')
                    with open(log_file, "r", encoding="utf-8") as f:
                        lines = f.readlines()
                        
                    self.log('INFO', f"日志文件 {date_str}.log 包含 {len(lines)} 行", 'SERVER')
                    
                    # 解析每一行消息
                    for line in lines:
                        line = line.strip()
                        if line:
                            parsed_message = self._parse_log_message(line)
                            if parsed_message:
                                messages.append(parsed_message)
                                self.log('INFO', f"解析消息成功: {parsed_message['content'][:20]}...", 'SERVER')
                            else:
                                self.log('WARNING', f"解析消息失败: {line[:50]}...", 'SERVER')
                else:
                    self.log('INFO', f"日志文件不存在: {log_file}", 'SERVER')
                
                current_date += datetime.timedelta(days=1)
            
            # 按时间戳排序
            messages.sort(key=lambda x: x.get("timestamp", 0))
            
            # 限制消息数量，最多返回500条
            if len(messages) > 500:
                messages = messages[-500:]
            
            return messages
            
        except Exception as e:
            self.log('ERROR', f"加载全服大喇叭历史消息失败: {str(e)}", 'SERVER')
            return []
    
    def _parse_log_message(self, line):
        """解析日志消息行"""
        try:
            # 消息格式: [时间] 昵称(QQ号): 消息内容
            import re
            
            # 匹配时间部分
            time_match = re.match(r'\[([^\]]+)\]', line)
            if not time_match:
                return None
            
            time_str = time_match.group(1)
            
            # 匹配用户名和消息内容
            # 格式: 昵称(QQ号): 消息内容
            content_part = line[len(time_match.group(0)):].strip()
            
            # 查找用户名和消息内容
            user_match = re.match(r'([^(]+)\(([^)]+)\):\s*(.+)', content_part)
            if not user_match:
                return None
            
            player_name = user_match.group(1).strip()
            username = user_match.group(2).strip()
            content = user_match.group(3).strip()
            
            # 解析时间戳
            try:
                # 时间格式: 2024年01月01日 12:00:00
                time_obj = datetime.datetime.strptime(time_str, "%Y年%m月%d日 %H:%M:%S")
                timestamp = time_obj.timestamp()
            except:
                timestamp = time.time()
            
            return {
                "username": username,
                "玩家昵称": player_name,
                "display_name": player_name if player_name else username,
                "content": content,
                "timestamp": timestamp,
                "time_str": time_str
            }
            
        except Exception as e:
            self.log('ERROR', f"解析日志消息失败: {line}, 错误: {str(e)}", 'SERVER')
            return None

#==========================全服大喇叭消息处理==========================
 
 



# #==========================聊天消息处理==========================
#     #处理聊天消息（暂未完成）
#     def _handle_chat_message(self, client_id, message):
#         """处理聊天消息"""
#         # 检查用户是否已登录
#         logged_in, response = self._check_user_logged_in(client_id, "发送聊天消息")
#         if not logged_in:
#             return self.send_data(client_id, response)
        
#         content = message.get("content", "")
#         if not content.strip():
#             return self.send_data(client_id, {
#                 "type": "chat_response",
#                 "success": False,
#                 "message": "消息内容不能为空"
#             })
        
#         username = self.user_data[client_id]["username"]
        
#         # 广播聊天消息给所有在线用户
#         chat_message = {
#             "type": "chat_message",
#             "username": username,
#             "content": content,
#             "timestamp": time.time()
#         }
        
#         self.broadcast(chat_message)
#         self.log('INFO', f"用户 {username} 发送聊天消息: {content}", 'SERVER')
        
#         return True
    
# #==========================聊天消息处理==========================




#==========================每日签到处理==========================
    #加载每日签到配置
    def _load_daily_check_in_config(self):
        """加载每日签到配置 - 优先使用MongoDB，失败则回退到JSON文件"""
        # 优先尝试从MongoDB获取配置
        if hasattr(self, 'use_mongodb') and self.use_mongodb and self.mongo_api:
            try:
                config = self.mongo_api.get_daily_checkin_config()
                if config:
                    self.log('INFO', "从MongoDB成功加载每日签到配置", 'SERVER')
                    return config
                else:
                    self.log('WARNING', "MongoDB中未找到每日签到配置，尝试使用JSON文件", 'SERVER')
            except Exception as e:
                self.log('ERROR', f"从MongoDB加载每日签到配置失败: {e}，回退到JSON文件", 'SERVER')
        
        # 回退到JSON文件
        try:
            config_path = os.path.join(self.config_dir, "daily_checkin_config.json")
            if os.path.exists(config_path):
                with open(config_path, 'r', encoding='utf-8') as f:
                    config = json.load(f)
                    self.log('INFO', "从JSON文件成功加载每日签到配置", 'SERVER')
                    return config
        except Exception as e:
            self.log('ERROR', f"从JSON文件加载每日签到配置失败: {e}", 'SERVER')
        
        # 默认配置
        self.log('WARNING', "使用默认每日签到配置", 'SERVER')
        return {
            "基础奖励": {
                "金币": {"最小值": 200, "最大值": 500, "图标": "💰", "颜色": "#FFD700"},
                "经验": {"最小值": 50, "最大值": 120, "图标": "⭐", "颜色": "#00BFFF"}
            },
            "种子奖励": {
                "普通": {"概率": 0.6, "数量范围": [2, 5], "种子池": ["小麦", "胡萝卜", "土豆", "稻谷"]},
                "优良": {"概率": 0.25, "数量范围": [2, 4], "种子池": ["玉米", "番茄", "洋葱", "大豆", "豌豆", "黄瓜", "大白菜"]},
                "稀有": {"概率": 0.12, "数量范围": [1, 3], "种子池": ["草莓", "花椰菜", "柿子", "蓝莓", "树莓"]},
                "史诗": {"概率": 0.025, "数量范围": [1, 2], "种子池": ["葡萄", "南瓜", "芦笋", "茄子", "向日葵", "蕨菜"]},
                "传奇": {"概率": 0.005, "数量范围": [1, 1], "种子池": ["西瓜", "甘蔗", "香草", "甜菜", "人参", "富贵竹", "芦荟", "哈密瓜"]}
            },
            "连续签到奖励": {
                "第3天": {"额外金币": 100, "额外经验": 50, "描述": "连续签到奖励"},
                "第7天": {"额外金币": 200, "额外经验": 100, "描述": "一周连击奖励"},
                "第14天": {"额外金币": 500, "额外经验": 200, "描述": "半月连击奖励"},
                "第21天": {"额外金币": 800, "额外经验": 300, "描述": "三周连击奖励"},
                "第30天": {"额外金币": 1500, "额外经验": 500, "描述": "满月连击奖励"}
            }
        }
    
    #更新每日签到配置到MongoDB
    def _update_daily_checkin_config_to_mongodb(self, config_data):
        """更新每日签到配置到MongoDB"""
        if hasattr(self, 'use_mongodb') and self.use_mongodb and self.mongo_api:
            try:
                success = self.mongo_api.update_daily_checkin_config(config_data)
                if success:
                    self.log('INFO', "成功更新每日签到配置到MongoDB", 'SERVER')
                    return True
                else:
                    self.log('ERROR', "更新每日签到配置到MongoDB失败", 'SERVER')
                    return False
            except Exception as e:
                self.log('ERROR', f"更新每日签到配置到MongoDB异常: {e}", 'SERVER')
                return False
        else:
            self.log('WARNING', "MongoDB未连接，无法更新配置", 'SERVER')
            return False
    
    #处理每日签到请求
    def _handle_daily_check_in_request(self, client_id, message):
        """处理每日签到请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "每日签到", "daily_check_in")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "daily_check_in")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 清理过期签到记录并使用新格式
        self._cleanup_check_in_history(player_data)
        
        # 检查今日是否已签到
        current_time = datetime.datetime.now()
        today_key = current_time.strftime("%Y年%m月%d日")
        check_in_history = player_data.get("签到历史", {})
        
        # 检查今日是否已签到
        for time_key in check_in_history.keys():
            if time_key.startswith(today_key):
                return self.send_data(client_id, {
                    "type": "daily_check_in_response",
                    "success": False,
                    "message": "今日已签到，请明日再来",
                    "has_checked_in": True
                })
        
        # 计算连续签到天数
        consecutive_days = self._calculate_consecutive_check_in_days_new(check_in_history)
        
        # 生成签到奖励
        config = self._load_daily_check_in_config()
        rewards = self._generate_check_in_rewards_new(consecutive_days, config)
        
        # 发放奖励
        self._apply_check_in_rewards(player_data, rewards)
        
        # 保存签到记录 - 使用新格式
        if "签到历史" not in player_data:
            player_data["签到历史"] = {}
        
        time_key = current_time.strftime("%Y年%m月%d日%H时%M分%S秒")
        reward_text = self._format_reward_text_simple(rewards)
        player_data["签到历史"][time_key] = reward_text
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        self.log('INFO', f"玩家 {username} 完成每日签到，连续 {consecutive_days} 天，获得奖励: {rewards}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "daily_check_in_response",
            "success": True,
            "message": f"签到成功！连续签到 {consecutive_days} 天",
            "rewards": rewards,
            "consecutive_days": consecutive_days,
            "updated_data": {
                "钱币": player_data["钱币"],
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "种子仓库": player_data.get("种子仓库", [])
            }
        })
    
    #处理客户端获取签到数据请求
    def _handle_get_check_in_data_request(self, client_id, message):
        """处理获取签到数据请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "获取签到数据", "get_check_in_data")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "get_check_in_data")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 清理过期签到记录
        self._cleanup_check_in_history(player_data)
        
        check_in_history = player_data.get("签到历史", {})
        
        # 计算连续签到天数
        consecutive_days = self._calculate_consecutive_check_in_days_new(check_in_history)
        
        # 检查今日是否已签到
        current_time = datetime.datetime.now()
        today_key = current_time.strftime("%Y年%m月%d日")
        has_checked_in_today = any(time_key.startswith(today_key) for time_key in check_in_history.keys())
        
        return self.send_data(client_id, {
            "type": "check_in_data_response",
            "success": True,
            "check_in_data": check_in_history,
            "consecutive_days": consecutive_days,
            "has_checked_in_today": has_checked_in_today,
            "current_date": current_time.strftime("%Y年%m月%d日")
        })
    
    #清理过期签到记录
    def _cleanup_check_in_history(self, player_data):
        """清理过期签到记录，只保留最近30天的记录"""
        if "签到历史" not in player_data:
            return
        
        current_time = datetime.datetime.now()
        cutoff_time = current_time - datetime.timedelta(days=30)
        
        # 清理过期记录
        history = player_data["签到历史"]
        keys_to_remove = []
        
        for time_key in history.keys():
            try:
                # 解析时间字符串
                check_time = datetime.datetime.strptime(time_key, "%Y年%m月%d日%H时%M分%S秒")
                if check_time < cutoff_time:
                    keys_to_remove.append(time_key)
            except:
                # 如果解析失败，删除这条记录
                keys_to_remove.append(time_key)
        
        for key in keys_to_remove:
            del history[key]
    
    #计算连续签到天数（新版本）
    def _calculate_consecutive_check_in_days_new(self, check_in_history):
        """计算连续签到天数（新版本）"""
        if not check_in_history:
            return 0
        
        # 提取所有签到日期（只取日期部分）
        check_dates = set()
        for time_key in check_in_history.keys():
            try:
                check_time = datetime.datetime.strptime(time_key, "%Y年%m月%d日%H时%M分%S秒")
                date_str = check_time.strftime("%Y-%m-%d")
                check_dates.add(date_str)
            except:
                continue
        
        if not check_dates:
            return 0
        
        # 从今天开始向前计算连续天数
        consecutive_days = 0
        current_date = datetime.datetime.now()
        
        # 检查今天是否已签到
        today_str = current_date.strftime("%Y-%m-%d")
        if today_str in check_dates:
            consecutive_days += 1
            check_date = current_date - datetime.timedelta(days=1)
        else:
            check_date = current_date - datetime.timedelta(days=1)
        
        # 向前查找连续签到天数
        while True:
            date_str = check_date.strftime("%Y-%m-%d")
            if date_str in check_dates:
                consecutive_days += 1
                check_date -= datetime.timedelta(days=1)
            else:
                break
            
            # 限制最大连续天数为30天
            if consecutive_days >= 30:
                break
        
        return consecutive_days
    
    #生成签到奖励（新版本）
    def _generate_check_in_rewards_new(self, consecutive_days, config):
        """生成签到奖励（新版本）"""
        import random
        
        rewards = {}
        
        # 基础奖励倍数
        base_multiplier = 1.0 + (consecutive_days - 1) * 0.1
        max_multiplier = 3.0
        multiplier = min(base_multiplier, max_multiplier)
        
        # 基础金币奖励
        coin_config = config.get("基础奖励", {}).get("金币", {})
        base_coins = random.randint(coin_config.get("最小值", 200), coin_config.get("最大值", 500))
        rewards["coins"] = int(base_coins * multiplier)
        
        # 基础经验奖励
        exp_config = config.get("基础奖励", {}).get("经验", {})
        base_exp = random.randint(exp_config.get("最小值", 50), exp_config.get("最大值", 120))
        rewards["exp"] = int(base_exp * multiplier)
        
        # 种子奖励
        seeds = self._generate_check_in_seeds_new(consecutive_days, config)
        if seeds:
            rewards["seeds"] = seeds
        
        # 连续签到特殊奖励
        consecutive_rewards = config.get("连续签到奖励", {})
        for milestone, bonus in consecutive_rewards.items():
            milestone_days = int(milestone.replace("第", "").replace("天", ""))
            if consecutive_days >= milestone_days:
                if "额外金币" in bonus:
                    rewards["bonus_coins"] = bonus["额外金币"]
                if "额外经验" in bonus:
                    rewards["bonus_exp"] = bonus["额外经验"]
        
        return rewards
    
    #生成签到种子奖励（新版本）
    def _generate_check_in_seeds_new(self, consecutive_days, config):
        """生成签到种子奖励（新版本）"""
        import random
        
        seeds = []
        seed_configs = config.get("种子奖励", {})
        
        # 根据连续签到天数确定种子稀有度
        if consecutive_days <= 2:
            rarity = "普通"
        elif consecutive_days <= 5:
            rarity = "优良"
        elif consecutive_days <= 10:
            rarity = "稀有"
        elif consecutive_days <= 15:
            rarity = "史诗"
        else:
            rarity = "传奇"
        
        # 获取对应稀有度的种子池
        rarity_config = seed_configs.get(rarity, {})
        seed_pool = rarity_config.get("种子池", [])
        quantity_range = rarity_config.get("数量范围", [1, 2])
        
        if not seed_pool:
            return seeds
        
        # 生成1-3个种子
        seed_count = random.randint(1, min(3, len(seed_pool)))
        selected_seeds = random.sample(seed_pool, seed_count)
        
        for seed_name in selected_seeds:
            quantity = random.randint(quantity_range[0], quantity_range[1])
            seeds.append({
                "name": seed_name,
                "quantity": quantity,
                "quality": rarity
            })
        
        return seeds
    
    #格式化奖励文本（简单版本）
    def _format_reward_text_simple(self, rewards):
        """格式化奖励文本（简单版本）"""
        parts = []
        
        if "coins" in rewards:
            parts.append(f"金币{rewards['coins']}")
        if "exp" in rewards:
            parts.append(f"经验{rewards['exp']}")
        if "bonus_coins" in rewards:
            parts.append(f"额外金币{rewards['bonus_coins']}")
        if "bonus_exp" in rewards:
            parts.append(f"额外经验{rewards['bonus_exp']}")
        
        if "seeds" in rewards:
            for seed in rewards["seeds"]:
                parts.append(f"{seed['name']}x{seed['quantity']}")
        
        return " ".join(parts)
    
    #应用签到奖励到玩家数据
    def _apply_check_in_rewards(self, player_data, rewards):
        """应用签到奖励到玩家数据"""
        # 应用钱币奖励
        if "coins" in rewards:
            player_data["钱币"] = player_data.get("钱币", 0) + rewards["coins"]
        
        if "bonus_coins" in rewards:
            player_data["钱币"] = player_data.get("钱币", 0) + rewards["bonus_coins"]
        
        # 应用经验奖励
        if "exp" in rewards:
            player_data["经验值"] = player_data.get("经验值", 0) + rewards["exp"]
        
        if "bonus_exp" in rewards:
            player_data["经验值"] = player_data.get("经验值", 0) + rewards["bonus_exp"]
        
        # 检查升级
        level_up_experience = 100 * player_data.get("等级", 1)
        while player_data.get("经验值", 0) >= level_up_experience:
            player_data["等级"] = player_data.get("等级", 1) + 1
            player_data["经验值"] -= level_up_experience
            level_up_experience = 100 * player_data["等级"]
        
        # 应用种子奖励
        if "seeds" in rewards:
            if "种子仓库" not in player_data:
                player_data["种子仓库"] = []
            
            for seed_reward in rewards["seeds"]:
                seed_name = seed_reward["name"]
                quantity = seed_reward["quantity"]
                quality = seed_reward["quality"]
                
                # 查找背包中是否已有该种子
                found = False
                for item in player_data["种子仓库"]:
                    if item.get("name") == seed_name:
                        item["count"] += quantity
                        found = True
                        break
                
                # 如果背包中没有，添加新条目
                if not found:
                    player_data["种子仓库"].append({
                        "name": seed_name,
                        "quality": quality,
                        "count": quantity
                    })
    
#==========================每日签到处理==========================




#==========================新手大礼包处理==========================

    #处理新手大礼包请求
    def _handle_new_player_gift_request(self, client_id, message):
        """处理新手大礼包请求"""
        try:
            # 检查用户是否已登录
            logged_in, response = self._check_user_logged_in(client_id, "领取新手大礼包", "new_player_gift")
            if not logged_in:
                return self.send_data(client_id, response)
            
            # 获取玩家数据
            player_data, username, response = self._load_player_data_with_check(client_id, "new_player_gift")
            if not player_data:
                return self.send_data(client_id, response)
            
            # 加载新手礼包配置
            config = self._load_new_player_config()
            gift_config = config.get("新手礼包配置", {})
            
            # 检查是否已经领取过新手大礼包
            new_player_gift_data = player_data.get("新手礼包", {})
            if new_player_gift_data.get("已领取", False):
                return self.send_data(client_id, {
                    "type": "new_player_gift_response",
                    "success": False,
                    "message": gift_config.get("提示消息", {}).get("已领取", "新手大礼包已经领取过了")
                })
            
            # 获取新手大礼包内容
            reward_content = gift_config.get("奖励内容", {})
            
            # 应用奖励
            self._apply_new_player_gift_rewards_new(player_data, reward_content)
            
            # 标记已领取
            player_data["新手礼包"] = {
                "已领取": True,
                "领取时间": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            }
            
            # 保存玩家数据
            self.save_player_data(username, player_data)
            
            self.log('INFO', f"玩家 {username} 成功领取新手大礼包", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "new_player_gift_response",
                "success": True,
                "message": gift_config.get("提示消息", {}).get("成功", "新手大礼包领取成功！"),
                "gift_contents": reward_content,
                "updated_data": {
                    "钱币": player_data["钱币"],
                    "经验值": player_data["经验值"],
                    "等级": player_data["等级"],
                    "种子仓库": player_data.get("种子仓库", []),
                    "宠物背包": player_data.get("宠物背包", []),
                    "新手礼包": player_data["新手礼包"]
                }
            })
            
        except Exception as e:
            # 捕获所有异常，防止服务器崩溃
            self.log('ERROR', f"处理新手大礼包请求时出错: {str(e)}", 'SERVER')
            
            # 发送错误响应
            return self.send_data(client_id, {
                "type": "new_player_gift_response",
                "success": False,
                "message": "服务器处理新手大礼包时出现错误，请稍后重试"
            })
    
    #应用新手大礼包奖励到玩家数据
    def _apply_new_player_gift_rewards(self, player_data, gift_contents):
        """应用新手大礼包奖励到玩家数据（旧格式，保留兼容性）"""
        # 应用金币奖励
        if "coins" in gift_contents:
            player_data["钱币"] = player_data.get("钱币", 0) + gift_contents["coins"]
        
        # 应用经验奖励
        if "经验值" in gift_contents:
            player_data["经验值"] = player_data.get("经验值", 0) + gift_contents["经验值"]
            
            # 检查升级
            level_up_experience = 100 * player_data.get("等级", 1)
            while player_data.get("经验值", 0) >= level_up_experience:
                player_data["等级"] = player_data.get("等级", 1) + 1
                player_data["经验值"] -= level_up_experience
                level_up_experience = 100 * player_data["等级"]
        
        # 应用种子奖励
        if "seeds" in gift_contents:
            if "种子仓库" not in player_data:
                player_data["种子仓库"] = []
            
            for seed_reward in gift_contents["seeds"]:
                seed_name = seed_reward["name"]
                quantity = seed_reward["count"]
                quality = seed_reward["quality"]
                
                # 查找背包中是否已有该种子
                found = False
                for item in player_data["种子仓库"]:
                    if item.get("name") == seed_name:
                        item["count"] += quantity
                        found = True
                        break
                
                # 如果背包中没有，添加新条目
                if not found:
                    player_data["种子仓库"].append({
                        "name": seed_name,
                        "quality": quality,
                        "count": quantity
                    })
    
    #应用新手大礼包奖励到玩家数据（新中文格式）
    def _apply_new_player_gift_rewards_new(self, player_data, reward_content):
        """应用新手大礼包奖励到玩家数据（新中文格式）"""
        # 应用金币奖励
        if "金币" in reward_content:
            player_data["钱币"] = player_data.get("钱币", 0) + reward_content["金币"]
        
        # 应用经验奖励
        if "经验" in reward_content:
            player_data["经验值"] = player_data.get("经验值", 0) + reward_content["经验"]
            
            # 检查升级
            while True:
                level_up_experience = 100 * player_data.get("等级", 1)
                if player_data.get("经验值", 0) >= level_up_experience:
                    player_data["等级"] = player_data.get("等级", 1) + 1
                    player_data["经验值"] -= level_up_experience
                else:
                    break
        
        # 应用种子奖励
        if "种子" in reward_content:
            if "种子仓库" not in player_data:
                player_data["种子仓库"] = []
            
            for seed_reward in reward_content["种子"]:
                seed_name = seed_reward["名称"]
                quantity = seed_reward["数量"]
                quality = seed_reward["品质"]
                
                # 查找背包中是否已有该种子
                found = False
                for item in player_data["种子仓库"]:
                    if item.get("name") == seed_name:
                        item["count"] += quantity
                        found = True
                        break
                
                # 如果背包中没有，添加新条目
                if not found:
                    player_data["种子仓库"].append({
                        "name": seed_name,
                        "quality": quality,
                        "count": quantity
                    })

#==========================新手大礼包处理==========================



#==========================幸运抽奖处理==========================

    #处理幸运抽奖请求
    def _handle_lucky_draw_request(self, client_id, message):
        """处理幸运抽奖请求"""
        try:
            # 检查用户是否已登录
            logged_in, response = self._check_user_logged_in(client_id, "幸运抽奖", "lucky_draw")
            if not logged_in:
                return self.send_data(client_id, response)
            
            # 获取玩家数据
            player_data, username, response = self._load_player_data_with_check(client_id, "lucky_draw")
            if not player_data:
                return self.send_data(client_id, response)
            
            # 删除历史记录（如果存在）
            if "lucky_draw_history" in player_data:
                del player_data["lucky_draw_history"]
            
            draw_type = message.get("draw_type", "single")  # single, five, ten
            
            # 从配置文件获取费用
            config = self._load_lucky_draw_config()
            costs = config.get("抽奖费用", {"单抽": 800, "五连抽": 3600, "十连抽": 6400})
            
            # 计算抽奖费用和数量
            if draw_type == "single":
                draw_count = 1
                total_cost = costs.get("单抽", 800)
            elif draw_type == "five":
                draw_count = 5
                total_cost = costs.get("五连抽", 3600)
            elif draw_type == "ten":
                draw_count = 10
                total_cost = costs.get("十连抽", 6400)
            else:
                return self.send_data(client_id, {
                    "type": "lucky_draw_response",
                    "success": False,
                    "message": "无效的抽奖类型"
                })
            
            # 检查玩家金钱是否足够
            if player_data.get("钱币", 0) < total_cost:
                return self.send_data(client_id, {
                    "type": "lucky_draw_response",
                    "success": False,
                    "message": f"金钱不足，需要 {total_cost} 金币"
                })
            
            # 扣除金钱
            player_data["钱币"] -= total_cost
            
            # 生成奖励
            rewards = self._generate_lucky_draw_rewards(draw_count, draw_type, config)
            
            # 应用奖励到玩家数据
            self._apply_lucky_draw_rewards(player_data, rewards)
            
            # 保存玩家数据
            self.save_player_data(username, player_data)
            
            self.log('INFO', f"玩家 {username} 进行{draw_type}抽奖，花费 {total_cost} 金币，获得 {len(rewards)} 个奖励", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "lucky_draw_response",
                "success": True,
                "message": f"{draw_type}抽奖成功！",
                "draw_type": draw_type,
                "cost": total_cost,
                "rewards": rewards,
                "updated_data": {
                    "钱币": player_data["钱币"],
                    "经验值": player_data["经验值"],
                    "等级": player_data["等级"],
                    "种子仓库": player_data.get("种子仓库", [])
                }
            })
            
        except Exception as e:
            self.log('ERROR', f"处理玩家抽奖请求时出错: {str(e)}", 'SERVER')
            
            return self.send_data(client_id, {
                "type": "lucky_draw_response",
                "success": False,
                "message": "服务器处理抽奖时出现错误，请稍后重试"
            })
    
    #加载抽奖配置
    def _load_lucky_draw_config(self):
        """加载抽奖配置（优先从MongoDB读取）"""
        # 优先尝试从MongoDB读取
        if self.use_mongodb and self.mongo_api:
            try:
                config = self.mongo_api.get_lucky_draw_config()
                if config:
                    self.log('INFO', "成功从MongoDB加载幸运抽奖配置", 'SERVER')
                    return config
                else:
                    self.log('WARNING', "MongoDB中未找到幸运抽奖配置，尝试从JSON文件读取", 'SERVER')
            except Exception as e:
                self.log('ERROR', f"从MongoDB读取幸运抽奖配置失败: {e}，尝试从JSON文件读取", 'SERVER')
        
        # 回退到JSON文件
        try:
            config_path = os.path.join(self.config_dir, "lucky_draw_config.json")
            if os.path.exists(config_path):
                with open(config_path, 'r', encoding='utf-8') as f:
                    config = json.load(f)
                    self.log('INFO', "成功从JSON文件加载幸运抽奖配置", 'SERVER')
                    return config
        except Exception as e:
            self.log('ERROR', f"从JSON文件读取幸运抽奖配置失败: {e}，使用默认配置", 'SERVER')
        
        # 默认配置
        self.log('WARNING', "使用默认幸运抽奖配置", 'SERVER')
        return {
            "抽奖费用": {"单抽": 800, "五连抽": 3600, "十连抽": 6400},
            "概率配置": {
                "普通": {"概率": 0.45, "金币范围": [100, 300], "经验范围": [50, 150], "种子数量": [2, 4]},
                "优良": {"概率": 0.25, "金币范围": [300, 600], "经验范围": [150, 300], "种子数量": [1, 3]},
                "稀有": {"概率": 0.12, "金币范围": [600, 1000], "经验范围": [300, 500], "种子数量": [1, 2]},
                "史诗": {"概率": 0.025, "金币范围": [1000, 1500], "经验范围": [500, 800], "种子数量": [1, 1]},
                "传奇": {"概率": 0.005, "金币范围": [1500, 2500], "经验范围": [800, 1200], "种子数量": [1, 1]},
                "空奖": {"概率": 0.15, "提示语": ["谢谢惠顾", "下次再来", "再试一次", "继续努力"]}
            }
        }

    #加载在线礼包配置
    def _load_online_gift_config(self):
        """加载在线礼包配置"""
        # 优先从MongoDB读取配置
        if hasattr(self, 'mongo_api') and self.mongo_api and self.mongo_api.is_connected():
            try:
                config = self.mongo_api.get_online_gift_config()
                if config:
                    self.log('INFO', '成功从MongoDB加载在线礼包配置', 'SERVER')
                    return config
                else:
                    self.log('WARNING', '从MongoDB未找到在线礼包配置，尝试从JSON文件加载', 'SERVER')
            except Exception as e:
                self.log('ERROR', f'从MongoDB加载在线礼包配置失败: {str(e)}，尝试从JSON文件加载', 'SERVER')
        
        # 回退到JSON文件
        try:
            config_path = os.path.join(self.config_dir, "online_gift_config.json")
            if os.path.exists(config_path):
                with open(config_path, 'r', encoding='utf-8') as f:
                    config = json.load(f)
                    self.log('INFO', '成功从JSON文件加载在线礼包配置', 'SERVER')
                    return config
        except Exception as e:
            self.log('ERROR', f"从JSON文件加载在线礼包配置失败: {str(e)}", 'SERVER')
        
        # 默认配置
        self.log('WARNING', '使用默认在线礼包配置', 'SERVER')
        return {
            "在线礼包配置": {
                "1分钟": {"时长秒数": 60, "奖励": {"金币": 100, "经验": 50, "种子": [{"名称": "小麦", "数量": 5}]}},
                "5分钟": {"时长秒数": 300, "奖励": {"金币": 500, "经验": 250, "种子": [{"名称": "玉米", "数量": 3}]}},
                "30分钟": {"时长秒数": 1800, "奖励": {"金币": 1500, "经验": 750, "种子": [{"名称": "草莓", "数量": 2}]}},
                "1小时": {"时长秒数": 3600, "奖励": {"金币": 3000, "经验": 1500, "种子": [{"名称": "葡萄", "数量": 2}]}}
            },
            "每日重置": True
        }
    
    #加载新手礼包配置
    def _load_new_player_config(self):
        """加载新手礼包配置"""
        # 优先从MongoDB读取配置
        if hasattr(self, 'mongo_api') and self.mongo_api and self.mongo_api.is_connected():
            try:
                config = self.mongo_api.get_new_player_config()
                if config:
                    self.log('INFO', '成功从MongoDB加载新手大礼包配置', 'SERVER')
                    return config
                else:
                    self.log('WARNING', '从MongoDB未找到新手大礼包配置，尝试从JSON文件加载', 'SERVER')
            except Exception as e:
                self.log('ERROR', f'从MongoDB加载新手大礼包配置失败: {str(e)}，尝试从JSON文件加载', 'SERVER')
        
        # 回退到JSON文件
        try:
            config_path = os.path.join(self.config_dir, "new_player_config.json")
            if os.path.exists(config_path):
                with open(config_path, 'r', encoding='utf-8') as f:
                    config = json.load(f)
                    self.log('INFO', '成功从JSON文件加载新手大礼包配置', 'SERVER')
                    return config
        except Exception as e:
            self.log('ERROR', f"从JSON文件加载新手礼包配置失败: {str(e)}", 'SERVER')
        
        # 默认配置
        self.log('WARNING', '使用默认新手大礼包配置', 'SERVER')
        return {
            "新手礼包配置": {
                "奖励内容": {
                    "金币": 6000,
                    "经验": 1000,
                    "种子": [
                        {"名称": "龙果", "品质": "传奇", "数量": 1},
                        {"名称": "杂交树1", "品质": "传奇", "数量": 1},
                        {"名称": "杂交树2", "品质": "传奇", "数量": 1}
                    ]
                },
                "提示消息": {
                    "成功": "新手大礼包领取成功！获得6000金币、1000经验和3个传奇种子",
                    "已领取": "新手大礼包已经领取过了"
                }
            }
        }
    
    #生成幸运抽奖奖励
    def _generate_lucky_draw_rewards(self, count: int, draw_type: str, config: dict):
        """生成幸运抽奖奖励"""
        
        # 加载作物配置
        crop_data = self._load_crop_data()
        
        rewards = []
        
        # 根据 crop_data.json 构建奖励池
        seed_pools = {"普通": [], "优良": [], "稀有": [], "史诗": [], "传奇": []}
        
        for crop_name, crop_info in crop_data.items():
            if not crop_info.get("能否购买", True):
                continue
                
            quality = crop_info.get("品质", "普通")
            if quality in seed_pools:
                seed_pools[quality].append(crop_name)
        
        # 十连抽保底机制
        guaranteed_rare = (draw_type == "ten")
        rare_given = False
        
        for i in range(count):
            # 生成单个奖励
            reward = self._generate_single_lucky_reward(
                seed_pools, config, guaranteed_rare and i == count - 1 and not rare_given
            )
            
            # 检查是否给出了稀有奖励
            if reward.get("rarity", "普通") in ["稀有", "史诗", "传奇"]:
                rare_given = True
            
            rewards.append(reward)
        
        return rewards
    
    #生成单个抽奖奖励
    def _generate_single_lucky_reward(self, seed_pools: dict, config: dict, force_rare=False):
        """生成单个幸运抽奖奖励"""
        import random
        
        prob_config = config.get("概率配置", {})
        
        # 决定稀有度
        if force_rare:
            # 强制稀有：33%稀有，33%史诗，34%传奇
            rand = random.random()
            if rand < 0.33:
                rarity = "稀有"
            elif rand < 0.66:
                rarity = "史诗"
            else:
                rarity = "传奇"
        else:
            # 正常概率
            rand = random.random()
            cumulative = 0
            rarity = "普通"
            
            for r, config_data in prob_config.items():
                prob = config_data.get("概率", 0)
                cumulative += prob
                if rand < cumulative:
                    rarity = r
                    break
        
        # 根据稀有度生成奖励
        if rarity == "空奖":
            empty_messages = prob_config.get("空奖", {}).get("提示语", ["谢谢惠顾"])
            return {
                "type": "empty",
                "name": random.choice(empty_messages),
                "rarity": "空奖",
                "amount": 0
            }
        
        # 获取稀有度配置
        rarity_config = prob_config.get(rarity, {})
        
        # 根据奖励类型权重选择奖励类型
        type_weights = config.get("奖励类型权重", {}).get(rarity, {"金币": 0.5, "经验": 0.3, "种子": 0.2})
        
        # 随机选择奖励类型
        rand = random.random()
        cumulative = 0
        reward_type = "金币"
        
        for r_type, weight in type_weights.items():
            cumulative += weight
            if rand < cumulative:
                reward_type = r_type
                break
        
        # 生成具体奖励
        if reward_type == "金币":
            coin_range = rarity_config.get("金币范围", [100, 300])
            return {
                "type": "coins",
                "name": "金币",
                "rarity": rarity,
                "amount": random.randint(coin_range[0], coin_range[1])
            }
        
        elif reward_type == "经验":
            exp_range = rarity_config.get("经验范围", [50, 150])
            return {
                "type": "exp",
                "name": "经验",
                "rarity": rarity,
                "amount": random.randint(exp_range[0], exp_range[1])
            }
        
        elif reward_type == "种子":
            seeds = seed_pools.get(rarity, [])
            if not seeds:
                # 如果没有对应稀有度的种子，给金币
                coin_range = rarity_config.get("金币范围", [100, 300])
                return {
                    "type": "coins",
                    "name": "金币",
                    "rarity": rarity,
                    "amount": random.randint(coin_range[0], coin_range[1])
                }
            
            seed_count_range = rarity_config.get("种子数量", [1, 2])
            return {
                "type": "seed",
                "name": random.choice(seeds),
                "rarity": rarity,
                "amount": random.randint(seed_count_range[0], seed_count_range[1])
            }
        
        elif reward_type == "礼包":
            package_config = config.get("礼包配置", {})
            package_names = [name for name, info in package_config.items() if info.get("稀有度") == rarity]
            
            if not package_names:
                # 如果没有对应稀有度的礼包，给金币
                coin_range = rarity_config.get("金币范围", [100, 300])
                return {
                    "type": "coins",
                    "name": "金币",
                    "rarity": rarity,
                    "amount": random.randint(coin_range[0], coin_range[1])
                }
            
            package_name = random.choice(package_names)
            package_info = package_config[package_name]
            contents = []
            
            # 生成礼包内容
            content_config = package_info.get("内容", {})
            
            if "金币" in content_config:
                coin_range = content_config["金币"]
                contents.append({
                    "type": "coins",
                    "amount": random.randint(coin_range[0], coin_range[1]),
                    "rarity": rarity
                })
            
            if "经验" in content_config:
                exp_range = content_config["经验"]
                contents.append({
                    "type": "exp",
                    "amount": random.randint(exp_range[0], exp_range[1]),
                    "rarity": rarity
                })
            
            if "种子数量" in content_config:
                seed_count_range = content_config["种子数量"]
                lower_rarity = {"优良": "普通", "稀有": "优良", "史诗": "稀有", "传奇": "史诗"}.get(rarity, "普通")
                seeds = seed_pools.get(lower_rarity, [])
                if seeds:
                    contents.append({
                        "type": "seed",
                        "name": random.choice(seeds),
                        "amount": random.randint(seed_count_range[0], seed_count_range[1]),
                        "rarity": rarity
                    })
            
            return {
                "type": "package",
                "name": package_name,
                "rarity": rarity,
                "amount": 1,
                "contents": contents
            }
        
        # 默认给金币
        coin_range = rarity_config.get("金币范围", [100, 300])
        return {
            "type": "coins",
            "name": "金币",
            "rarity": rarity,
            "amount": random.randint(coin_range[0], coin_range[1])
        }
    
    #应用幸运抽奖奖励到玩家数据
    def _apply_lucky_draw_rewards(self, player_data, rewards):
        """应用幸运抽奖奖励到玩家数据"""
        for reward in rewards:
            reward_type = reward.get("type", "empty")
            
            if reward_type == "empty":
                continue  # 空奖励不处理
            
            elif reward_type == "coins":
                player_data["钱币"] = player_data.get("钱币", 0) + reward.get("amount", 0)
            
            elif reward_type == "exp":
                player_data["经验值"] = player_data.get("经验值", 0) + reward.get("amount", 0)
                
                # 检查升级
                level_up_experience = 100 * player_data.get("等级", 1)
                while player_data.get("经验值", 0) >= level_up_experience:
                    player_data["等级"] = player_data.get("等级", 1) + 1
                    player_data["经验值"] -= level_up_experience
                    level_up_experience = 100 * player_data["等级"]
            
            elif reward_type == "seed":
                if "种子仓库" not in player_data:
                    player_data["种子仓库"] = []
                
                # 查找背包中是否已有该种子
                found = False
                for item in player_data["种子仓库"]:
                    if item.get("name") == reward.get("name", ""):
                        item["count"] += reward.get("amount", 0)
                        found = True
                        break
                
                # 如果背包中没有，添加新条目
                if not found:
                    player_data["种子仓库"].append({
                        "name": reward.get("name", "未知种子"),
                        "quality": reward.get("rarity", "普通"),
                        "count": reward.get("amount", 0)
                    })
            
            elif reward_type == "package":
                # 递归处理礼包内容
                contents = reward.get("contents", [])
                if contents:
                    # 为礼包内容添加默认的rarity字段
                    for content in contents:
                        if not content.get("rarity"):
                            content["rarity"] = reward.get("rarity", "普通")
                    
                    # 递归处理礼包内容
                    self._apply_lucky_draw_rewards(player_data, contents)
    
#==========================幸运抽奖处理==========================


#==========================发送游戏操作错误处理==========================
    #发送游戏操作错误
    def _send_action_error(self, client_id, action_type, message):
        """发送游戏操作错误响应"""
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": action_type,
            "success": False,
            "message": message
        })
#==========================发送游戏操作错误处理==========================   


# ================================账户设置处理方法================================
    def _handle_modify_account_info_request(self, client_id, message):
        """处理修改账号信息请求"""
        # 检查用户是否已登录
        is_logged_in, error_response = self._check_user_logged_in(client_id, "修改账号信息")
        if not is_logged_in:
            return self._send_modify_account_error(client_id, error_response["message"])
        
        # 加载玩家数据
        player_data, username, error_response = self._load_player_data_with_check(client_id, "modify_account_info")
        if not player_data:
            return self.send_data(client_id, error_response)
        
        # 获取新的信息
        new_password = message.get("new_password", "").strip()
        new_player_name = message.get("new_player_name", "").strip()
        new_farm_name = message.get("new_farm_name", "").strip()
        new_personal_profile = message.get("new_personal_profile", "").strip()
        
        # 验证输入
        if not new_password:
            return self._send_modify_account_error(client_id, "密码不能为空")
        
        if not new_player_name:
            return self._send_modify_account_error(client_id, "玩家昵称不能为空")
        
        if not new_farm_name:
            return self._send_modify_account_error(client_id, "农场名称不能为空")

        if len(new_player_name) > 20:
            return self._send_modify_account_error(client_id, "玩家昵称不能超过20个字符")
        
        if len(new_farm_name) > 20:
            return self._send_modify_account_error(client_id, "农场名称不能超过20个字符")
        
        if len(new_personal_profile) > 100:
            return self._send_modify_account_error(client_id, "个人简介不能超过100个字符")
        
        try:
            # 更新玩家数据
            player_data["玩家密码"] = new_password
            player_data["玩家昵称"] = new_player_name
            player_data["农场名称"] = new_farm_name
            player_data["个人简介"] = new_personal_profile
            
            # 保存到文件
            self.save_player_data(username, player_data)
            
            # 发送成功响应
            self.send_data(client_id, {
                "type": "modify_account_info_response",
                "success": True,
                "message": "账号信息修改成功",
                "updated_data": {
                    "玩家密码": new_password,
                    "玩家昵称": new_player_name,
                    "农场名称": new_farm_name,
                    "个人简介": new_personal_profile
                }
            })
            
            self.log('INFO', f"用户 {username} 修改账号信息成功", 'ACCOUNT')
            
        except Exception as e:
            self.log('ERROR', f"修改账号信息时出错: {str(e)}", 'ACCOUNT')
            return self._send_modify_account_error(client_id, "修改账号信息失败，请稍后重试")

    def _handle_delete_account_request(self, client_id, message):
        """处理删除账号请求"""
        # 检查用户是否已登录
        is_logged_in, error_response = self._check_user_logged_in(client_id, "删除账号")
        if not is_logged_in:
            return self._send_delete_account_error(client_id, error_response["message"])
        
        # 获取用户名
        username = self.user_data[client_id]["username"]
        
        try:
            # 优先从MongoDB删除
            if self.use_mongodb and self.mongo_api:
                success = self.mongo_api.delete_player_data(username)
                if not success:
                    self.log('WARNING', f"MongoDB删除失败，尝试删除文件: {username}", 'ACCOUNT')
            
            # 清理用户数据
            if client_id in self.user_data:
                del self.user_data[client_id]
            
            # 发送成功响应
            self.send_data(client_id, {
                "type": "delete_account_response",
                "success": True,
                "message": "账号删除成功，即将返回主菜单"
            })
            
            self.log('INFO', f"用户 {username} 账号删除成功", 'ACCOUNT')
            
            # 稍后断开连接
            import threading
            def delayed_disconnect():
                import time
                time.sleep(2)
                self._remove_client(client_id)
            
            disconnect_thread = threading.Thread(target=delayed_disconnect)
            disconnect_thread.daemon = True
            disconnect_thread.start()
            
        except Exception as e:
            self.log('ERROR', f"删除账号时出错: {str(e)}", 'ACCOUNT')
            return self._send_delete_account_error(client_id, "删除账号失败，请稍后重试")

    def _handle_refresh_player_info_request(self, client_id, message):
        """处理刷新玩家信息请求"""
        # 检查用户是否已登录
        is_logged_in, error_response = self._check_user_logged_in(client_id, "刷新玩家信息")
        if not is_logged_in:
            return self._send_refresh_info_error(client_id, error_response["message"])
        
        # 获取用户名
        username = self.user_data[client_id]["username"]
        
        try:
            # 强制从数据库重新加载最新数据
            player_data = self.load_player_data(username)
            if not player_data:
                return self._send_refresh_info_error(client_id, "无法加载玩家数据")
            
            # 只发送账户相关信息，不发送农场数据等
            account_info = {
                "玩家账号": player_data.get("玩家账号", ""),
                "玩家密码": player_data.get("玩家密码", ""),
                "玩家昵称": player_data.get("玩家昵称", ""),
                "农场名称": player_data.get("农场名称", ""),
                "个人简介": player_data.get("个人简介", ""),
                "等级": player_data.get("等级", 1),
                "经验值": player_data.get("经验值", 0),
                "钱币": player_data.get("钱币", 0)
            }
            
            # 发送刷新后的账户信息
            self.send_data(client_id, {
                "type": "refresh_player_info_response",
                "success": True,
                "message": "玩家信息已刷新",
                "account_info": account_info
            })
            
            self.log('INFO', f"用户 {username} 刷新玩家信息成功", 'ACCOUNT')
            
        except Exception as e:
            self.log('ERROR', f"刷新玩家信息时出错: {str(e)}", 'ACCOUNT')
            return self._send_refresh_info_error(client_id, "刷新玩家信息失败，请稍后重试")

    def _send_modify_account_error(self, client_id, message):
        """发送修改账号信息错误响应"""
        self.send_data(client_id, {
            "type": "modify_account_info_response",
            "success": False,
            "message": message
        })

    def _send_delete_account_error(self, client_id, message):
        """发送删除账号错误响应"""
        self.send_data(client_id, {
            "type": "delete_account_response",
            "success": False,
            "message": message
        })

    def _send_refresh_info_error(self, client_id, message):
        """发送刷新信息错误响应"""
        self.send_data(client_id, {
            "type": "refresh_player_info_response",
            "success": False,
            "message": message
        })

    #处理背包数据同步消息
    def _handle_sync_bag_data(self, client_id, message):
        """处理背包数据同步请求"""
        username = self.user_data.get(client_id, {}).get("username")
        
        if not username:
            return self.send_data(client_id, {
                "type": "sync_bag_data_response",
                "success": False,
                "message": "用户未登录"
            })
        
        # 从数据库加载最新的玩家数据
        player_data = self.load_player_data(username)
        if not player_data:
            return self.send_data(client_id, {
                "type": "sync_bag_data_response",
                "success": False,
                "message": "玩家数据加载失败"
            })
        
        # 提取所有背包数据
        bag_data = {
            "道具背包": player_data.get("道具背包", []),
            "宠物背包": player_data.get("宠物背包", []),
            "种子仓库": player_data.get("种子仓库", []),
            "作物仓库": player_data.get("作物仓库", [])
        }
        
        self.log('INFO', f"用户 {username} 请求同步背包数据", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "sync_bag_data_response",
            "success": True,
            "message": "背包数据同步成功",
            "bag_data": bag_data
        })
    
    def _handle_kick_player(self, client_id, message):
        """处理踢出玩家消息（服务器内部使用）"""
        # 这个函数主要用于接收来自控制台命令的踢出消息
        # 实际的踢出逻辑在 ConsoleCommandsAPI 中处理
        reason = message.get("reason", "您已被管理员踢出服务器")
        duration = message.get("duration", 0)
        
        # 发送踢出通知给客户端
        response = {
            "type": "kick_notification",
            "reason": reason,
            "duration": duration,
            "message": reason
        }
        
        self.log('INFO', f"向客户端 {client_id} 发送踢出通知: {reason}", 'SERVER')
        return self.send_data(client_id, response)

# ================================账户设置处理方法================================


#==========================稻草人系统处理==========================
    def _handle_buy_scare_crow(self, client_id, message):
        """处理购买稻草人请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "购买稻草人", "buy_scare_crow")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "buy_scare_crow")
        if not player_data:
            return self.send_data(client_id, response)
        
        scare_crow_type = message.get("scare_crow_type", "")
        price = message.get("price", 0)
        
        # 加载稻草人配置
        scare_crow_config = self._load_scare_crow_config()
        if not scare_crow_config:
            return self._send_buy_scare_crow_error(client_id, "服务器无法加载稻草人配置")
        
        # 检查稻草人类型是否存在
        if scare_crow_type not in scare_crow_config.get("稻草人类型", {}):
            return self._send_buy_scare_crow_error(client_id, "该稻草人类型不存在")
        
        # 验证价格是否正确
        actual_price = scare_crow_config["稻草人类型"][scare_crow_type]["价格"]
        if price != actual_price:
            return self._send_buy_scare_crow_error(client_id, f"稻草人价格验证失败，实际价格为{actual_price}金币")
        
        # 检查玩家金钱
        if player_data["钱币"] < price:
            return self._send_buy_scare_crow_error(client_id, f"金币不足，需要{price}金币，当前只有{player_data['money']}金币")
        
        # 确保稻草人配置存在
        if "稻草人配置" not in player_data:
            player_data["稻草人配置"] = {
                "已拥有稻草人类型": ["稻草人1"],
                "稻草人展示类型": "",
                "稻草人昵称": "我的稻草人",
                "稻草人昵称颜色": "#ffffff",
                "稻草人说的话": {
                    "第一句话": {"内容": "", "颜色": "#000000"},
                    "第二句话": {"内容": "", "颜色": "#000000"},
                    "第三句话": {"内容": "", "颜色": "#000000"},
                    "第四句话": {"内容": "", "颜色": "#000000"}
                }
            }
        
        # 检查是否已拥有该稻草人
        if scare_crow_type in player_data["稻草人配置"]["已拥有稻草人类型"]:
            return self._send_buy_scare_crow_error(client_id, f"你已经拥有{scare_crow_type}了")
        
        # 扣除金钱
        player_data["钱币"] -= price
        
        # 添加稻草人到已拥有列表
        player_data["稻草人配置"]["已拥有稻草人类型"].append(scare_crow_type)
        
        # 如果是第一个稻草人，设置为展示类型
        if player_data["稻草人配置"]["稻草人展示类型"] == "":
            player_data["稻草人配置"]["稻草人展示类型"] = scare_crow_type
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        self.log('INFO', f"玩家 {username} 购买了稻草人 {scare_crow_type}，花费 {price} 金币", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "buy_scare_crow_response",
            "success": True,
            "message": f"成功购买{scare_crow_type}！",
            "updated_data": {
                "钱币": player_data["钱币"],
                "稻草人配置": player_data["稻草人配置"]
            }
        })
    
    def _handle_modify_scare_crow_config(self, client_id, message):
        """处理修改稻草人配置请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "修改稻草人配置", "modify_scare_crow_config")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "modify_scare_crow_config")
        if not player_data:
            return self.send_data(client_id, response)
        
        config_data = message.get("config_data", {})
        modify_cost = message.get("modify_cost", 300)
        
        # 加载稻草人配置
        scare_crow_config = self._load_scare_crow_config()
        if not scare_crow_config:
            return self._send_modify_scare_crow_config_error(client_id, "服务器无法加载稻草人配置")
        
        # 检查是否只是切换展示类型（不收费）
        is_only_changing_display = (
            len(config_data) == 1 and 
            "稻草人展示类型" in config_data and 
            modify_cost == 0
        )
        
        if not is_only_changing_display:
            # 验证修改费用
            actual_cost = scare_crow_config.get("修改稻草人配置花费", 300)
            if modify_cost != actual_cost:
                return self._send_modify_scare_crow_config_error(client_id, f"修改费用验证失败，实际费用为{actual_cost}金币")
            
            # 检查玩家金钱
            if player_data["钱币"] < modify_cost:
                return self._send_modify_scare_crow_config_error(client_id, f"金币不足，需要{modify_cost}金币，当前只有{player_data['money']}金币")
        
        # 确保稻草人配置存在
        if "稻草人配置" not in player_data:
            return self._send_modify_scare_crow_config_error(client_id, "你还没有稻草人，请先购买稻草人")
        
        # 只在非切换展示类型时扣除金钱
        if not is_only_changing_display:
            player_data["钱币"] -= modify_cost
        
        # 更新稻草人配置
        if "稻草人展示类型" in config_data:
            # 检查展示类型是否已拥有
            owned_types = player_data["稻草人配置"].get("已拥有稻草人类型", [])
            if config_data["稻草人展示类型"] in owned_types:
                player_data["稻草人配置"]["稻草人展示类型"] = config_data["稻草人展示类型"]
            else:
                return self._send_modify_scare_crow_config_error(client_id, "你没有拥有该稻草人类型")
        
        if "稻草人昵称" in config_data:
            player_data["稻草人配置"]["稻草人昵称"] = config_data["稻草人昵称"]
        
        if "稻草人昵称颜色" in config_data:
            player_data["稻草人配置"]["稻草人昵称颜色"] = config_data["稻草人昵称颜色"]
        
        if "稻草人说的话" in config_data:
            player_data["稻草人配置"]["稻草人说的话"] = config_data["稻草人说的话"]
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        if is_only_changing_display:
            self.log('INFO', f"玩家 {username} 切换了稻草人展示类型到 {config_data['稻草人展示类型']}", 'SERVER')
            message = f"成功切换到{config_data['稻草人展示类型']}！"
        else:
            self.log('INFO', f"玩家 {username} 修改了稻草人配置，花费 {modify_cost} 金币", 'SERVER')
            message = f"稻草人配置修改成功！花费{modify_cost}金币"
        
        return self.send_data(client_id, {
            "type": "modify_scare_crow_config_response",
            "success": True,
            "message": message,
            "updated_data": {
                "钱币": player_data["钱币"],
                "稻草人配置": player_data["稻草人配置"]
            }
        })
    
    def _handle_get_scare_crow_config(self, client_id, message):
        """处理获取稻草人配置请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "获取稻草人配置", "get_scare_crow_config")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "get_scare_crow_config")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 确保稻草人配置存在
        if "稻草人配置" not in player_data:
            player_data["稻草人配置"] = {
                "已拥有稻草人类型": [],
                "稻草人展示类型": "",
                "稻草人昵称": "我的稻草人",
                "稻草人昵称颜色": "#ffffff",
                "稻草人说的话": {
                    "第一句话": {"内容": "", "颜色": "#000000"},
                    "第二句话": {"内容": "", "颜色": "#000000"},
                    "第三句话": {"内容": "", "颜色": "#000000"},
                    "第四句话": {"内容": "", "颜色": "#000000"}
                }
            }
            # 保存默认配置
            self.save_player_data(username, player_data)
        
        return self.send_data(client_id, {
            "type": "get_scare_crow_config_response",
            "success": True,
            "message": "获取稻草人配置成功",
            "scare_crow_config": player_data["稻草人配置"]
        })
    
    def _load_scare_crow_config(self):
        """加载稻草人配置"""
        try:
            if hasattr(self, 'mongo_api') and self.mongo_api and self.mongo_api.is_connected():
                config = self.mongo_api.get_scare_crow_config()
                if config:
                    self.log('INFO', "成功从MongoDB加载稻草人配置", 'SERVER')
                    return config
                else:
                    self.log('WARNING', "MongoDB中未找到稻草人配置，使用默认配置", 'SERVER')
            else:
                self.log('WARNING', "MongoDB未连接，使用默认稻草人配置", 'SERVER')
        except Exception as e:
            self.log('ERROR', f"从MongoDB加载稻草人配置失败: {str(e)}，使用默认配置", 'SERVER')
        
        # 返回默认配置
        return {
            "稻草人类型": {
                "稻草人1": {"图片": "res://assets/道具图片/稻草人1.webp", "价格": 1000},
                "稻草人2": {"图片": "res://assets/道具图片/稻草人2.webp", "价格": 1000},
                "稻草人3": {"图片": "res://assets/道具图片/稻草人3.webp", "价格": 1000}
            },
            "修改稻草人配置花费": 300
        }
    
    def _send_buy_scare_crow_error(self, client_id, message):
        """发送购买稻草人错误响应"""
        return self.send_data(client_id, {
            "type": "buy_scare_crow_response",
            "success": False,
            "message": message
        })
    
    def _send_modify_scare_crow_config_error(self, client_id, message):
        """发送修改稻草人配置错误响应"""
        return self.send_data(client_id, {
            "type": "modify_scare_crow_config_response",
            "success": False,
            "message": message
        })
#==========================稻草人系统处理==========================





#==========================作物出售处理==========================
    def _handle_sell_crop(self, client_id, message):
        """处理作物出售请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "出售作物", "sell_crop")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "sell_crop")
        if not player_data:
            return self.send_data(client_id, response)
        
        crop_name = message.get("crop_name", "")
        sell_count = message.get("sell_count", 1)
        unit_price = message.get("unit_price", 0)
        
        # 验证参数
        if not crop_name:
            return self._send_action_error(client_id, "sell_crop", "作物名称不能为空")
        
        if sell_count <= 0:
            return self._send_action_error(client_id, "sell_crop", "出售数量必须大于0")
        
        if unit_price <= 0:
            return self._send_action_error(client_id, "sell_crop", "单价必须大于0")
        
        # 检查作物仓库中是否有足够的作物
        crop_warehouse = player_data.get("作物仓库", [])
        crop_found = False
        crop_index = -1
        available_count = 0
        
        for i, crop_item in enumerate(crop_warehouse):
            if crop_item.get("name") == crop_name:
                crop_found = True
                crop_index = i
                available_count = crop_item.get("count", 0)
                break
        
        if not crop_found:
            return self._send_action_error(client_id, "sell_crop", f"作物仓库中没有 {crop_name}")
        
        if available_count < sell_count:
            return self._send_action_error(client_id, "sell_crop", f"作物数量不足，仓库中只有 {available_count} 个 {crop_name}")
        
        # 验证价格（防止客户端篡改价格）
        crop_data = self._load_crop_data()
        if crop_name in crop_data:
            expected_price = crop_data[crop_name].get("收益", 0)
            if unit_price != expected_price:
                return self._send_action_error(client_id, "sell_crop", f"价格验证失败，{crop_name} 的正确价格应为 {expected_price} 元/个")
        else:
            return self._send_action_error(client_id, "sell_crop", f"未知的作物类型：{crop_name}")
        
        # 计算总收入
        total_income = sell_count * unit_price
        
        # 执行出售操作
        player_data["钱币"] += total_income
        
        # 从作物仓库中减少数量
        crop_warehouse[crop_index]["count"] -= sell_count
        
        # 如果数量为0，从仓库中移除该作物
        if crop_warehouse[crop_index]["count"] <= 0:
            crop_warehouse.pop(crop_index)
        
        # 给予少量出售经验
        sell_experience = max(1, sell_count // 5)  # 每5个作物给1点经验
        player_data["经验值"] += sell_experience
        
        # 检查是否升级
        self._check_level_up(player_data)
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        # 获取显示名称
        display_name = crop_name
        if crop_name in crop_data:
            mature_name = crop_data[crop_name].get("成熟物名称")
            if mature_name:
                display_name = mature_name
            else:
                display_name = crop_data[crop_name].get("作物名称", crop_name)
        
        self.log('INFO', f"玩家 {username} 出售了 {sell_count} 个 {crop_name}，获得 {total_income} 金币和 {sell_experience} 经验", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "sell_crop",
            "success": True,
            "message": f"成功出售 {sell_count} 个 {display_name}，获得 {total_income} 金币和 {sell_experience} 经验",
            "updated_data": {
                "钱币": player_data["钱币"],
                "经验值": player_data["经验值"],
                "等级": player_data["等级"],
                "作物仓库": player_data["作物仓库"]
            }
        })
#==========================作物出售处理==========================


#==========================小卖部管理处理==========================
    def _handle_add_product_to_store(self, client_id, message):
        """处理添加商品到小卖部请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "添加商品到小卖部", "add_product_to_store")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "add_product_to_store")
        if not player_data:
            return self.send_data(client_id, response)
        
        product_type = message.get("product_type", "")
        product_name = message.get("product_name", "")
        product_count = message.get("product_count", 1)
        product_price = message.get("product_price", 0)
        
        # 验证参数
        if not product_type or not product_name:
            return self._send_action_error(client_id, "add_product_to_store", "商品类型或名称不能为空")
        
        if product_count <= 0:
            return self._send_action_error(client_id, "add_product_to_store", "商品数量必须大于0")
        
        if product_price <= 0:
            return self._send_action_error(client_id, "add_product_to_store", "商品价格必须大于0")
        
        # 初始化小卖部数据
        if "小卖部配置" not in player_data:
            player_data["小卖部配置"] = {
                "商品列表": [],
                "格子数": 10
            }
        
        store_config = player_data["小卖部配置"]
        player_store = store_config["商品列表"]
        max_slots = store_config["格子数"]
        
        # 检查小卖部格子是否已满
        if len(player_store) >= max_slots:
            return self._send_action_error(client_id, "add_product_to_store", f"小卖部格子已满({len(player_store)}/{max_slots})")
        
        # 检查作物仓库中是否有足够的商品
        if product_type == "作物":
            crop_warehouse = player_data.get("作物仓库", [])
            crop_found = False
            crop_index = -1
            available_count = 0
            
            for i, crop_item in enumerate(crop_warehouse):
                if crop_item.get("name") == product_name:
                    crop_found = True
                    crop_index = i
                    available_count = crop_item.get("count", 0)
                    break
            
            if not crop_found:
                return self._send_action_error(client_id, "add_product_to_store", f"作物仓库中没有 {product_name}")
            
            if available_count < product_count:
                return self._send_action_error(client_id, "add_product_to_store", f"作物数量不足，仓库中只有 {available_count} 个 {product_name}")
            
            # 从作物仓库中扣除商品
            crop_warehouse[crop_index]["count"] -= product_count
            if crop_warehouse[crop_index]["count"] <= 0:
                crop_warehouse.pop(crop_index)
        
        # 添加商品到小卖部
        new_product = {
            "商品类型": product_type,
            "商品名称": product_name,
            "商品价格": product_price,
            "商品数量": product_count
        }
        player_store.append(new_product)
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        self.log('INFO', f"玩家 {username} 添加商品到小卖部: {product_name} x{product_count}, 价格 {product_price}元/个", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "add_product_to_store",
            "success": True,
            "message": f"成功添加 {product_count} 个 {product_name} 到小卖部",
            "updated_data": {
                "小卖部配置": player_data["小卖部配置"],
                "作物仓库": player_data.get("作物仓库", [])
            }
        })
    
    def _handle_remove_store_product(self, client_id, message):
        """处理下架小卖部商品请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "下架小卖部商品", "remove_store_product")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "remove_store_product")
        if not player_data:
            return self.send_data(client_id, response)
        
        slot_index = message.get("slot_index", -1)
        
        # 验证参数
        if slot_index < 0:
            return self._send_action_error(client_id, "remove_store_product", "无效的商品槽位")
        
        # 检查小卖部数据
        store_config = player_data.get("小卖部配置", {"商品列表": [], "格子数": 10})
        player_store = store_config.get("商品列表", [])
        if slot_index >= len(player_store):
            return self._send_action_error(client_id, "remove_store_product", "商品槽位不存在")
        
        # 获取要下架的商品信息
        product_data = player_store[slot_index]
        product_type = product_data.get("商品类型", "")
        product_name = product_data.get("商品名称", "")
        product_count = product_data.get("商品数量", 0)
        
        # 将商品返回到对应仓库
        if product_type == "作物":
            # 返回到作物仓库
            if "作物仓库" not in player_data:
                player_data["作物仓库"] = []
            
            crop_warehouse = player_data["作物仓库"]
            # 查找是否已有该作物
            crop_found = False
            for crop_item in crop_warehouse:
                if crop_item.get("name") == product_name:
                    crop_item["count"] += product_count
                    crop_found = True
                    break
            
            if not crop_found:
                # 添加新的作物条目
                crop_data = self._load_crop_data()
                quality = "普通"
                if crop_data and product_name in crop_data:
                    quality = crop_data[product_name].get("品质", "普通")
                
                crop_warehouse.append({
                    "name": product_name,
                    "quality": quality,
                    "count": product_count
                })
        
        # 从小卖部移除商品
        player_store.pop(slot_index)
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        self.log('INFO', f"玩家 {username} 下架小卖部商品: {product_name} x{product_count}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "remove_store_product",
            "success": True,
            "message": f"成功下架 {product_count} 个 {product_name}，已返回仓库",
            "updated_data": {
                "小卖部配置": player_data["小卖部配置"],
                "作物仓库": player_data.get("作物仓库", [])
            }
        })
    
    def _handle_buy_store_product(self, client_id, message):
        """处理购买小卖部商品请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "购买小卖部商品", "buy_store_product")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取买家数据
        buyer_data, buyer_username, response = self._load_player_data_with_check(client_id, "buy_store_product")
        if not buyer_data:
            return self.send_data(client_id, response)
        
        seller_username = message.get("seller_username", "")
        slot_index = message.get("slot_index", -1)
        product_name = message.get("product_name", "")
        unit_price = message.get("unit_price", 0)
        quantity = message.get("quantity", 1)
        
        # 验证参数
        if not seller_username:
            return self._send_action_error(client_id, "buy_store_product", "卖家用户名不能为空")
        
        if slot_index < 0:
            return self._send_action_error(client_id, "buy_store_product", "无效的商品槽位")
        
        if quantity <= 0:
            return self._send_action_error(client_id, "buy_store_product", "购买数量必须大于0")
        
        # 检查是否是自己购买自己的商品
        if buyer_username == seller_username:
            return self._send_action_error(client_id, "buy_store_product", "不能购买自己的商品")
        
        # 加载卖家数据
        seller_data = self.load_player_data(seller_username)
        if not seller_data:
            return self._send_action_error(client_id, "buy_store_product", f"卖家 {seller_username} 不存在")
        
        # 检查卖家小卖部
        seller_store_config = seller_data.get("小卖部配置", {"商品列表": [], "格子数": 10})
        seller_store = seller_store_config.get("商品列表", [])
        if slot_index >= len(seller_store):
            return self._send_action_error(client_id, "buy_store_product", "商品不存在")
        
        product_data = seller_store[slot_index]
        product_type = product_data.get("商品类型", "")
        store_product_name = product_data.get("商品名称", "")
        store_unit_price = product_data.get("商品价格", 0)
        available_count = product_data.get("商品数量", 0)
        
        # 验证商品信息
        if store_product_name != product_name:
            return self._send_action_error(client_id, "buy_store_product", "商品名称不匹配")
        
        if store_unit_price != unit_price:
            return self._send_action_error(client_id, "buy_store_product", "商品价格已变更，请刷新重试")
        
        if available_count < quantity:
            return self._send_action_error(client_id, "buy_store_product", f"商品库存不足，仅剩 {available_count} 个")
        
        # 计算总价
        total_cost = quantity * unit_price
        
        # 检查买家金钱是否足够
        if buyer_data["钱币"] < total_cost:
            return self._send_action_error(client_id, "buy_store_product", f"金钱不足，需要 {total_cost} 元")
        
        # 执行交易
        buyer_data["钱币"] -= total_cost
        seller_data["钱币"] += total_cost
        
        # 扣除卖家商品
        seller_store[slot_index]["商品数量"] -= quantity
        if seller_store[slot_index]["商品数量"] <= 0:
            seller_store.pop(slot_index)
        
        # 给买家添加商品
        if product_type == "作物":
            if "作物仓库" not in buyer_data:
                buyer_data["作物仓库"] = []
            
            buyer_warehouse = buyer_data["作物仓库"]
            # 查找是否已有该作物
            crop_found = False
            for crop_item in buyer_warehouse:
                if crop_item.get("name") == product_name:
                    crop_item["count"] += quantity
                    crop_found = True
                    break
            
            if not crop_found:
                # 添加新的作物条目
                crop_data = self._load_crop_data()
                quality = "普通"
                if crop_data and product_name in crop_data:
                    quality = crop_data[product_name].get("品质", "普通")
                
                buyer_warehouse.append({
                    "name": product_name,
                    "quality": quality,
                    "count": quantity
                })
        
        # 保存两个玩家的数据
        self.save_player_data(buyer_username, buyer_data)
        self.save_player_data(seller_username, seller_data)
        
        self.log('INFO', f"玩家 {buyer_username} 从 {seller_username} 的小卖部购买了 {quantity} 个 {product_name}，花费 {total_cost} 元", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "buy_store_product",
            "success": True,
            "message": f"成功购买 {quantity} 个 {product_name}，花费 {total_cost} 元",
            "updated_data": {
                "钱币": buyer_data["钱币"],
                "作物仓库": buyer_data.get("作物仓库", [])
            }
        })
    
    def _handle_buy_store_booth(self, client_id, message):
        """处理购买小卖部格子请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "购买小卖部格子", "buy_store_booth")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "buy_store_booth")
        if not player_data:
            return self.send_data(client_id, response)
        
        cost = message.get("cost", 0)
        
        # 验证参数
        if cost <= 0:
            return self._send_action_error(client_id, "buy_store_booth", "无效的购买费用")
        
        # 初始化小卖部数据
        if "小卖部配置" not in player_data:
            player_data["小卖部配置"] = {
                "商品列表": [],
                "格子数": 10
            }
        
        store_config = player_data["小卖部配置"]
        current_slots = store_config["格子数"]
        
        # 检查是否已达上限
        if current_slots >= 40:
            return self._send_action_error(client_id, "buy_store_booth", "小卖部格子数已达上限(40)")
        
        # 验证费用
        expected_cost = 1000 + (current_slots - 10) * 500
        if cost != expected_cost:
            return self._send_action_error(client_id, "buy_store_booth", f"费用不正确，应为 {expected_cost} 元")
        
        # 检查玩家金钱是否足够
        if player_data["钱币"] < cost:
            return self._send_action_error(client_id, "buy_store_booth", f"金钱不足，需要 {cost} 元")
        
        # 执行购买
        player_data["钱币"] -= cost
        store_config["格子数"] += 1
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        self.log('INFO', f"玩家 {username} 购买小卖部格子，花费 {cost} 元，格子数：{current_slots} -> {store_config['格子数']}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "action_response",
            "action_type": "buy_store_booth",
            "success": True,
            "message": f"成功购买格子，花费 {cost} 元，当前格子数：{store_config['格子数']}",
            "updated_data": {
                "钱币": player_data["钱币"],
                "小卖部配置": player_data["小卖部配置"]
            }
        })
#==========================小卖部管理处理==========================


#==========================今日占卜处理==========================
    def _handle_today_divination(self, client_id, message):
        """处理今日占卜请求"""
        # 检查用户是否已登录
        logged_in, response = self._check_user_logged_in(client_id, "今日占卜", "today_divination")
        if not logged_in:
            return self.send_data(client_id, response)
        
        # 获取玩家数据
        player_data, username, response = self._load_player_data_with_check(client_id, "today_divination")
        if not player_data:
            return self.send_data(client_id, response)
        
        # 获取今日日期
        today = datetime.datetime.now().strftime("%Y-%m-%d")
        
        # 检查今日占卜对象是否存在
        if "今日占卜对象" not in player_data:
            player_data["今日占卜对象"] = {}
        
        divination_data = player_data["今日占卜对象"]
        
        # 检查今日是否已经占卜过
        if "占卜日期" in divination_data and divination_data["占卜日期"] == today:
            return self.send_data(client_id, {
                "type": "today_divination_response",
                "success": False,
                "message": "今日已经占卜过了，明天再来吧！",
                "divination_data": player_data
            })
        
        # 生成占卜结果
        divination_result = self._generate_divination_result()
        
        # 更新玩家占卜数据
        divination_data["占卜日期"] = today
        divination_data["占卜结果"] = divination_result["result"]
        divination_data["占卜等级"] = divination_result["level"]
        divination_data["卦象"] = divination_result["hexagram"]
        divination_data["建议"] = divination_result["advice"]
        
        # 保存玩家数据
        self.save_player_data(username, player_data)
        
        self.log('INFO', f"玩家 {username} 进行今日占卜，等级：{divination_result['level']}", 'SERVER')
        
        return self.send_data(client_id, {
            "type": "today_divination_response",
            "success": True,
            "message": "占卜完成！",
            "divination_data": player_data
        })
    
    def _generate_divination_result(self):
        """生成占卜结果"""
        import random
        
        # 占卜等级配置（权重越高，出现概率越大）
        levels = [
            {"name": "大吉", "weight": 5, "color": "#FFD700"},
            {"name": "中吉", "weight": 15, "color": "#FFA500"},
            {"name": "小吉", "weight": 25, "color": "#90EE90"},
            {"name": "平", "weight": 30, "color": "#87CEEB"},
            {"name": "小凶", "weight": 20, "color": "#DDA0DD"},
            {"name": "凶", "weight": 5, "color": "#FF6347"}
        ]
        
        # 易经八卦
        hexagrams = [
            {"name": "乾卦", "symbol": "☰", "meaning": "天行健，君子以自强不息"},
            {"name": "坤卦", "symbol": "☷", "meaning": "地势坤，君子以厚德载物"},
            {"name": "震卦", "symbol": "☳", "meaning": "雷声隆隆，万物复苏"},
            {"name": "巽卦", "symbol": "☴", "meaning": "风行天下，顺势而为"},
            {"name": "坎卦", "symbol": "☵", "meaning": "水流不息，智慧如泉"},
            {"name": "离卦", "symbol": "☲", "meaning": "火光明亮，照耀前程"},
            {"name": "艮卦", "symbol": "☶", "meaning": "山高水长，稳如磐石"},
            {"name": "兑卦", "symbol": "☱", "meaning": "泽润万物，和谐共生"}
        ]
        
        # 占卜结果文案
        results = {
            "大吉": [
                "今日运势如虹，万事皆宜，财运亨通，贵人相助！",
                "紫气东来，福星高照，今日必有喜事临门！",
                "天时地利人和，今日是您大展宏图的好日子！"
            ],
            "中吉": [
                "今日运势不错，做事顺利，宜把握机会！",
                "春风得意，今日适合开展新计划！",
                "运势上升，今日努力必有收获！"
            ],
            "小吉": [
                "今日运势平稳向好，小有收获！",
                "和风细雨，今日宜静心修身！",
                "运势渐佳，今日适合稳步前进！"
            ],
            "平": [
                "今日运势平稳，宜守不宜攻！",
                "平平淡淡才是真，今日适合休养生息！",
                "运势平和，今日宜保持现状！"
            ],
            "小凶": [
                "今日运势略有波折，宜谨慎行事！",
                "小心驶得万年船，今日宜低调处事！",
                "运势稍逊，今日宜多思而后行！"
            ],
            "凶": [
                "今日运势欠佳，宜静待时机！",
                "山雨欲来风满楼，今日宜避其锋芒！",
                "运势低迷，今日宜韬光养晦！"
            ]
        }
        
        # 建议文案
        advice_list = {
            "大吉": [
                "今日宜：投资理财、开展新业务、拜访贵人",
                "今日宜：签订合同、举办庆典、求婚表白",
                "今日宜：出行旅游、购买重要物品、做重大决定"
            ],
            "中吉": [
                "今日宜：学习进修、拓展人脉、适度投资",
                "今日宜：整理规划、健身运动、与朋友聚会",
                "今日宜：处理积压事务、改善居住环境"
            ],
            "小吉": [
                "今日宜：读书思考、轻松娱乐、关爱家人",
                "今日宜：整理物品、制定计划、适度休息",
                "今日宜：培养兴趣、与人为善、保持乐观"
            ],
            "平": [
                "今日宜：维持现状、按部就班、稳中求进",
                "今日宜：反思总结、调整心态、积蓄力量",
                "今日宜：关注健康、陪伴家人、平和处事"
            ],
            "小凶": [
                "今日忌：冲动决定、大额消费、与人争执",
                "今日忌：签重要合同、做重大变动、外出远行",
                "今日宜：谨言慎行、低调做人、耐心等待"
            ],
            "凶": [
                "今日忌：投资冒险、开展新项目、做重要决定",
                "今日忌：与人冲突、外出办事、签署文件",
                "今日宜：静心修养、反省自身、等待转机"
            ]
        }
        
        # 按权重随机选择等级
        total_weight = sum(level["weight"] for level in levels)
        rand_num = random.randint(1, total_weight)
        current_weight = 0
        
        selected_level = None
        for level in levels:
            current_weight += level["weight"]
            if rand_num <= current_weight:
                selected_level = level
                break
        
        # 随机选择卦象
        selected_hexagram = random.choice(hexagrams)
        
        # 随机选择对应等级的结果和建议
        level_name = selected_level["name"]
        selected_result = random.choice(results[level_name])
        selected_advice = random.choice(advice_list[level_name])
        
        return {
            "level": level_name,
            "level_color": selected_level["color"],
            "result": selected_result,
            "hexagram": f"{selected_hexagram['symbol']} {selected_hexagram['name']}",
            "hexagram_meaning": selected_hexagram["meaning"],
            "advice": selected_advice
        }
#==========================今日占卜处理==========================


def console_input_thread(server):
    """控制台输入处理线程"""

    
    # 等待服务器完全启动
    time.sleep(0.5)
    
    console = ConsoleCommandsAPI(server)
    
    # 创建输入锁，防止日志输出打乱命令输入
    input_lock = threading.Lock()
    server._console_input_lock = input_lock
    
    # 获取服务器IP地址
    server_ip = getattr(server, 'host', 'localhost')
    if server_ip == '0.0.0.0':
        server_ip = 'localhost'
    
    # 使用锁保护初始化消息输出
    with input_lock:
        print("💬 控制台已就绪，输入 'help' 查看可用命令")
    
    while True:
        try:
            # 使用自定义提示符格式，不使用锁避免阻塞
            prompt = f"mengyafarm#{server_ip}> "
            command = input(prompt).strip()
                
            if command:
                # 只在处理命令时使用锁，避免输出被打乱
                with input_lock:
                    console.process_command(command)
        except EOFError:
            break
        except KeyboardInterrupt:
            break
        except Exception as e:
            # 使用锁保护错误输出
            with input_lock:
                print(f"❌ 处理命令时出错: {str(e)}")

# 主程序启动入口
if __name__ == "__main__":
    import sys
    
    try:
        print("=" * 60)
        print(f"🌱 萌芽农场游戏服务器 v{server_version} 🌱")
        print("=" * 60)
        print(f"📡 服务器地址: {server_host}:{server_port}")
        print(f"📦 缓冲区大小: {buffer_size} bytes")
        print("=" * 60)
        
        # 创建并启动游戏服务器
        server = TCPGameServer()
        
        # 在后台线程中启动服务器
        server_thread = threading.Thread(target=server.start)
        server_thread.daemon = True
        server_thread.start()
        
        print("✅ 服务器启动成功！")
        
        # 启动控制台输入线程
        console_thread = threading.Thread(target=console_input_thread, args=(server,))
        console_thread.daemon = True
        console_thread.start()
        
        # 主循环：保持服务器运行
        while True:
            time.sleep(1)
            
    except KeyboardInterrupt:
        print("\n" + "=" * 60)
        print("⚠️  程序被用户中断")
        print("💾 正在保存数据并关闭服务器...")
        
        if 'server' in locals():
            try:
                # 保存所有在线玩家数据
                for client_id, user_info in server.user_data.items():
                    if user_info.get("logged_in", False):
                        username = user_info.get("username")
                        if username:
                            player_data = server.load_player_data(username)
                            if player_data:
                                server.save_player_data(username, player_data)
                print("💾 数据保存完成")
            except:
                pass
            server.stop()
            
        print("✅ 服务器已安全关闭")
        print("👋 感谢使用萌芽农场服务器！")
        print("=" * 60)
        sys.exit(0)
    
    except Exception as e:
        print(f"\n❌ 服务器启动失败: {str(e)}")
        print("🔧 请检查配置并重试")
        sys.exit(1)