3693 lines
153 KiB
Python
3693 lines
153 KiB
Python
from TCPServer import TCPServer
|
||
import time
|
||
import json
|
||
import os
|
||
import glob
|
||
import threading
|
||
import datetime
|
||
import re
|
||
|
||
"""
|
||
萌芽农场TCP游戏服务器 - 代码结构说明
|
||
====================================================================
|
||
|
||
📁 代码组织结构：
|
||
├── 1. 初始化和生命周期管理 - 服务器启动、停止、客户端管理
|
||
├── 2. 验证和检查方法 - 版本检查、登录状态验证
|
||
├── 3. 数据管理方法 - 玩家数据读写、缓存管理
|
||
├── 4. 作物系统管理 - 作物生长、更新推送
|
||
├── 5. 消息处理路由 - 客户端消息分发处理
|
||
├── 6. 用户认证处理 - 登录、注册、验证码
|
||
├── 7. 游戏操作处理 - 种植、收获、浇水等
|
||
├── 8. 系统功能处理 - 签到、抽奖、排行榜
|
||
└── 9. 性能优化功能 - 缓存优化、批量保存
|
||
|
||
🔧 性能优化特性：
|
||
- 内存缓存系统：减少磁盘I/O操作
|
||
- 分层更新策略：在线玩家快速更新，离线玩家慢速更新
|
||
- 批量数据保存：定时批量写入，提升性能
|
||
- 智能缓存管理：LRU策略，自动清理过期数据
|
||
|
||
🎮 游戏功能模块：
|
||
- 用户系统：注册、登录、邮箱验证
|
||
- 农场系统：种植、收获、浇水、施肥
|
||
- 升级系统：经验获取、等级提升
|
||
- 社交系统：访问农场、点赞互动
|
||
- 奖励系统：每日签到、幸运抽奖
|
||
- 排行系统：玩家排行榜展示
|
||
|
||
📊 数据存储：
|
||
- 玩家数据：JSON格式存储在game_saves目录
|
||
- 配置文件：作物数据、初始模板等
|
||
- 缓存策略：内存缓存 + 定时持久化
|
||
|
||
🌐 网络通信：
|
||
- 协议：TCP长连接
|
||
- 数据格式：JSON消息
|
||
- 消息类型：请求/响应模式
|
||
|
||
|
||
====================================================================
|
||
"""
|
||
|
||
# ============================================================================
|
||
# 服务器配置参数
|
||
# ============================================================================
|
||
server_host: str = "0.0.0.0"
|
||
server_port: int = 4040
|
||
buffer_size: int = 4096
|
||
server_version: str = "1.0.3" # 记录服务端版本
|
||
|
||
|
||
# ============================================================================
|
||
# TCP游戏服务器类
|
||
# ============================================================================
|
||
class TCPGameServer(TCPServer):
|
||
"""
|
||
萌芽农场TCP游戏服务器
|
||
"""
|
||
|
||
#==========================初始化和生命周期管理==========================
|
||
#初始化操作
|
||
def __init__(self, server_host=server_host, server_port=server_port, buffer_size=buffer_size):
|
||
"""初始化TCP游戏服务器"""
|
||
super().__init__(server_host, server_port, buffer_size)
|
||
|
||
# 基础数据存储
|
||
self.user_data = {} # 存储用户相关数据
|
||
self.crop_timer = None # 作物生长计时器
|
||
|
||
# 性能优化相关配置
|
||
self._init_performance_settings()
|
||
|
||
self.log('INFO', f"萌芽农场TCP游戏服务器初始化完成 - 版本: {server_version}", 'SERVER')
|
||
|
||
# 启动定时器
|
||
self.start_crop_growth_timer()
|
||
self.start_batch_save_timer()
|
||
|
||
#初始化性能操作
|
||
def _init_performance_settings(self):
|
||
"""初始化性能优化配置"""
|
||
self.player_cache = {} # 玩家数据内存缓存
|
||
self.dirty_players = set() # 需要保存到磁盘的玩家列表
|
||
self.last_save_time = time.time() # 上次批量保存时间
|
||
self.save_interval = 30 # 批量保存间隔（秒）
|
||
self.update_counter = 0 # 更新计数器
|
||
self.slow_update_interval = 10 # 慢速更新间隔（每10秒进行一次完整更新）
|
||
self.active_players_cache = {} # 活跃玩家缓存
|
||
self.cache_expire_time = 300 # 缓存过期时间（5分钟）
|
||
|
||
#启动作物生长计时器
|
||
def start_crop_growth_timer(self):
|
||
"""启动作物生长计时器，每秒更新一次"""
|
||
try:
|
||
self.update_crops_growth_optimized()
|
||
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_batch_save_timer(self):
|
||
"""启动批量保存计时器"""
|
||
try:
|
||
self.batch_save_dirty_players()
|
||
self.cleanup_expired_cache()
|
||
except Exception as e:
|
||
self.log('ERROR', f"批量保存时出错: {str(e)}", 'SERVER')
|
||
|
||
# 创建下一个批量保存计时器
|
||
batch_timer = threading.Timer(self.save_interval, self.start_batch_save_timer)
|
||
batch_timer.daemon = True
|
||
batch_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 {
|
||
"cached_players": len(self.player_cache),
|
||
"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')
|
||
|
||
# 强制保存所有缓存数据
|
||
self.log('INFO', "正在保存所有玩家数据...", 'SERVER')
|
||
saved_count = self.force_save_all_data()
|
||
self.log('INFO', f"已保存 {saved_count} 个玩家的数据", 'SERVER')
|
||
|
||
# 显示服务器统计信息
|
||
stats = self.get_server_stats()
|
||
self.log('INFO', f"服务器统计 - 缓存玩家: {stats['cached_players']}, 在线玩家: {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)
|
||
|
||
# 立即保存离线玩家的数据
|
||
if username and username in self.player_cache:
|
||
self.save_player_data_immediate(username)
|
||
self.dirty_players.discard(username)
|
||
self.log('INFO', f"已立即保存离线玩家 {username} 的数据", 'SERVER')
|
||
|
||
self.log('INFO', f"用户 {username} 登出", 'SERVER')
|
||
|
||
# 广播用户离开消息
|
||
self.broadcast({
|
||
"type": "user_left",
|
||
"user_id": client_id,
|
||
"timestamp": time.time(),
|
||
"remaining_users": len(self.clients) - 1
|
||
}, exclude=[client_id])
|
||
|
||
# 清理用户数据
|
||
if client_id in self.user_data:
|
||
del self.user_data[client_id]
|
||
|
||
self.log('INFO', f"用户 {username} 已离开游戏", 'SERVER')
|
||
|
||
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):
|
||
"""从缓存或文件加载玩家数据（优化版本）"""
|
||
# 先检查内存缓存
|
||
if account_id in self.player_cache:
|
||
self._update_cache_access_time(account_id)
|
||
return self.player_cache[account_id]
|
||
|
||
# 缓存未命中，从文件读取
|
||
return self._load_player_data_from_file(account_id)
|
||
|
||
#更新缓存访问时间
|
||
def _update_cache_access_time(self, account_id):
|
||
"""更新缓存访问时间"""
|
||
if account_id not in self.active_players_cache:
|
||
self.active_players_cache[account_id] = {}
|
||
self.active_players_cache[account_id]["last_access"] = time.time()
|
||
|
||
#从文件里加载玩家数据
|
||
def _load_player_data_from_file(self, account_id):
|
||
"""从文件加载玩家数据"""
|
||
file_path = os.path.join("game_saves", f"{account_id}.json")
|
||
|
||
try:
|
||
if os.path.exists(file_path):
|
||
with open(file_path, 'r', encoding='utf-8') as file:
|
||
player_data = json.load(file)
|
||
|
||
# 存入缓存
|
||
self.player_cache[account_id] = player_data
|
||
self.active_players_cache[account_id] = {
|
||
"last_access": time.time(),
|
||
"is_online": account_id in self.user_data and self.user_data[account_id].get("logged_in", False)
|
||
}
|
||
|
||
return player_data
|
||
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):
|
||
"""保存玩家数据到缓存"""
|
||
# 更新内存缓存
|
||
self.player_cache[account_id] = player_data
|
||
|
||
# 标记为脏数据，等待批量保存
|
||
self.dirty_players.add(account_id)
|
||
|
||
# 更新活跃缓存
|
||
self._update_cache_access_time(account_id)
|
||
|
||
return True
|
||
|
||
#保存玩家数据到磁盘
|
||
def save_player_data_immediate(self, account_id):
|
||
"""立即保存玩家数据到磁盘"""
|
||
if account_id not in self.player_cache:
|
||
return False
|
||
|
||
file_path = os.path.join("game_saves", f"{account_id}.json")
|
||
|
||
try:
|
||
with open(file_path, 'w', encoding='utf-8') as file:
|
||
json.dump(self.player_cache[account_id], file, indent=2, ensure_ascii=False)
|
||
return True
|
||
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 _load_crop_data(self):
|
||
"""加载作物配置数据"""
|
||
try:
|
||
with open("config/crop_data.json", 'r', encoding='utf-8') as file:
|
||
return json.load(file)
|
||
except Exception as e:
|
||
self.log('ERROR', f"无法加载作物数据: {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['total_login_time']}", 'SERVER')
|
||
|
||
#更新总游玩时间
|
||
def _update_total_play_time(self, player_data, play_time_seconds):
|
||
"""更新总游玩时间"""
|
||
total_time_str = player_data.get("total_login_time", "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["total_login_time"] = f"{new_hours}时{new_minutes}分{new_seconds}秒"
|
||
|
||
#==========================作物系统管理==========================
|
||
#优化的作物生长更新系统
|
||
def update_crops_growth_optimized(self):
|
||
"""优化的作物生长更新系统"""
|
||
self.update_counter += 1
|
||
|
||
# 每秒快速更新在线玩家
|
||
self.update_online_players_crops()
|
||
|
||
# 每10秒进行一次慢速更新（离线玩家和深度检查）
|
||
if self.update_counter % self.slow_update_interval == 0:
|
||
self.update_offline_players_crops()
|
||
|
||
#快速更新在线玩家的作物
|
||
def update_online_players_crops(self):
|
||
"""快速更新在线玩家的作物"""
|
||
for client_id, user_info in self.user_data.items():
|
||
if not user_info.get("logged_in", False):
|
||
continue
|
||
|
||
username = user_info.get("username")
|
||
if not username:
|
||
continue
|
||
|
||
try:
|
||
player_data = self.load_player_data(username)
|
||
if not player_data:
|
||
continue
|
||
|
||
if self.update_player_crops_fast(player_data, username):
|
||
self.save_player_data(username, player_data)
|
||
self._push_crop_update_to_player(username, player_data)
|
||
|
||
except Exception as e:
|
||
self.log('ERROR', f"快速更新在线玩家 {username} 作物时出错: {str(e)}", 'SERVER')
|
||
|
||
#慢速更新离线玩家的作物
|
||
def update_offline_players_crops(self):
|
||
"""慢速更新离线玩家的作物（每10秒一次）"""
|
||
import glob
|
||
|
||
try:
|
||
save_files = glob.glob(os.path.join("game_saves", "*.json"))
|
||
offline_count = 0
|
||
updated_count = 0
|
||
|
||
for save_file in save_files:
|
||
account_id = os.path.basename(save_file).split('.')[0]
|
||
|
||
# 跳过在线玩家
|
||
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 is_online:
|
||
continue
|
||
|
||
offline_count += 1
|
||
|
||
player_data = self.load_player_data(account_id)
|
||
if not player_data:
|
||
continue
|
||
|
||
if self.update_player_crops_slow(player_data, account_id):
|
||
self.save_player_data(account_id, player_data)
|
||
updated_count += 1
|
||
|
||
if updated_count > 0:
|
||
self.log('INFO', f"慢速更新：检查了 {offline_count} 个离线玩家，更新了 {updated_count} 个", 'SERVER')
|
||
|
||
except Exception as e:
|
||
self.log('ERROR', f"慢速更新离线玩家作物时出错: {str(e)}", 'SERVER')
|
||
|
||
#快速更新单个玩家的作物
|
||
def update_player_crops_fast(self, player_data, account_id):
|
||
"""快速更新单个玩家的作物（在线玩家用）"""
|
||
return self.update_player_crops_common(player_data, account_id, 1)
|
||
|
||
#慢速更新单个玩家的作物
|
||
def update_player_crops_slow(self, player_data, account_id):
|
||
"""慢速更新单个玩家的作物（离线玩家用，补偿倍数）"""
|
||
return self.update_player_crops_common(player_data, account_id, self.slow_update_interval)
|
||
|
||
#通用的作物更新逻辑
|
||
def update_player_crops_common(self, player_data, account_id, time_multiplier):
|
||
"""通用的作物更新逻辑"""
|
||
growth_updated = False
|
||
|
||
for farm_lot in player_data.get("farm_lots", []):
|
||
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_multiplier = 1.0
|
||
|
||
# 土地等级影响 - 根据不同等级应用不同倍数
|
||
land_level = farm_lot.get("土地等级", 0)
|
||
land_speed_multipliers = {
|
||
0: 1.0, # 默认土地：正常生长速度
|
||
1: 2.0, # 黄土地：2倍速
|
||
2: 4.0, # 红土地：4倍速
|
||
3: 6.0, # 紫土地：6倍速
|
||
4: 10.0 # 黑土地：10倍速
|
||
}
|
||
growth_multiplier *= land_speed_multipliers.get(land_level, 1.0)
|
||
|
||
# 施肥影响
|
||
if farm_lot.get("已施肥", False) and "施肥时间" in farm_lot:
|
||
fertilize_time = farm_lot.get("施肥时间", 0)
|
||
current_time = time.time()
|
||
if current_time - fertilize_time <= 600: # 10分钟内
|
||
growth_multiplier *= 2.0
|
||
else:
|
||
# 施肥效果过期
|
||
farm_lot["已施肥"] = False
|
||
if "施肥时间" in farm_lot:
|
||
del farm_lot["施肥时间"]
|
||
|
||
# 应用生长速度倍数和时间补偿
|
||
growth_increase = int(growth_multiplier * time_multiplier)
|
||
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)
|
||
|
||
#根据用户名查找客户端ID
|
||
def _find_client_by_username(self, username):
|
||
"""根据用户名查找客户端ID"""
|
||
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",
|
||
"farm_lots": target_player_data.get("farm_lots", []),
|
||
"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",
|
||
"farm_lots": player_data.get("farm_lots", []),
|
||
"timestamp": time.time(),
|
||
"is_visiting": False
|
||
}
|
||
self.send_data(client_id, update_message)
|
||
|
||
|
||
|
||
|
||
|
||
|
||
# =======================服务端与客户端通信注册==========================================
|
||
#服务端与客户端通用消息处理-这个是服务端与客户端通信的核心中的核心
|
||
def _handle_message(self, client_id, message):
|
||
"""接收客户端消息并路由到对应处理函数"""
|
||
message_type = message.get("type", "")
|
||
|
||
# 用户认证相关
|
||
if message_type == "greeting":#默认欢迎
|
||
return self._handle_greeting(client_id, message)
|
||
elif message_type == "login":#玩家登录
|
||
return self._handle_login(client_id, message)
|
||
elif message_type == "register":#玩家注册
|
||
return self._handle_register(client_id, message)
|
||
elif message_type == "request_verification_code":#验证码请求
|
||
return self._handle_verification_code_request(client_id, message)
|
||
elif message_type == "verify_code":#验证码
|
||
return self._handle_verify_code(client_id, message)
|
||
|
||
#---------------------------------------------------------------------------
|
||
# 游戏操作相关
|
||
elif message_type == "harvest_crop":#收获作物
|
||
return self._handle_harvest_crop(client_id, message)
|
||
elif message_type == "plant_crop":#种植作物
|
||
return self._handle_plant_crop(client_id, message)
|
||
elif message_type == "buy_seed":#购买种子
|
||
return self._handle_buy_seed(client_id, message)
|
||
elif message_type == "dig_ground":#开垦土地
|
||
return self._handle_dig_ground(client_id, message)
|
||
elif message_type == "remove_crop":#铲除作物
|
||
return self._handle_remove_crop(client_id, message)
|
||
elif message_type == "water_crop":#浇水
|
||
return self._handle_water_crop(client_id, message)
|
||
elif message_type == "fertilize_crop":#施肥
|
||
return self._handle_fertilize_crop(client_id, message)
|
||
elif message_type == "upgrade_land":#升级土地
|
||
return self._handle_upgrade_land(client_id, message)
|
||
elif message_type == "buy_new_ground":#添加新的土地
|
||
return self._handle_buy_new_ground(client_id, message)
|
||
elif message_type == "like_player":#点赞玩家
|
||
return self._handle_like_player(client_id, message)
|
||
elif message_type == "request_online_players":#请求在线玩家
|
||
return self._handle_online_players_request(client_id, message)
|
||
elif message_type == "get_play_time":#获取游玩时间
|
||
return self._handle_get_play_time(client_id)
|
||
elif message_type == "update_play_time":#更新游玩时间
|
||
return self._handle_update_play_time(client_id)
|
||
elif message_type == "request_player_rankings":#请求玩家排行榜
|
||
return self._handle_player_rankings_request(client_id)
|
||
elif message_type == "request_crop_data":#请求作物数据
|
||
return self._handle_crop_data_request(client_id)
|
||
elif message_type == "visit_player":#拜访其他玩家农场
|
||
return self._handle_visit_player_request(client_id, message)
|
||
elif message_type == "return_my_farm":#返回我的农场
|
||
return self._handle_return_my_farm_request(client_id, message)
|
||
elif message_type == "daily_check_in":#每日签到
|
||
return self._handle_daily_check_in_request(client_id, message)
|
||
elif message_type == "get_check_in_data":#获取签到数据
|
||
return self._handle_get_check_in_data_request(client_id, message)
|
||
elif message_type == "lucky_draw":#幸运抽奖
|
||
return self._handle_lucky_draw_request(client_id, message)
|
||
elif message_type == "claim_new_player_gift":#领取新手大礼包
|
||
return self._handle_new_player_gift_request(client_id, message)
|
||
elif message_type == "ping":#客户端ping请求
|
||
return self._handle_ping_request(client_id, message)
|
||
#---------------------------------------------------------------------------
|
||
|
||
elif message_type == "message":#处理聊天消息（暂未实现）
|
||
return self._handle_chat_message(client_id, message)
|
||
else:
|
||
return super()._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("user_password") == password:
|
||
# 登录成功
|
||
self.log('INFO', f"用户 {username} 登录成功", 'SERVER')
|
||
|
||
# 更新最后登录时间
|
||
current_time = datetime.datetime.now()
|
||
player_data["last_login_time"] = current_time.strftime("%Y年%m月%d日%H时%M分%S秒")
|
||
|
||
# 检查并更新体力值
|
||
stamina_updated = self._check_and_update_stamina(player_data)
|
||
if stamina_updated:
|
||
self.log('INFO', f"玩家 {username} 体力值已更新：{player_data.get('体力值', 20)}", 'SERVER')
|
||
|
||
# 保存用户会话信息
|
||
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 = {
|
||
"type": "login_response",
|
||
"status": "success",
|
||
"message": "登录成功",
|
||
"player_data": player_data
|
||
}
|
||
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("farm_lots", [])
|
||
initial_crop_update = {
|
||
"type": "crop_update",
|
||
"farm_lots": 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')
|
||
|
||
|
||
#处理注册消息
|
||
def _handle_register(self, client_id, message):
|
||
"""处理注册消息"""
|
||
username = message.get("username", "")
|
||
password = message.get("password", "")
|
||
farm_name = message.get("farm_name", "")
|
||
player_name = message.get("player_name", "")
|
||
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:
|
||
from QQEmailSend import EmailVerification
|
||
success, verify_message = EmailVerification.verify_code(username, verification_code)
|
||
if not success:
|
||
return self._send_register_error(client_id, f"验证码错误: {verify_message}")
|
||
|
||
# 检查用户是否已存在
|
||
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):
|
||
"""创建新用户"""
|
||
try:
|
||
# 从模板加载初始玩家数据
|
||
template_path = os.path.join("config", "initial_player_data_template.json")
|
||
if not os.path.exists(template_path):
|
||
return self._send_register_error(client_id, "服务器配置错误，无法注册新用户")
|
||
|
||
with open(template_path, 'r', encoding='utf-8') as file:
|
||
player_data = json.load(file)
|
||
|
||
# 更新玩家数据
|
||
player_data.update({
|
||
"user_name": username,
|
||
"user_password": password,
|
||
"farm_name": farm_name or "我的农场",
|
||
"player_name": player_name or username,
|
||
"experience": player_data.get("experience", 0),
|
||
"level": player_data.get("level", 1),
|
||
"money": player_data.get("money", 1000)
|
||
})
|
||
|
||
# 确保农场地块存在
|
||
if "farm_lots" not in player_data:
|
||
player_data["farm_lots"] = []
|
||
for i in range(40):
|
||
player_data["farm_lots"].append({
|
||
"crop_type": "",
|
||
"grow_time": 0,
|
||
"is_dead": False,
|
||
"is_diged": i < 5, # 默认开垦前5块地
|
||
"is_planted": False,
|
||
"max_grow_time": 5 if i >= 5 else 3
|
||
})
|
||
|
||
if "player_bag" not in player_data:
|
||
player_data["player_bag"] = []
|
||
|
||
# 更新注册时间和登录时间
|
||
current_time = datetime.datetime.now()
|
||
time_str = current_time.strftime("%Y年%m月%d日%H时%M分%S秒")
|
||
player_data["last_login_time"] = time_str
|
||
|
||
if "total_login_time" not in player_data:
|
||
player_data["total_login_time"] = "0时0分0秒"
|
||
|
||
# 保存新用户数据
|
||
file_path = os.path.join("game_saves", f"{username}.json")
|
||
with open(file_path, 'w', encoding='utf-8') as file:
|
||
json.dump(player_data, file, indent=2, ensure_ascii=False)
|
||
|
||
self.log('INFO', f"用户 {username} 注册成功", 'SERVER')
|
||
|
||
# 返回成功响应
|
||
return self.send_data(client_id, {
|
||
"type": "register_response",
|
||
"status": "success",
|
||
"message": "注册成功，请登录游戏"
|
||
})
|
||
|
||
except Exception as e:
|
||
self.log('ERROR', f"注册用户 {username} 时出错: {str(e)}", 'SERVER')
|
||
return self._send_register_error(client_id, f"注册过程中出现错误: {str(e)}")
|
||
|
||
#辅助函数-客户端版本检查
|
||
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):
|
||
"""处理验证码请求"""
|
||
from QQEmailSend import EmailVerification
|
||
|
||
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)
|
||
self.log('INFO', f"已向QQ号 {qq_number} 发送验证码", '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):
|
||
"""处理验证码验证"""
|
||
from QQEmailSend import EmailVerification
|
||
|
||
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号格式
|
||
|
||
#辅助函数-验证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", "")
|
||
|
||
# 确定操作目标：如果有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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "harvest_crop", "无效的地块索引")
|
||
|
||
target_lot = target_player_data["farm_lots"][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": {
|
||
"money": current_player_data["money"],
|
||
"experience": current_player_data["experience"],
|
||
"level": current_player_data["level"]
|
||
}
|
||
})
|
||
|
||
if target_lot["grow_time"] < target_lot["max_grow_time"]:
|
||
return self._send_action_error(client_id, "harvest_crop", "作物尚未成熟，无法偷菜")
|
||
|
||
# 处理偷菜
|
||
return self._process_steal_crop(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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "harvest_crop", "无效的地块索引")
|
||
|
||
lot = current_player_data["farm_lots"][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": {
|
||
"money": current_player_data["money"],
|
||
"experience": current_player_data["experience"],
|
||
"level": current_player_data["level"]
|
||
}
|
||
})
|
||
|
||
if lot["grow_time"] < lot["max_grow_time"]:
|
||
return self._send_action_error(client_id, "harvest_crop", "作物尚未成熟")
|
||
|
||
# 处理正常收获
|
||
return self._process_harvest(client_id, current_player_data, current_username, lot, lot_index)
|
||
|
||
#辅助函数-处理作物收获
|
||
def _process_harvest(self, client_id, player_data, username, lot, lot_index):
|
||
"""处理作物收获逻辑"""
|
||
# 读取作物配置
|
||
crop_data = self._load_crop_data()
|
||
|
||
# 获取作物收益和经验
|
||
crop_type = lot["crop_type"]
|
||
if crop_type in crop_data:
|
||
crop_income = crop_data[crop_type].get("收益", 100) + crop_data[crop_type].get("花费", 0)
|
||
crop_exp = crop_data[crop_type].get("经验", 10)
|
||
else:
|
||
# 默认收益
|
||
crop_income = 100
|
||
crop_exp = 10
|
||
|
||
# 更新玩家数据
|
||
player_data["money"] += crop_income
|
||
player_data["experience"] += crop_exp
|
||
|
||
# 检查升级
|
||
level_up_experience = 100 * player_data["level"]
|
||
if player_data["experience"] >= level_up_experience:
|
||
player_data["level"] += 1
|
||
player_data["experience"] -= level_up_experience
|
||
self.log('INFO', f"玩家 {username} 升级到 {player_data['level']} 级", 'SERVER')
|
||
|
||
# 清理地块
|
||
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)
|
||
|
||
self.log('INFO', f"玩家 {username} 从地块 {lot_index} 收获了作物，获得 {crop_income} 金钱和 {crop_exp} 经验", 'SERVER')
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "action_response",
|
||
"action_type": "harvest_crop",
|
||
"success": True,
|
||
"message": f"收获成功，获得 {crop_income} 金钱和 {crop_exp} 经验",
|
||
"updated_data": {
|
||
"money": player_data["money"],
|
||
"experience": player_data["experience"],
|
||
"level": player_data["level"]
|
||
}
|
||
})
|
||
|
||
#辅助函数-处理偷菜逻辑（访问模式下收获其他玩家作物的操作）
|
||
def _process_steal_crop(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index):
|
||
"""处理偷菜逻辑（收益给当前玩家，清空目标玩家的作物）"""
|
||
# 偷菜体力值消耗
|
||
stamina_cost = 2
|
||
|
||
# 检查并更新当前玩家的体力值
|
||
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)}")
|
||
|
||
# 读取作物配置
|
||
crop_data = self._load_crop_data()
|
||
|
||
# 获取作物收益和经验（偷菜获得的收益稍微少一些，比如80%）
|
||
crop_type = target_lot["crop_type"]
|
||
if crop_type in crop_data:
|
||
crop_income = int((crop_data[crop_type].get("收益", 100) + crop_data[crop_type].get("花费", 0)) * 0.8) # 偷菜获得80%收益
|
||
crop_exp = int(crop_data[crop_type].get("经验", 10) * 0.5) # 偷菜获得50%经验
|
||
else:
|
||
# 默认收益
|
||
crop_income = 80
|
||
crop_exp = 5
|
||
|
||
# 消耗当前玩家的体力值
|
||
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["money"] += crop_income
|
||
current_player_data["experience"] += crop_exp
|
||
|
||
# 检查当前玩家升级
|
||
level_up_experience = 100 * current_player_data["level"]
|
||
if current_player_data["experience"] >= level_up_experience:
|
||
current_player_data["level"] += 1
|
||
current_player_data["experience"] -= level_up_experience
|
||
self.log('INFO', f"玩家 {current_username} 升级到 {current_player_data['level']} 级", 'SERVER')
|
||
|
||
# 清理目标玩家的地块
|
||
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)
|
||
|
||
self.log('INFO', f"玩家 {current_username} 偷了玩家 {target_username} 地块 {lot_index} 的作物，获得 {crop_income} 金钱和 {crop_exp} 经验", 'SERVER')
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "action_response",
|
||
"action_type": "harvest_crop",
|
||
"success": True,
|
||
"message": f"偷菜成功！从 {target_username} 那里获得 {crop_income} 金钱和 {crop_exp} 经验，{stamina_message}",
|
||
"updated_data": {
|
||
"money": current_player_data["money"],
|
||
"experience": current_player_data["experience"],
|
||
"level": current_player_data["level"],
|
||
"体力值": current_player_data["体力值"]
|
||
}
|
||
})
|
||
#==========================收获作物处理==========================
|
||
|
||
|
||
|
||
|
||
#==========================种植作物处理==========================
|
||
#处理种植作物请求
|
||
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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "plant_crop", "无效的地块索引")
|
||
|
||
lot = player_data["farm_lots"][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("player_bag", [])):
|
||
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["player_bag"][seed_index]["count"] -= 1
|
||
|
||
# 如果种子用完，从背包中移除
|
||
if player_data["player_bag"][seed_index]["count"] <= 0:
|
||
player_data["player_bag"].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_bag": player_data["player_bag"]
|
||
}
|
||
})
|
||
#==========================种植作物处理==========================
|
||
|
||
|
||
|
||
|
||
#==========================购买种子处理==========================
|
||
#处理购买种子请求
|
||
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", "")
|
||
|
||
# 加载作物配置
|
||
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])
|
||
|
||
#处理种子购买逻辑
|
||
def _process_seed_purchase(self, client_id, player_data, username, crop_name, crop):
|
||
"""处理种子购买逻辑"""
|
||
# 检查玩家等级
|
||
if player_data["level"] < crop.get("等级", 1):
|
||
return self._send_action_error(client_id, "buy_seed", "等级不足，无法购买此种子")
|
||
|
||
# 检查玩家金钱
|
||
if player_data["money"] < crop.get("花费", 0):
|
||
return self._send_action_error(client_id, "buy_seed", "金钱不足，无法购买此种子")
|
||
|
||
# 扣除金钱
|
||
player_data["money"] -= crop.get("花费", 0)
|
||
|
||
# 将种子添加到背包
|
||
seed_found = False
|
||
|
||
for item in player_data.get("player_bag", []):
|
||
if item.get("name") == crop_name:
|
||
item["count"] += 1
|
||
seed_found = True
|
||
break
|
||
|
||
if not seed_found:
|
||
if "player_bag" not in player_data:
|
||
player_data["player_bag"] = []
|
||
|
||
player_data["player_bag"].append({
|
||
"name": crop_name,
|
||
"quality": crop.get("品质", "普通"),
|
||
"count": 1
|
||
})
|
||
|
||
# 保存玩家数据
|
||
self.save_player_data(username, player_data)
|
||
|
||
self.log('INFO', f"玩家 {username} 购买了种子 {crop_name}", 'SERVER')
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "action_response",
|
||
"action_type": "buy_seed",
|
||
"success": True,
|
||
"message": f"成功购买 {crop_name} 种子",
|
||
"updated_data": {
|
||
"money": player_data["money"],
|
||
"player_bag": player_data["player_bag"]
|
||
}
|
||
})
|
||
|
||
#==========================购买种子处理==========================
|
||
|
||
|
||
|
||
|
||
#==========================开垦土地处理==========================
|
||
#处理开垦土地请求
|
||
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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "dig_ground", "无效的地块索引")
|
||
|
||
lot = player_data["farm_lots"][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["farm_lots"] if l.get("is_diged", False))
|
||
dig_money = digged_count * 1000
|
||
|
||
# 检查玩家金钱是否足够
|
||
if player_data["money"] < dig_money:
|
||
return self._send_action_error(client_id, "dig_ground", f"金钱不足，开垦此地块需要 {dig_money} 金钱")
|
||
|
||
# 执行开垦操作
|
||
player_data["money"] -= dig_money
|
||
lot["is_diged"] = True
|
||
|
||
# 保存玩家数据
|
||
self.save_player_data(username, player_data)
|
||
|
||
# 发送作物更新
|
||
self._push_crop_update_to_player(username, player_data)
|
||
|
||
self.log('INFO', f"玩家 {username} 成功开垦地块 {lot_index}，花费 {dig_money} 金钱", 'SERVER')
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "action_response",
|
||
"action_type": "dig_ground",
|
||
"success": True,
|
||
"message": f"成功开垦地块，花费 {dig_money} 金钱",
|
||
"updated_data": {
|
||
"money": player_data["money"],
|
||
"farm_lots": player_data["farm_lots"]
|
||
}
|
||
})
|
||
|
||
#==========================开垦土地处理==========================
|
||
|
||
|
||
|
||
|
||
#==========================铲除作物处理==========================
|
||
#处理铲除作物请求
|
||
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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "remove_crop", "无效的地块索引")
|
||
|
||
lot = player_data["farm_lots"][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["money"] < removal_cost:
|
||
return self._send_action_error(client_id, "remove_crop", f"金钱不足，铲除作物需要 {removal_cost} 金钱")
|
||
|
||
# 获取作物名称用于日志
|
||
crop_type = lot.get("crop_type", "未知作物")
|
||
|
||
# 执行铲除操作
|
||
player_data["money"] -= 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": {
|
||
"money": player_data["money"],
|
||
"farm_lots": player_data["farm_lots"]
|
||
}
|
||
})
|
||
|
||
#==========================铲除作物处理==========================
|
||
|
||
|
||
|
||
|
||
#==========================浇水作物处理==========================
|
||
#处理浇水请求
|
||
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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "water_crop", "无效的地块索引")
|
||
|
||
target_lot = target_player_data["farm_lots"][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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "water_crop", "无效的地块索引")
|
||
|
||
lot = current_player_data["farm_lots"][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
|
||
stamina_cost = 1
|
||
|
||
# 检查并更新体力值
|
||
self._check_and_update_stamina(player_data)
|
||
|
||
# 检查体力值是否足够
|
||
if not self._check_stamina_sufficient(player_data, stamina_cost):
|
||
return self._send_action_error(client_id, "water_crop", f"体力值不足，浇水需要 {stamina_cost} 点体力，当前体力：{player_data.get('体力值', 0)}")
|
||
|
||
# 检查玩家金钱是否足够
|
||
if player_data["money"] < 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["money"] -= water_cost
|
||
|
||
# 消耗体力值
|
||
stamina_success, stamina_message = self._consume_stamina(player_data, stamina_cost, "浇水")
|
||
if not stamina_success:
|
||
return self._send_action_error(client_id, "water_crop", stamina_message)
|
||
|
||
# 计算浇水效果：增加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} 金钱，生长进度: {progress:.1f}%", 'SERVER')
|
||
|
||
message = f"浇水成功！{crop_type} 生长了 {growth_increase} 秒，当前进度: {progress:.1f}%，{stamina_message}"
|
||
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": {
|
||
"money": player_data["money"],
|
||
"体力值": player_data["体力值"],
|
||
"farm_lots": player_data["farm_lots"]
|
||
}
|
||
})
|
||
|
||
#处理访问模式浇水逻辑
|
||
def _process_visiting_watering(self, client_id, current_player_data, current_username, target_player_data, target_username, target_lot, lot_index):
|
||
"""处理访问模式浇水逻辑（花自己的钱，效果作用在目标玩家作物上）"""
|
||
# 浇水费用和体力值消耗
|
||
water_cost = 50
|
||
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, "water_crop", f"体力值不足，帮助浇水需要 {stamina_cost} 点体力，当前体力：{current_player_data.get('体力值', 0)}")
|
||
|
||
# 检查当前玩家金钱是否足够
|
||
if current_player_data["money"] < 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["money"] -= water_cost
|
||
|
||
# 消耗当前玩家的体力值
|
||
stamina_success, stamina_message = self._consume_stamina(current_player_data, stamina_cost, "帮助浇水")
|
||
if not stamina_success:
|
||
return self._send_action_error(client_id, "water_crop", stamina_message)
|
||
|
||
# 计算浇水效果：增加目标作物的生长进度
|
||
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} 金钱，生长进度: {progress:.1f}%", 'SERVER')
|
||
|
||
message = f"帮助浇水成功！{target_username} 的 {crop_type} 生长了 {growth_increase} 秒，当前进度: {progress:.1f}%，{stamina_message}"
|
||
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": {
|
||
"money": current_player_data["money"],
|
||
"体力值": 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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "fertilize_crop", "无效的地块索引")
|
||
|
||
target_lot = target_player_data["farm_lots"][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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "fertilize_crop", "无效的地块索引")
|
||
|
||
lot = current_player_data["farm_lots"][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
|
||
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, "fertilize_crop", f"体力值不足，帮助施肥需要 {stamina_cost} 点体力，当前体力：{current_player_data.get('体力值', 0)}")
|
||
|
||
# 检查当前玩家金钱是否足够
|
||
if current_player_data["money"] < 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["money"] -= fertilize_cost
|
||
|
||
# 消耗当前玩家的体力值
|
||
stamina_success, stamina_message = self._consume_stamina(current_player_data, stamina_cost, "帮助施肥")
|
||
if not stamina_success:
|
||
return self._send_action_error(client_id, "fertilize_crop", stamina_message)
|
||
|
||
# 标记目标作物已施肥，施肥效果会在作物生长更新时生效
|
||
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} 金钱", 'SERVER')
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "action_response",
|
||
"action_type": "fertilize_crop",
|
||
"success": True,
|
||
"message": f"帮助施肥成功！{target_username} 的 {crop_type} 将在10分钟内以双倍速度生长，{stamina_message}",
|
||
"updated_data": {
|
||
"money": current_player_data["money"],
|
||
"体力值": current_player_data["体力值"]
|
||
}
|
||
})
|
||
|
||
#辅助函数-处理施肥逻辑
|
||
def _process_fertilizing(self, client_id, player_data, username, lot, lot_index):
|
||
"""处理施肥逻辑"""
|
||
# 施肥费用和体力值消耗
|
||
fertilize_cost = 150
|
||
stamina_cost = 1
|
||
|
||
# 检查并更新体力值
|
||
self._check_and_update_stamina(player_data)
|
||
|
||
# 检查体力值是否足够
|
||
if not self._check_stamina_sufficient(player_data, stamina_cost):
|
||
return self._send_action_error(client_id, "fertilize_crop", f"体力值不足，施肥需要 {stamina_cost} 点体力，当前体力：{player_data.get('体力值', 0)}")
|
||
|
||
# 检查玩家金钱是否足够
|
||
if player_data["money"] < 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["money"] -= fertilize_cost
|
||
|
||
# 消耗体力值
|
||
stamina_success, stamina_message = self._consume_stamina(player_data, stamina_cost, "施肥")
|
||
if not stamina_success:
|
||
return self._send_action_error(client_id, "fertilize_crop", stamina_message)
|
||
|
||
# 标记已施肥，施肥效果会在作物生长更新时生效
|
||
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} 金钱", 'SERVER')
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "action_response",
|
||
"action_type": "fertilize_crop",
|
||
"success": True,
|
||
"message": f"施肥成功！{crop_type} 将在10分钟内以双倍速度生长，{stamina_message}",
|
||
"updated_data": {
|
||
"money": player_data["money"],
|
||
"体力值": player_data["体力值"],
|
||
"farm_lots": player_data["farm_lots"]
|
||
}
|
||
})
|
||
|
||
#==========================施肥作物处理==========================
|
||
|
||
|
||
|
||
|
||
#==========================升级土地处理==========================
|
||
#处理升级土地请求
|
||
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("farm_lots", [])):
|
||
return self._send_action_error(client_id, "upgrade_land", "无效的地块索引")
|
||
|
||
lot = player_data["farm_lots"][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["money"] < upgrade_cost:
|
||
return self._send_action_error(client_id, "upgrade_land", f"金钱不足，升级到{next_name}需要 {upgrade_cost} 金钱")
|
||
|
||
# 执行升级操作
|
||
player_data["money"] -= 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": {
|
||
"money": player_data["money"],
|
||
"farm_lots": player_data["farm_lots"]
|
||
}
|
||
})
|
||
#==========================升级土地处理==========================
|
||
|
||
|
||
|
||
#==========================购买新地块处理==========================
|
||
#处理购买新地块请求
|
||
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["money"] < 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("farm_lots", []))
|
||
if current_lots >= max_lots:
|
||
return self._send_action_error(client_id, "buy_new_ground", f"已达到最大地块数量限制（{max_lots}个）")
|
||
|
||
# 执行购买操作
|
||
player_data["money"] -= 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 "farm_lots" not in player_data:
|
||
player_data["farm_lots"] = []
|
||
player_data["farm_lots"].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["farm_lots"])
|
||
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": {
|
||
"money": player_data["money"],
|
||
"farm_lots": player_data["farm_lots"]
|
||
}
|
||
})
|
||
|
||
#==========================购买新地块处理==========================
|
||
|
||
|
||
|
||
#==========================点赞玩家处理==========================
|
||
#处理玩家点赞请求
|
||
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": "不能给自己点赞"
|
||
})
|
||
|
||
# 检查今天是否已经给这个玩家点过赞
|
||
current_date = datetime.datetime.now().strftime("%Y-%m-%d")
|
||
|
||
# 初始化点赞记录
|
||
if "daily_likes" not in player_data:
|
||
player_data["daily_likes"] = {}
|
||
|
||
# 检查今天的点赞记录
|
||
if current_date not in player_data["daily_likes"]:
|
||
player_data["daily_likes"][current_date] = []
|
||
|
||
if target_username in player_data["daily_likes"][current_date]:
|
||
return self.send_data(client_id, {
|
||
"type": "like_player_response",
|
||
"success": False,
|
||
"message": f"今天已经给 {target_username} 点过赞了"
|
||
})
|
||
|
||
# 加载目标玩家数据
|
||
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["daily_likes"][current_date].append(target_username)
|
||
|
||
# 更新目标玩家的点赞数量
|
||
target_player_data["total_likes"] = target_player_data.get("total_likes", 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['total_likes']}", 'SERVER')
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "like_player_response",
|
||
"success": True,
|
||
"message": f"成功点赞玩家 {target_username}！",
|
||
"target_likes": target_player_data["total_likes"]
|
||
})
|
||
|
||
#==========================点赞玩家处理==========================
|
||
|
||
|
||
|
||
#==========================在线玩家处理==========================
|
||
#处理请求在线玩家请求
|
||
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")
|
||
|
||
# 初始化体力值相关字段
|
||
if "体力值" not in player_data:
|
||
player_data["体力值"] = 20
|
||
if "体力上次刷新时间" not in player_data:
|
||
player_data["体力上次刷新时间"] = current_date
|
||
if "体力上次恢复时间" not in player_data:
|
||
player_data["体力上次恢复时间"] = current_time
|
||
|
||
# 检查是否需要每日重置
|
||
last_refresh_date = player_data.get("体力上次刷新时间", "")
|
||
if last_refresh_date != current_date:
|
||
# 新的一天，重置体力值
|
||
player_data["体力值"] = 20
|
||
player_data["体力上次刷新时间"] = current_date
|
||
player_data["体力上次恢复时间"] = current_time
|
||
return True # 发生了重置
|
||
|
||
# 检查每小时恢复
|
||
last_recovery_time = player_data.get("体力上次恢复时间", current_time)
|
||
time_diff = current_time - last_recovery_time
|
||
|
||
# 如果超过1小时（3600秒），恢复体力值
|
||
if time_diff >= 3600:
|
||
hours_passed = int(time_diff // 3600)
|
||
current_stamina = player_data.get("体力值", 0)
|
||
|
||
# 体力值恢复，但不能超过20
|
||
new_stamina = min(20, current_stamina + hours_passed)
|
||
if new_stamina > current_stamina:
|
||
player_data["体力值"] = new_stamina
|
||
player_data["体力上次恢复时间"] = current_time
|
||
return True # 发生了恢复
|
||
|
||
return False # 没有变化
|
||
|
||
#消耗体力值
|
||
def _consume_stamina(self, player_data, amount, action_name):
|
||
"""消耗体力值"""
|
||
current_stamina = player_data.get("体力值", 20)
|
||
|
||
if current_stamina < amount:
|
||
return False, f"体力值不足！{action_name}需要 {amount} 点体力，当前体力：{current_stamina}"
|
||
|
||
player_data["体力值"] = current_stamina - amount
|
||
return True, f"消耗 {amount} 点体力，剩余体力：{player_data['体力值']}"
|
||
|
||
#检查体力值是否足够
|
||
def _check_stamina_sufficient(self, player_data, amount):
|
||
"""检查体力值是否足够"""
|
||
current_stamina = player_data.get("体力值", 20)
|
||
return current_stamina >= amount
|
||
|
||
#==========================玩家体力值处理==========================
|
||
|
||
|
||
|
||
#==========================玩家游玩时间处理==========================
|
||
#处理获取玩家游玩时间请求
|
||
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("last_login_time", "未知")
|
||
total_login_time = player_data.get("total_login_time", "0时0分0秒")
|
||
|
||
self.log('INFO', f"玩家 {username} 请求游玩时间统计", 'SERVER')
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "play_time_response",
|
||
"success": True,
|
||
"last_login_time": last_login_time,
|
||
"total_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("total_login_time", "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["total_login_time"] = 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['total_login_time']}", 'SERVER')
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "update_time_response",
|
||
"success": True,
|
||
"message": "游玩时间已更新",
|
||
"total_login_time": player_data["total_login_time"]
|
||
})
|
||
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):
|
||
"""处理获取玩家排行榜的请求"""
|
||
# 检查用户是否已登录
|
||
logged_in, response = self._check_user_logged_in(client_id, "获取玩家排行榜", "player_rankings")
|
||
if not logged_in:
|
||
return self.send_data(client_id, response)
|
||
|
||
# 获取所有玩家存档文件
|
||
save_files = glob.glob(os.path.join("game_saves", "*.json"))
|
||
players_data = []
|
||
|
||
# 统计注册总人数
|
||
total_registered_players = len(save_files)
|
||
|
||
for save_file in save_files:
|
||
try:
|
||
# 从文件名提取账号ID
|
||
account_id = os.path.basename(save_file).split('.')[0]
|
||
|
||
# 加载玩家数据
|
||
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("player_bag", []))
|
||
|
||
# 检查玩家是否在线
|
||
is_online = any(
|
||
user_info.get("username") == account_id and user_info.get("logged_in", False)
|
||
for user_info in self.user_data.values()
|
||
)
|
||
|
||
# 获取所需的玩家信息
|
||
player_info = {
|
||
"user_name": player_data.get("user_name", account_id),
|
||
"player_name": player_data.get("player_name", player_data.get("user_name", account_id)),
|
||
"farm_name": player_data.get("farm_name", ""),
|
||
"level": player_data.get("level", 1),
|
||
"money": player_data.get("money", 0),
|
||
"experience": player_data.get("experience", 0),
|
||
"体力值": player_data.get("体力值", 20),
|
||
"seed_count": seed_count,
|
||
"last_login_time": player_data.get("last_login_time", "未知"),
|
||
"total_login_time": player_data.get("total_login_time", "0时0分0秒"),
|
||
"is_online": is_online
|
||
}
|
||
|
||
players_data.append(player_info)
|
||
except Exception as e:
|
||
self.log('ERROR', f"读取玩家 {account_id} 的数据时出错: {str(e)}", 'SERVER')
|
||
|
||
# 按等级降序排序
|
||
players_data.sort(key=lambda x: x["level"], reverse=True)
|
||
|
||
# 统计在线玩家数量
|
||
online_count = sum(1 for player in players_data if player.get("is_online", False))
|
||
|
||
self.log('INFO', f"玩家 {self.user_data[client_id].get('username')} 请求玩家排行榜，返回 {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
|
||
})
|
||
#==========================玩家排行榜处理==========================
|
||
|
||
|
||
|
||
#==========================作物数据处理==========================
|
||
#处理客户端请求作物数据
|
||
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} 的数据"
|
||
})
|
||
|
||
# 返回目标玩家的农场数据（只返回可见的数据，不包含敏感信息如密码）
|
||
safe_player_data = {
|
||
"user_name": target_player_data.get("user_name", target_username),
|
||
"player_name": target_player_data.get("player_name", target_username),
|
||
"farm_name": target_player_data.get("farm_name", ""),
|
||
"level": target_player_data.get("level", 1),
|
||
"money": target_player_data.get("money", 0),
|
||
"experience": target_player_data.get("experience", 0),
|
||
"体力值": target_player_data.get("体力值", 20),
|
||
"farm_lots": target_player_data.get("farm_lots", []),
|
||
"player_bag": target_player_data.get("player_bag", []),
|
||
"last_login_time": target_player_data.get("last_login_time", "未知"),
|
||
"total_login_time": target_player_data.get("total_login_time", "0时0分0秒"),
|
||
"total_likes": target_player_data.get("total_likes", 0)
|
||
}
|
||
|
||
current_username = self.user_data[client_id]["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 _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.log('INFO', f"玩家 {username} 返回了自己的农场", 'SERVER')
|
||
|
||
# 返回玩家自己的农场数据
|
||
return self.send_data(client_id, {
|
||
"type": "return_my_farm_response",
|
||
"success": True,
|
||
"message": "已返回自己的农场",
|
||
"player_data": {
|
||
"user_name": player_data.get("user_name", username),
|
||
"player_name": player_data.get("player_name", username),
|
||
"farm_name": player_data.get("farm_name", ""),
|
||
"level": player_data.get("level", 1),
|
||
"money": player_data.get("money", 0),
|
||
"experience": player_data.get("experience", 0),
|
||
"体力值": player_data.get("体力值", 20),
|
||
"farm_lots": player_data.get("farm_lots", []),
|
||
"player_bag": player_data.get("player_bag", []),
|
||
"total_likes": player_data.get("total_likes", 0)
|
||
},
|
||
"is_visiting": False
|
||
})
|
||
#==========================返回自己农场处理==========================
|
||
|
||
|
||
|
||
|
||
#==========================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_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 _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)
|
||
|
||
# 检查今日是否已签到
|
||
current_date = datetime.datetime.now().strftime("%Y-%m-%d")
|
||
check_in_data = player_data.get("daily_check_in", {})
|
||
|
||
if current_date in check_in_data:
|
||
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(check_in_data, current_date)
|
||
|
||
# 生成签到奖励
|
||
rewards = self._generate_check_in_rewards(consecutive_days)
|
||
|
||
# 发放奖励
|
||
self._apply_check_in_rewards(player_data, rewards)
|
||
|
||
# 保存签到记录
|
||
if "daily_check_in" not in player_data:
|
||
player_data["daily_check_in"] = {}
|
||
|
||
player_data["daily_check_in"][current_date] = {
|
||
"rewards": rewards,
|
||
"consecutive_days": consecutive_days,
|
||
"timestamp": time.time()
|
||
}
|
||
|
||
# 保存玩家数据
|
||
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": {
|
||
"money": player_data["money"],
|
||
"experience": player_data["experience"],
|
||
"level": player_data["level"],
|
||
"player_bag": player_data.get("player_bag", [])
|
||
}
|
||
})
|
||
|
||
#处理客户端获取签到数据请求
|
||
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)
|
||
|
||
current_date = datetime.datetime.now().strftime("%Y-%m-%d")
|
||
check_in_data = player_data.get("daily_check_in", {})
|
||
|
||
# 计算连续签到天数
|
||
consecutive_days = self._calculate_consecutive_check_in_days(check_in_data, current_date)
|
||
|
||
# 检查今日是否已签到
|
||
has_checked_in_today = current_date in check_in_data
|
||
|
||
return self.send_data(client_id, {
|
||
"type": "check_in_data_response",
|
||
"success": True,
|
||
"check_in_data": check_in_data,
|
||
"consecutive_days": consecutive_days,
|
||
"has_checked_in_today": has_checked_in_today,
|
||
"current_date": current_date
|
||
})
|
||
|
||
#计算连续签到天数
|
||
def _calculate_consecutive_check_in_days(self, check_in_data, current_date):
|
||
"""计算连续签到天数"""
|
||
if not check_in_data:
|
||
return 0
|
||
|
||
# 获取所有签到日期并排序
|
||
sorted_dates = sorted(check_in_data.keys())
|
||
if not sorted_dates:
|
||
return 0
|
||
|
||
# 从最新日期开始向前计算连续天数
|
||
consecutive_days = 0
|
||
current_datetime = datetime.datetime.strptime(current_date, "%Y-%m-%d")
|
||
|
||
# 如果今天已经签到，从今天开始计算，否则从昨天开始
|
||
if current_date in check_in_data:
|
||
check_date = current_datetime
|
||
else:
|
||
check_date = current_datetime - datetime.timedelta(days=1)
|
||
|
||
# 向前查找连续签到天数
|
||
while True:
|
||
date_string = check_date.strftime("%Y-%m-%d")
|
||
if date_string in check_in_data:
|
||
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(self, consecutive_days):
|
||
"""生成签到奖励"""
|
||
import random
|
||
|
||
# 加载作物配置
|
||
crop_data = self._load_crop_data()
|
||
|
||
rewards = {}
|
||
|
||
# 基础奖励倍数（根据连续签到天数）
|
||
base_multiplier = 1.0 + (consecutive_days - 1) * 0.1 # 每连续签到一天增加10%
|
||
max_multiplier = 3.0 # 最大3倍奖励
|
||
multiplier = min(base_multiplier, max_multiplier)
|
||
|
||
# 钱币奖励 (基础200-500，受连续签到影响)
|
||
base_coins = random.randint(200, 500)
|
||
rewards["coins"] = int(base_coins * multiplier)
|
||
|
||
# 经验奖励 (基础50-120，受连续签到影响)
|
||
base_exp = random.randint(50, 120)
|
||
rewards["exp"] = int(base_exp * multiplier)
|
||
|
||
# 种子奖励 (根据连续签到天数获得更好的种子)
|
||
seeds = self._generate_check_in_seeds(consecutive_days, crop_data)
|
||
if seeds:
|
||
rewards["seeds"] = seeds
|
||
|
||
# 连续签到特殊奖励
|
||
if consecutive_days >= 3:
|
||
rewards["bonus_coins"] = int(100 * (consecutive_days // 3))
|
||
|
||
if consecutive_days >= 7:
|
||
rewards["bonus_exp"] = int(200 * (consecutive_days // 7))
|
||
|
||
return rewards
|
||
|
||
#生成签到种子奖励
|
||
def _generate_check_in_seeds(self, consecutive_days, crop_data):
|
||
"""生成签到种子奖励"""
|
||
import random
|
||
|
||
seeds = []
|
||
|
||
# 根据连续签到天数确定种子类型和数量
|
||
if consecutive_days <= 2:
|
||
# 1-2天：普通种子
|
||
common_seeds = ["小麦", "胡萝卜", "土豆", "稻谷"]
|
||
elif consecutive_days <= 5:
|
||
# 3-5天：优良种子
|
||
common_seeds = ["玉米", "番茄", "洋葱", "大豆", "豌豆", "黄瓜", "大白菜"]
|
||
elif consecutive_days <= 10:
|
||
# 6-10天：稀有种子
|
||
common_seeds = ["草莓", "花椰菜", "柿子", "蓝莓", "树莓"]
|
||
elif consecutive_days <= 15:
|
||
# 11-15天：史诗种子
|
||
common_seeds = ["葡萄", "南瓜", "芦笋", "茄子", "向日葵", "蕨菜"]
|
||
else:
|
||
# 16天以上：传奇种子
|
||
common_seeds = ["西瓜", "甘蔗", "香草", "甜菜", "人参", "富贵竹", "芦荟", "哈密瓜"]
|
||
|
||
# 生成1-3个种子
|
||
seed_count = random.randint(1, min(3, len(common_seeds)))
|
||
selected_seeds = random.sample(common_seeds, seed_count)
|
||
|
||
for seed_name in selected_seeds:
|
||
if seed_name in crop_data:
|
||
# 根据种子等级确定数量
|
||
seed_level = crop_data[seed_name].get("等级", 1)
|
||
if seed_level <= 2:
|
||
quantity = random.randint(2, 5)
|
||
elif seed_level <= 4:
|
||
quantity = random.randint(1, 3)
|
||
else:
|
||
quantity = 1
|
||
|
||
seeds.append({
|
||
"name": seed_name,
|
||
"quantity": quantity,
|
||
"quality": crop_data[seed_name].get("品质", "普通")
|
||
})
|
||
|
||
return seeds
|
||
|
||
#应用签到奖励到玩家数据
|
||
def _apply_check_in_rewards(self, player_data, rewards):
|
||
"""应用签到奖励到玩家数据"""
|
||
# 应用钱币奖励
|
||
if "coins" in rewards:
|
||
player_data["money"] = player_data.get("money", 0) + rewards["coins"]
|
||
|
||
if "bonus_coins" in rewards:
|
||
player_data["money"] = player_data.get("money", 0) + rewards["bonus_coins"]
|
||
|
||
# 应用经验奖励
|
||
if "exp" in rewards:
|
||
player_data["experience"] = player_data.get("experience", 0) + rewards["exp"]
|
||
|
||
if "bonus_exp" in rewards:
|
||
player_data["experience"] = player_data.get("experience", 0) + rewards["bonus_exp"]
|
||
|
||
# 检查升级
|
||
level_up_experience = 100 * player_data.get("level", 1)
|
||
while player_data.get("experience", 0) >= level_up_experience:
|
||
player_data["level"] = player_data.get("level", 1) + 1
|
||
player_data["experience"] -= level_up_experience
|
||
level_up_experience = 100 * player_data["level"]
|
||
|
||
# 应用种子奖励
|
||
if "seeds" in rewards:
|
||
if "player_bag" not in player_data:
|
||
player_data["player_bag"] = []
|
||
|
||
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["player_bag"]:
|
||
if item.get("name") == seed_name:
|
||
item["count"] += quantity
|
||
found = True
|
||
break
|
||
|
||
# 如果背包中没有，添加新条目
|
||
if not found:
|
||
player_data["player_bag"].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)
|
||
|
||
# 检查是否已经领取过新手大礼包
|
||
if player_data.get("new_player_gift_claimed", False):
|
||
return self.send_data(client_id, {
|
||
"type": "new_player_gift_response",
|
||
"success": False,
|
||
"message": "新手大礼包已经领取过了"
|
||
})
|
||
|
||
# 新手大礼包内容
|
||
gift_contents = {
|
||
"coins": 6000,
|
||
"experience": 1000,
|
||
"seeds": [
|
||
{"name": "龙果", "quality": "传奇", "count": 1},
|
||
{"name": "杂交树1", "quality": "传奇", "count": 1},
|
||
{"name": "杂交树2", "quality": "传奇", "count": 1}
|
||
]
|
||
}
|
||
|
||
# 应用奖励
|
||
self._apply_new_player_gift_rewards(player_data, gift_contents)
|
||
|
||
# 标记已领取
|
||
player_data["new_player_gift_claimed"] = True
|
||
|
||
# 记录领取时间
|
||
player_data["new_player_gift_time"] = 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": "新手大礼包领取成功！获得6000金币、1000经验和3个传奇种子",
|
||
"gift_contents": gift_contents,
|
||
"updated_data": {
|
||
"money": player_data["money"],
|
||
"experience": player_data["experience"],
|
||
"level": player_data["level"],
|
||
"player_bag": player_data.get("player_bag", []),
|
||
"new_player_gift_claimed": True
|
||
}
|
||
})
|
||
|
||
except Exception as e:
|
||
# 捕获所有异常，防止服务器崩溃
|
||
self.log('ERROR', f"处理新手大礼包请求时出错: {str(e)}", 'SERVER')
|
||
|
||
# 尝试获取用户名
|
||
try:
|
||
username = self.user_data[client_id].get("username", "未知用户")
|
||
except:
|
||
username = "未知用户"
|
||
|
||
# 发送错误响应
|
||
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["money"] = player_data.get("money", 0) + gift_contents["coins"]
|
||
|
||
# 应用经验奖励
|
||
if "experience" in gift_contents:
|
||
player_data["experience"] = player_data.get("experience", 0) + gift_contents["experience"]
|
||
|
||
# 检查升级
|
||
level_up_experience = 100 * player_data.get("level", 1)
|
||
while player_data.get("experience", 0) >= level_up_experience:
|
||
player_data["level"] = player_data.get("level", 1) + 1
|
||
player_data["experience"] -= level_up_experience
|
||
level_up_experience = 100 * player_data["level"]
|
||
|
||
# 应用种子奖励
|
||
if "seeds" in gift_contents:
|
||
if "player_bag" not in player_data:
|
||
player_data["player_bag"] = []
|
||
|
||
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["player_bag"]:
|
||
if item.get("name") == seed_name:
|
||
item["count"] += quantity
|
||
found = True
|
||
break
|
||
|
||
# 如果背包中没有，添加新条目
|
||
if not found:
|
||
player_data["player_bag"].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)
|
||
|
||
draw_type = message.get("draw_type", "single") # single, five, ten
|
||
draw_count = 1
|
||
base_cost = 800 # 基础抽奖费用
|
||
|
||
# 计算抽奖费用和数量
|
||
if draw_type == "single":
|
||
draw_count = 1
|
||
total_cost = base_cost
|
||
elif draw_type == "five":
|
||
draw_count = 5
|
||
total_cost = int(base_cost * 5 * 0.9) # 五连抽九折
|
||
elif draw_type == "ten":
|
||
draw_count = 10
|
||
total_cost = int(base_cost * 10 * 0.8) # 十连抽八折
|
||
else:
|
||
self.log('WARNING', f"玩家 {username} 使用了无效的抽奖类型: {draw_type}", 'SERVER')
|
||
return self.send_data(client_id, {
|
||
"type": "lucky_draw_response",
|
||
"success": False,
|
||
"message": "无效的抽奖类型"
|
||
})
|
||
|
||
# 检查玩家金钱是否足够
|
||
if player_data.get("money", 0) < total_cost:
|
||
self.log('WARNING', f"玩家 {username} 金币不足进行{draw_type}抽奖，需要{total_cost}，当前{player_data.get('money', 0)}", 'SERVER')
|
||
return self.send_data(client_id, {
|
||
"type": "lucky_draw_response",
|
||
"success": False,
|
||
"message": f"金钱不足，{draw_type}抽奖需要 {total_cost} 金币"
|
||
})
|
||
|
||
# 扣除金钱
|
||
player_data["money"] -= total_cost
|
||
|
||
# 生成奖励
|
||
rewards = self._generate_lucky_draw_rewards(draw_count, draw_type)
|
||
|
||
# 验证奖励格式
|
||
for reward in rewards:
|
||
if not reward.get("rarity"):
|
||
reward["rarity"] = "普通"
|
||
self.log('WARNING', f"奖励缺少稀有度字段，已设置为普通: {reward}", 'SERVER')
|
||
|
||
# 应用奖励到玩家数据
|
||
self._apply_lucky_draw_rewards(player_data, rewards)
|
||
|
||
# 记录抽奖历史
|
||
if "lucky_draw_history" not in player_data:
|
||
player_data["lucky_draw_history"] = []
|
||
|
||
draw_record = {
|
||
"date": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
|
||
"type": draw_type,
|
||
"cost": total_cost,
|
||
"rewards": rewards
|
||
}
|
||
player_data["lucky_draw_history"].append(draw_record)
|
||
|
||
# 只保留最近100次记录
|
||
if len(player_data["lucky_draw_history"]) > 100:
|
||
player_data["lucky_draw_history"] = player_data["lucky_draw_history"][-100:]
|
||
|
||
# 保存玩家数据
|
||
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": {
|
||
"money": player_data["money"],
|
||
"experience": player_data["experience"],
|
||
"level": player_data["level"],
|
||
"player_bag": player_data.get("player_bag", [])
|
||
}
|
||
})
|
||
|
||
except Exception as e:
|
||
# 捕获所有异常，防止服务器崩溃
|
||
self.log('ERROR', f"处理玩家抽奖请求时出错: {str(e)}", 'SERVER')
|
||
|
||
# 尝试获取用户名
|
||
try:
|
||
username = self.user_data[client_id].get("username", "未知用户")
|
||
except:
|
||
username = "未知用户"
|
||
|
||
# 发送错误响应
|
||
return self.send_data(client_id, {
|
||
"type": "lucky_draw_response",
|
||
"success": False,
|
||
"message": "服务器处理抽奖时出现错误，请稍后重试"
|
||
})
|
||
|
||
#生成幸运抽奖奖励
|
||
def _generate_lucky_draw_rewards(self, count: int, draw_type: str):
|
||
"""生成幸运抽奖奖励"""
|
||
import random
|
||
|
||
# 加载作物配置
|
||
crop_data = self._load_crop_data()
|
||
|
||
rewards = []
|
||
|
||
# 根据 crop_data.json 构建奖励池
|
||
common_seeds = []
|
||
good_seeds = []
|
||
rare_seeds = []
|
||
epic_seeds = []
|
||
legendary_seeds = []
|
||
|
||
for crop_name, crop_info in crop_data.items():
|
||
if not crop_info.get("能否购买", True):
|
||
continue # 跳过不能购买的作物
|
||
|
||
quality = crop_info.get("品质", "普通")
|
||
if quality == "普通":
|
||
common_seeds.append(crop_name)
|
||
elif quality == "优良":
|
||
good_seeds.append(crop_name)
|
||
elif quality == "稀有":
|
||
rare_seeds.append(crop_name)
|
||
elif quality == "史诗":
|
||
epic_seeds.append(crop_name)
|
||
elif quality == "传奇":
|
||
legendary_seeds.append(crop_name)
|
||
|
||
# 十连抽保底机制：至少一个稀有以上
|
||
guaranteed_rare = (draw_type == "ten")
|
||
rare_given = False
|
||
|
||
for i in range(count):
|
||
# 生成单个奖励
|
||
reward = self._generate_single_lucky_reward(
|
||
common_seeds, good_seeds, rare_seeds, epic_seeds, legendary_seeds,
|
||
guaranteed_rare and i == count - 1 and not rare_given
|
||
)
|
||
|
||
# 检查是否给出了稀有奖励（使用安全的方式访问）
|
||
reward_rarity = reward.get("rarity", "普通")
|
||
if reward_rarity in ["稀有", "史诗", "传奇"]:
|
||
rare_given = True
|
||
|
||
rewards.append(reward)
|
||
|
||
return rewards
|
||
|
||
#生成单个抽奖奖励
|
||
def _generate_single_lucky_reward(self, common_seeds, good_seeds, rare_seeds, epic_seeds, legendary_seeds, force_rare=False):
|
||
"""生成单个幸运抽奖奖励"""
|
||
import random
|
||
|
||
# 概率配置
|
||
if force_rare:
|
||
# 强制稀有：33%稀有，33%史诗，34%传奇
|
||
rand = random.random()
|
||
if rand < 0.33:
|
||
reward_type = "rare"
|
||
elif rand < 0.66:
|
||
reward_type = "epic"
|
||
else:
|
||
reward_type = "legendary"
|
||
else:
|
||
# 正常概率：45%普通，25%优良，15%空奖，12%稀有，2.5%史诗，0.5%传奇
|
||
rand = random.random()
|
||
if rand < 0.45:
|
||
reward_type = "common"
|
||
elif rand < 0.70:
|
||
reward_type = "good"
|
||
elif rand < 0.85:
|
||
reward_type = "empty"
|
||
elif rand < 0.97:
|
||
reward_type = "rare"
|
||
elif rand < 0.995:
|
||
reward_type = "epic"
|
||
else:
|
||
reward_type = "legendary"
|
||
|
||
reward = {}
|
||
|
||
if reward_type == "empty":
|
||
# 谢谢惠顾
|
||
empty_messages = ["谢谢惠顾", "下次再来", "再试一次", "继续努力"]
|
||
reward = {
|
||
"type": "empty",
|
||
"name": random.choice(empty_messages),
|
||
"rarity": "空奖",
|
||
"amount": 0
|
||
}
|
||
|
||
elif reward_type == "common":
|
||
# 普通奖励：金币、经验或普通种子
|
||
reward_choice = random.choice(["coins", "exp", "seed"])
|
||
if reward_choice == "coins":
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "普通",
|
||
"amount": random.randint(100, 300)
|
||
}
|
||
elif reward_choice == "exp":
|
||
reward = {
|
||
"type": "exp",
|
||
"name": "经验",
|
||
"rarity": "普通",
|
||
"amount": random.randint(50, 150)
|
||
}
|
||
else: # seed
|
||
if common_seeds:
|
||
seed_name = random.choice(common_seeds)
|
||
reward = {
|
||
"type": "seed",
|
||
"name": seed_name,
|
||
"rarity": "普通",
|
||
"amount": random.randint(2, 4)
|
||
}
|
||
else:
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "普通",
|
||
"amount": random.randint(100, 300)
|
||
}
|
||
|
||
elif reward_type == "good":
|
||
# 优良奖励：更多金币经验或优良种子
|
||
reward_choice = random.choice(["coins", "exp", "seed", "package"])
|
||
if reward_choice == "coins":
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "优良",
|
||
"amount": random.randint(300, 600)
|
||
}
|
||
elif reward_choice == "exp":
|
||
reward = {
|
||
"type": "exp",
|
||
"name": "经验",
|
||
"rarity": "优良",
|
||
"amount": random.randint(150, 300)
|
||
}
|
||
elif reward_choice == "seed":
|
||
if good_seeds:
|
||
seed_name = random.choice(good_seeds)
|
||
reward = {
|
||
"type": "seed",
|
||
"name": seed_name,
|
||
"rarity": "优良",
|
||
"amount": random.randint(1, 3)
|
||
}
|
||
else:
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "优良",
|
||
"amount": random.randint(300, 600)
|
||
}
|
||
else: # package
|
||
reward = {
|
||
"type": "package",
|
||
"name": "成长套餐",
|
||
"rarity": "优良",
|
||
"amount": 1,
|
||
"contents": [
|
||
{"type": "coins", "amount": random.randint(200, 400)},
|
||
{"type": "exp", "amount": random.randint(100, 200)},
|
||
{"type": "seed", "name": random.choice(common_seeds) if common_seeds else "小麦", "amount": random.randint(2, 3)}
|
||
]
|
||
}
|
||
|
||
elif reward_type == "rare":
|
||
# 稀有奖励
|
||
reward_choice = random.choice(["coins", "exp", "seed", "package"])
|
||
if reward_choice == "coins":
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "稀有",
|
||
"amount": random.randint(600, 1000)
|
||
}
|
||
elif reward_choice == "exp":
|
||
reward = {
|
||
"type": "exp",
|
||
"name": "经验",
|
||
"rarity": "稀有",
|
||
"amount": random.randint(300, 500)
|
||
}
|
||
elif reward_choice == "seed":
|
||
if rare_seeds:
|
||
seed_name = random.choice(rare_seeds)
|
||
reward = {
|
||
"type": "seed",
|
||
"name": seed_name,
|
||
"rarity": "稀有",
|
||
"amount": random.randint(1, 2)
|
||
}
|
||
else:
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "稀有",
|
||
"amount": random.randint(600, 1000)
|
||
}
|
||
else: # package
|
||
reward = {
|
||
"type": "package",
|
||
"name": "稀有礼包",
|
||
"rarity": "稀有",
|
||
"amount": 1,
|
||
"contents": [
|
||
{"type": "coins", "amount": random.randint(400, 700)},
|
||
{"type": "exp", "amount": random.randint(200, 350)},
|
||
{"type": "seed", "name": random.choice(good_seeds) if good_seeds else "番茄", "amount": random.randint(2, 3)}
|
||
]
|
||
}
|
||
|
||
elif reward_type == "epic":
|
||
# 史诗奖励
|
||
reward_choice = random.choice(["coins", "exp", "seed", "package"])
|
||
if reward_choice == "coins":
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "史诗",
|
||
"amount": random.randint(1000, 1500)
|
||
}
|
||
elif reward_choice == "exp":
|
||
reward = {
|
||
"type": "exp",
|
||
"name": "经验",
|
||
"rarity": "史诗",
|
||
"amount": random.randint(500, 800)
|
||
}
|
||
elif reward_choice == "seed":
|
||
if epic_seeds:
|
||
seed_name = random.choice(epic_seeds)
|
||
reward = {
|
||
"type": "seed",
|
||
"name": seed_name,
|
||
"rarity": "史诗",
|
||
"amount": 1
|
||
}
|
||
else:
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "史诗",
|
||
"amount": random.randint(1000, 1500)
|
||
}
|
||
else: # package
|
||
reward = {
|
||
"type": "package",
|
||
"name": "史诗礼包",
|
||
"rarity": "史诗",
|
||
"amount": 1,
|
||
"contents": [
|
||
{"type": "coins", "amount": random.randint(700, 1200)},
|
||
{"type": "exp", "amount": random.randint(350, 600)},
|
||
{"type": "seed", "name": random.choice(rare_seeds) if rare_seeds else "草莓", "amount": random.randint(1, 2)}
|
||
]
|
||
}
|
||
|
||
else: # legendary
|
||
# 传奇奖励
|
||
reward_choice = random.choice(["coins", "exp", "seed", "package"])
|
||
if reward_choice == "coins":
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "传奇",
|
||
"amount": random.randint(1500, 2500)
|
||
}
|
||
elif reward_choice == "exp":
|
||
reward = {
|
||
"type": "exp",
|
||
"name": "经验",
|
||
"rarity": "传奇",
|
||
"amount": random.randint(800, 1200)
|
||
}
|
||
elif reward_choice == "seed":
|
||
if legendary_seeds:
|
||
seed_name = random.choice(legendary_seeds)
|
||
reward = {
|
||
"type": "seed",
|
||
"name": seed_name,
|
||
"rarity": "传奇",
|
||
"amount": 1
|
||
}
|
||
else:
|
||
reward = {
|
||
"type": "coins",
|
||
"name": "金币",
|
||
"rarity": "传奇",
|
||
"amount": random.randint(1500, 2500)
|
||
}
|
||
else: # package
|
||
reward = {
|
||
"type": "package",
|
||
"name": "传奇大礼包",
|
||
"rarity": "传奇",
|
||
"amount": 1,
|
||
"contents": [
|
||
{"type": "coins", "amount": random.randint(1000, 2000)},
|
||
{"type": "exp", "amount": random.randint(600, 1000)},
|
||
{"type": "seed", "name": random.choice(epic_seeds) if epic_seeds else "葡萄", "amount": 1},
|
||
{"type": "seed", "name": random.choice(rare_seeds) if rare_seeds else "草莓", "amount": random.randint(2, 3)}
|
||
]
|
||
}
|
||
|
||
# 确保所有奖励都有基本字段
|
||
if not reward.get("rarity"):
|
||
reward["rarity"] = "普通"
|
||
if not reward.get("amount"):
|
||
reward["amount"] = 0
|
||
if not reward.get("type"):
|
||
reward["type"] = "empty"
|
||
if not reward.get("name"):
|
||
reward["name"] = "未知奖励"
|
||
|
||
return reward
|
||
|
||
#应用幸运抽奖奖励到玩家数据
|
||
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["money"] = player_data.get("money", 0) + reward.get("amount", 0)
|
||
|
||
elif reward_type == "exp":
|
||
player_data["experience"] = player_data.get("experience", 0) + reward.get("amount", 0)
|
||
|
||
# 检查升级
|
||
level_up_experience = 100 * player_data.get("level", 1)
|
||
while player_data.get("experience", 0) >= level_up_experience:
|
||
player_data["level"] = player_data.get("level", 1) + 1
|
||
player_data["experience"] -= level_up_experience
|
||
level_up_experience = 100 * player_data["level"]
|
||
|
||
elif reward_type == "seed":
|
||
if "player_bag" not in player_data:
|
||
player_data["player_bag"] = []
|
||
|
||
# 查找背包中是否已有该种子
|
||
found = False
|
||
for item in player_data["player_bag"]:
|
||
if item.get("name") == reward.get("name", ""):
|
||
item["count"] += reward.get("amount", 0)
|
||
found = True
|
||
break
|
||
|
||
# 如果背包中没有，添加新条目
|
||
if not found:
|
||
player_data["player_bag"].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 cleanup_expired_cache(self):
|
||
"""清理过期的缓存数据"""
|
||
current_time = time.time()
|
||
expired_players = []
|
||
|
||
for account_id, cache_data in self.active_players_cache.items():
|
||
if current_time - cache_data.get("last_access", 0) > self.cache_expire_time:
|
||
expired_players.append(account_id)
|
||
|
||
for account_id in expired_players:
|
||
# 如果是脏数据，先保存
|
||
if account_id in self.dirty_players:
|
||
self.save_player_data_immediate(account_id)
|
||
self.dirty_players.discard(account_id)
|
||
|
||
# 移除过期缓存
|
||
self.player_cache.pop(account_id, None)
|
||
self.active_players_cache.pop(account_id, None)
|
||
|
||
if expired_players:
|
||
self.log('INFO', f"清理了 {len(expired_players)} 个过期缓存", 'SERVER')
|
||
|
||
#批量保存脏数据到磁盘
|
||
def batch_save_dirty_players(self):
|
||
"""批量保存脏数据到磁盘"""
|
||
if not self.dirty_players:
|
||
return
|
||
|
||
saved_count = 0
|
||
for account_id in list(self.dirty_players):
|
||
try:
|
||
if self.save_player_data_immediate(account_id):
|
||
saved_count += 1
|
||
except Exception as e:
|
||
self.log('ERROR', f"保存玩家 {account_id} 数据时出错: {str(e)}", 'SERVER')
|
||
|
||
self.dirty_players.clear()
|
||
self.last_save_time = time.time()
|
||
|
||
if saved_count > 0:
|
||
self.log('INFO', f"批量保存了 {saved_count} 个玩家的数据", 'SERVER')
|
||
|
||
#强制保存所有缓存数据
|
||
def force_save_all_data(self):
|
||
"""强制保存所有缓存数据（用于服务器关闭时）"""
|
||
saved_count = 0
|
||
for account_id in list(self.player_cache.keys()):
|
||
try:
|
||
if self.save_player_data_immediate(account_id):
|
||
saved_count += 1
|
||
except Exception as e:
|
||
self.log('ERROR', f"强制保存玩家 {account_id} 数据时出错: {str(e)}", 'SERVER')
|
||
|
||
self.dirty_players.clear()
|
||
self.log('INFO', f"强制保存完成，保存了 {saved_count} 个玩家的数据", 'SERVER')
|
||
return saved_count
|
||
|
||
#优化缓存大小，移除不活跃的数据
|
||
def optimize_cache_size(self):
|
||
"""优化缓存大小，移除不活跃的数据"""
|
||
current_time = time.time()
|
||
removed_count = 0
|
||
|
||
# 如果缓存过大，移除最不活跃的数据
|
||
if len(self.player_cache) > 1000: # 缓存超过1000个玩家时进行清理
|
||
sorted_players = sorted(
|
||
self.active_players_cache.items(),
|
||
key=lambda x: x[1].get("last_access", 0)
|
||
)
|
||
|
||
# 移除最不活跃的50%
|
||
remove_count = len(sorted_players) // 2
|
||
for account_id, _ in sorted_players[:remove_count]:
|
||
if account_id in self.dirty_players:
|
||
self.save_player_data_immediate(account_id)
|
||
self.dirty_players.discard(account_id)
|
||
|
||
self.player_cache.pop(account_id, None)
|
||
self.active_players_cache.pop(account_id, None)
|
||
removed_count += 1
|
||
|
||
if removed_count > 0:
|
||
self.log('INFO', f"缓存优化：移除了 {removed_count} 个不活跃的缓存数据", 'SERVER')
|
||
|
||
return removed_count
|
||
|
||
#获取缓存命中信息（用于调试）
|
||
def get_cache_hit_info(self, account_id):
|
||
"""获取缓存命中信息（用于调试）"""
|
||
return {
|
||
"in_memory_cache": account_id in self.player_cache,
|
||
"in_active_cache": account_id in self.active_players_cache,
|
||
"is_dirty": account_id in self.dirty_players,
|
||
"last_access": self.active_players_cache.get(account_id, {}).get("last_access", 0)
|
||
}
|
||
|
||
#==========================缓存数据处理==========================
|
||
|
||
# 主程序启动入口
|
||
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(f"🔧 性能优化: 已启用")
|
||
print("=" * 60)
|
||
|
||
# 创建并启动游戏服务器
|
||
server = TCPGameServer()
|
||
|
||
# 在后台线程中启动服务器
|
||
server_thread = threading.Thread(target=server.start)
|
||
server_thread.daemon = True
|
||
server_thread.start()
|
||
|
||
print("✅ 服务器启动成功！")
|
||
print("📋 功能列表:")
|
||
print(" ├── 用户注册/登录系统")
|
||
print(" ├── 作物种植与收获")
|
||
print(" ├── 浇水与施肥系统")
|
||
print(" ├── 每日签到奖励")
|
||
print(" ├── 幸运抽奖系统")
|
||
print(" ├── 玩家互动功能")
|
||
print(" └── 性能优化缓存")
|
||
print("=" * 60)
|
||
print("🔥 服务器运行中... 按 Ctrl+C 停止服务器")
|
||
print("=" * 60)
|
||
|
||
# 主循环：保持服务器运行
|
||
while True:
|
||
time.sleep(1)
|
||
|
||
except KeyboardInterrupt:
|
||
print("\n" + "=" * 60)
|
||
print("⚠️ 程序被用户中断")
|
||
print("💾 正在保存数据并关闭服务器...")
|
||
|
||
if 'server' in locals():
|
||
server.stop()
|
||
|
||
print("✅ 服务器已安全关闭")
|
||
print("👋 感谢使用萌芽农场服务器！")
|
||
print("=" * 60)
|
||
sys.exit(0)
|
||
except Exception as e:
|
||
print(f"\n❌ 服务器启动失败: {str(e)}")
|
||
print("🔧 请检查配置并重试")
|
||
sys.exit(1) |