shumengya/Sprout-Farm
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

稍微优化了一下签到系统和抽奖系统

Browse Source
This commit is contained in:
树萌芽
2025-07-12 21:08:36 +08:00
parent aa8707878e
commit 09b1f19a8f
10 changed files with 791 additions and 1184 deletions
Download Patch File Download Diff File Expand all files Collapse all files

769
Server/TCPGameServer.py
View File

@@ -65,6 +65,7 @@ server_version: str = "2.0.1"
# TCP游戏服务器类
# ============================================================================
class TCPGameServer(TCPServer):
"""
萌芽农场TCP游戏服务器
"""
@@ -6206,6 +6207,39 @@ class TCPGameServer(TCPServer):
#==========================每日签到处理==========================
#加载每日签到配置
def _load_daily_check_in_config(self):
"""加载每日签到配置"""
try:
config_path = os.path.join(self.config_dir, "daily_checkin_config.json")
if os.path.exists(config_path):
with open(config_path, 'r', encoding='utf-8') as f:
return json.load(f)
except:
pass
# 默认配置
return {
"基础奖励": {
"金币": {"最小值": 200, "最大值": 500, "图标": "💰", "颜色": "#FFD700"},
"经验": {"最小值": 50, "最大值": 120, "图标": "⭐", "颜色": "#00BFFF"}
},
"种子奖励": {
"普通": {"概率": 0.6, "数量范围": [2, 5], "种子池": ["小麦", "胡萝卜", "土豆", "稻谷"]},
"优良": {"概率": 0.25, "数量范围": [2, 4], "种子池": ["玉米", "番茄", "洋葱", "大豆", "豌豆", "黄瓜", "大白菜"]},
"稀有": {"概率": 0.12, "数量范围": [1, 3], "种子池": ["草莓", "花椰菜", "柿子", "蓝莓", "树莓"]},
"史诗": {"概率": 0.025, "数量范围": [1, 2], "种子池": ["葡萄", "南瓜", "芦笋", "茄子", "向日葵", "蕨菜"]},
"传奇": {"概率": 0.005, "数量范围": [1, 1], "种子池": ["西瓜", "甘蔗", "香草", "甜菜", "人参", "富贵竹", "芦荟", "哈密瓜"]}
},
"连续签到奖励": {
"第3天": {"额外金币": 100, "额外经验": 50, "描述": "连续签到奖励"},
"第7天": {"额外金币": 200, "额外经验": 100, "描述": "一周连击奖励"},
"第14天": {"额外金币": 500, "额外经验": 200, "描述": "半月连击奖励"},
"第21天": {"额外金币": 800, "额外经验": 300, "描述": "三周连击奖励"},
"第30天": {"额外金币": 1500, "额外经验": 500, "描述": "满月连击奖励"}
}
}
#处理每日签到请求
def _handle_daily_check_in_request(self, client_id, message):
"""处理每日签到请求"""
@@ -6219,36 +6253,41 @@ class TCPGameServer(TCPServer):
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", {})
# 清理过期签到记录并使用新格式
self._cleanup_check_in_history(player_data)
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
})
# 检查今日是否已签到
current_time = datetime.datetime.now()
today_key = current_time.strftime("%Y年%m月%d日")
check_in_history = player_data.get("签到历史", {})
# 检查今日是否已签到
for time_key in check_in_history.keys():
if time_key.startswith(today_key):
return self.send_data(client_id, {
"type": "daily_check_in_response",
"success": False,
"message": "今日已签到，请明日再来",
"has_checked_in": True
})
# 计算连续签到天数
consecutive_days = self._calculate_consecutive_check_in_days(check_in_data, current_date)
consecutive_days = self._calculate_consecutive_check_in_days_new(check_in_history)
# 生成签到奖励
rewards = self._generate_check_in_rewards(consecutive_days)
config = self._load_daily_check_in_config()
rewards = self._generate_check_in_rewards_new(consecutive_days, config)
# 发放奖励
self._apply_check_in_rewards(player_data, rewards)
# 保存签到记录
if "daily_check_in" not in player_data:
player_data["daily_check_in"] = {}
# 保存签到记录 - 使用新格式
if "签到历史" not in player_data:
player_data["签到历史"] = {}
player_data["daily_check_in"][current_date] = {
"rewards": rewards,
"consecutive_days": consecutive_days,
"timestamp": time.time()
}
time_key = current_time.strftime("%Y年%m月%d日%H时%M分%S秒")
reward_text = self._format_reward_text_simple(rewards)
player_data["签到历史"][time_key] = reward_text
# 保存玩家数据
self.save_player_data(username, player_data)
@@ -6282,144 +6321,201 @@ class TCPGameServer(TCPServer):
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", {})
# 清理过期签到记录
self._cleanup_check_in_history(player_data)
check_in_history = player_data.get("签到历史", {})
# 计算连续签到天数
consecutive_days = self._calculate_consecutive_check_in_days(check_in_data, current_date)
consecutive_days = self._calculate_consecutive_check_in_days_new(check_in_history)
# 检查今日是否已签到
has_checked_in_today = current_date in check_in_data
current_time = datetime.datetime.now()
today_key = current_time.strftime("%Y年%m月%d日")
has_checked_in_today = any(time_key.startswith(today_key) for time_key in check_in_history.keys())
return self.send_data(client_id, {
"type": "check_in_data_response",
"success": True,
"check_in_data": check_in_data,
"check_in_data": check_in_history,
"consecutive_days": consecutive_days,
"has_checked_in_today": has_checked_in_today,
"current_date": current_date
"current_date": current_time.strftime("%Y年%m月%d日")
})
#计算连续签到天数
def _calculate_consecutive_check_in_days(self, check_in_data, current_date):
"""计算连续签到天数"""
if not check_in_data:
#清理过期签到记录
def _cleanup_check_in_history(self, player_data):
"""清理过期签到记录，只保留最近30天的记录"""
if "签到历史" not in player_data:
return
current_time = datetime.datetime.now()
cutoff_time = current_time - datetime.timedelta(days=30)
# 清理过期记录
history = player_data["签到历史"]
keys_to_remove = []
for time_key in history.keys():
try:
# 解析时间字符串
check_time = datetime.datetime.strptime(time_key, "%Y年%m月%d日%H时%M分%S秒")
if check_time < cutoff_time:
keys_to_remove.append(time_key)
except:
# 如果解析失败，删除这条记录
keys_to_remove.append(time_key)
for key in keys_to_remove:
del history[key]
#计算连续签到天数（新版本）
def _calculate_consecutive_check_in_days_new(self, check_in_history):
"""计算连续签到天数（新版本）"""
if not check_in_history:
return 0
# 获取所有签到日期并排序
sorted_dates = sorted(check_in_data.keys())
if not sorted_dates:
# 提取所有签到日期（只取日期部分）
check_dates = set()
for time_key in check_in_history.keys():
try:
check_time = datetime.datetime.strptime(time_key, "%Y年%m月%d日%H时%M分%S秒")
date_str = check_time.strftime("%Y-%m-%d")
check_dates.add(date_str)
except:
continue
if not check_dates:
return 0
# 从最新日期开始向前计算连续天数
# 从今天开始向前计算连续天数
consecutive_days = 0
current_datetime = datetime.datetime.strptime(current_date, "%Y-%m-%d")
current_date = datetime.datetime.now()
# 如果今天已经签到，从今天开始计算，否则从昨天开始
if current_date in check_in_data:
check_date = current_datetime
# 检查今天是否已签到
today_str = current_date.strftime("%Y-%m-%d")
if today_str in check_dates:
consecutive_days += 1
check_date = current_date - datetime.timedelta(days=1)
else:
check_date = current_datetime - datetime.timedelta(days=1)
check_date = current_date - datetime.timedelta(days=1)
# 向前查找连续签到天数
while True:
date_string = check_date.strftime("%Y-%m-%d")
if date_string in check_in_data:
date_str = check_date.strftime("%Y-%m-%d")
if date_str in check_dates:
consecutive_days += 1
check_date -= datetime.timedelta(days=1)
else:
break
# 限制最大连续天数为30天，避免过度奖励
# 限制最大连续天数为30天
if consecutive_days >= 30:
break
return consecutive_days
#生成签到奖励
def _generate_check_in_rewards(self, consecutive_days):
"""生成签到奖励"""
#生成签到奖励（新版本）
def _generate_check_in_rewards_new(self, consecutive_days, config):
"""生成签到奖励（新版本）"""
import random
# 加载作物配置
crop_data = self._load_crop_data()
rewards = {}
# 基础奖励倍数（根据连续签到天数）
base_multiplier = 1.0 + (consecutive_days - 1) * 0.1 # 每连续签到一天增加10%
max_multiplier = 3.0 # 最大3倍奖励
# 基础奖励倍数
base_multiplier = 1.0 + (consecutive_days - 1) * 0.1
max_multiplier = 3.0
multiplier = min(base_multiplier, max_multiplier)
# 钱币奖励 (基础200-500，受连续签到影响)
base_coins = random.randint(200, 500)
# 基础金币奖励
coin_config = config.get("基础奖励", {}).get("金币", {})
base_coins = random.randint(coin_config.get("最小值", 200), coin_config.get("最大值", 500))
rewards["coins"] = int(base_coins * multiplier)
# 经验奖励 (基础50-120，受连续签到影响)
base_exp = random.randint(50, 120)
# 基础经验奖励
exp_config = config.get("基础奖励", {}).get("经验", {})
base_exp = random.randint(exp_config.get("最小值", 50), exp_config.get("最大值", 120))
rewards["exp"] = int(base_exp * multiplier)
# 种子奖励 (根据连续签到天数获得更好的种子)
seeds = self._generate_check_in_seeds(consecutive_days, crop_data)
# 种子奖励
seeds = self._generate_check_in_seeds_new(consecutive_days, config)
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))
consecutive_rewards = config.get("连续签到奖励", {})
for milestone, bonus in consecutive_rewards.items():
milestone_days = int(milestone.replace("第", "").replace("天", ""))
if consecutive_days >= milestone_days:
if "额外金币" in bonus:
rewards["bonus_coins"] = bonus["额外金币"]
if "额外经验" in bonus:
rewards["bonus_exp"] = bonus["额外经验"]
return rewards
#生成签到种子奖励
def _generate_check_in_seeds(self, consecutive_days, crop_data):
"""生成签到种子奖励"""
#生成签到种子奖励（新版本）
def _generate_check_in_seeds_new(self, consecutive_days, config):
"""生成签到种子奖励（新版本）"""
import random
seeds = []
seed_configs = config.get("种子奖励", {})
# 根据连续签到天数确定种子类型和数量
# 根据连续签到天数确定种子稀有度
if consecutive_days <= 2:
# 1-2天：普通种子
common_seeds = ["小麦", "胡萝卜", "土豆", "稻谷"]
rarity = "普通"
elif consecutive_days <= 5:
# 3-5天：优良种子
common_seeds = ["玉米", "番茄", "洋葱", "大豆", "豌豆", "黄瓜", "大白菜"]
rarity = "优良"
elif consecutive_days <= 10:
# 6-10天：稀有种子
common_seeds = ["草莓", "花椰菜", "柿子", "蓝莓", "树莓"]
rarity = "稀有"
elif consecutive_days <= 15:
# 11-15天：史诗种子
common_seeds = ["葡萄", "南瓜", "芦笋", "茄子", "向日葵", "蕨菜"]
rarity = "史诗"
else:
# 16天以上：传奇种子
common_seeds = ["西瓜", "甘蔗", "香草", "甜菜", "人参", "富贵竹", "芦荟", "哈密瓜"]
rarity = "传奇"
# 获取对应稀有度的种子池
rarity_config = seed_configs.get(rarity, {})
seed_pool = rarity_config.get("种子池", [])
quantity_range = rarity_config.get("数量范围", [1, 2])
if not seed_pool:
return seeds
# 生成1-3个种子
seed_count = random.randint(1, min(3, len(common_seeds)))
selected_seeds = random.sample(common_seeds, seed_count)
seed_count = random.randint(1, min(3, len(seed_pool)))
selected_seeds = random.sample(seed_pool, 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("品质", "普通")
})
quantity = random.randint(quantity_range[0], quantity_range[1])
seeds.append({
"name": seed_name,
"quantity": quantity,
"quality": rarity
})
return seeds
#格式化奖励文本（简单版本）
def _format_reward_text_simple(self, rewards):
"""格式化奖励文本（简单版本）"""
parts = []
if "coins" in rewards:
parts.append(f"金币{rewards['coins']}")
if "exp" in rewards:
parts.append(f"经验{rewards['exp']}")
if "bonus_coins" in rewards:
parts.append(f"额外金币{rewards['bonus_coins']}")
if "bonus_exp" in rewards:
parts.append(f"额外经验{rewards['bonus_exp']}")
if "seeds" in rewards:
for seed in rewards["seeds"]:
parts.append(f"{seed['name']}x{seed['quantity']}")
return " ".join(parts)
#应用签到奖励到玩家数据
def _apply_check_in_rewards(self, player_data, rewards):
"""应用签到奖励到玩家数据"""
@@ -6620,22 +6716,27 @@ class TCPGameServer(TCPServer):
if not player_data:
return self.send_data(client_id, response)
# 删除历史记录（如果存在）
if "lucky_draw_history" in player_data:
del player_data["lucky_draw_history"]
draw_type = message.get("draw_type", "single") # single, five, ten
draw_count = 1
base_cost = 800 # 基础抽奖费用
# 从配置文件获取费用
config = self._load_lucky_draw_config()
costs = config.get("抽奖费用", {"单抽": 800, "五连抽": 3600, "十连抽": 6400})
# 计算抽奖费用和数量
if draw_type == "single":
draw_count = 1
total_cost = base_cost
total_cost = costs.get("单抽", 800)
elif draw_type == "five":
draw_count = 5
total_cost = int(base_cost * 5 * 0.9) # 五连抽九折
total_cost = costs.get("五连抽", 3600)
elif draw_type == "ten":
draw_count = 10
total_cost = int(base_cost * 10 * 0.8) # 十连抽八折
total_cost = costs.get("十连抽", 6400)
else:
self.log('WARNING', f"玩家 {username} 使用了无效的抽奖类型: {draw_type}", 'SERVER')
return self.send_data(client_id, {
"type": "lucky_draw_response",
"success": False,
@@ -6644,44 +6745,21 @@ class TCPGameServer(TCPServer):
# 检查玩家金钱是否足够
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} 金币"
"message": f"金钱不足，需要 {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')
rewards = self._generate_lucky_draw_rewards(draw_count, draw_type, config)
# 应用奖励到玩家数据
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)
@@ -6703,24 +6781,40 @@ class TCPGameServer(TCPServer):
})
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 _load_lucky_draw_config(self):
"""加载抽奖配置"""
try:
config_path = os.path.join(self.config_dir, "lucky_draw_config.json")
if os.path.exists(config_path):
with open(config_path, 'r', encoding='utf-8') as f:
return json.load(f)
except:
pass
# 默认配置
return {
"抽奖费用": {"单抽": 800, "五连抽": 3600, "十连抽": 6400},
"概率配置": {
"普通": {"概率": 0.45, "金币范围": [100, 300], "经验范围": [50, 150], "种子数量": [2, 4]},
"优良": {"概率": 0.25, "金币范围": [300, 600], "经验范围": [150, 300], "种子数量": [1, 3]},
"稀有": {"概率": 0.12, "金币范围": [600, 1000], "经验范围": [300, 500], "种子数量": [1, 2]},
"史诗": {"概率": 0.025, "金币范围": [1000, 1500], "经验范围": [500, 800], "种子数量": [1, 1]},
"传奇": {"概率": 0.005, "金币范围": [1500, 2500], "经验范围": [800, 1200], "种子数量": [1, 1]},
"空奖": {"概率": 0.15, "提示语": ["谢谢惠顾", "下次再来", "再试一次", "继续努力"]}
}
}
#生成幸运抽奖奖励
def _generate_lucky_draw_rewards(self, count: int, draw_type: str):
def _generate_lucky_draw_rewards(self, count: int, draw_type: str, config: dict):
"""生成幸运抽奖奖励"""
import random
@@ -6730,42 +6824,28 @@ class TCPGameServer(TCPServer):
rewards = []
# 根据 crop_data.json 构建奖励池
common_seeds = []
good_seeds = []
rare_seeds = []
epic_seeds = []
legendary_seeds = []
seed_pools = {"普通": [], "优良": [], "稀有": [], "史诗": [], "传奇": []}
for crop_name, crop_info in crop_data.items():
if not crop_info.get("能否购买", True):
continue # 跳过不能购买的作物
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)
if quality in seed_pools:
seed_pools[quality].append(crop_name)
# 十连抽保底机制：至少一个稀有以上
# 十连抽保底机制
guaranteed_rare = (draw_type == "ten")
rare_given = False
for i in range(count):
# 生成单个奖励
reward = self._generate_single_lucky_reward(
common_seeds, good_seeds, rare_seeds, epic_seeds, legendary_seeds,
guaranteed_rare and i == count - 1 and not rare_given
seed_pools, config, guaranteed_rare and i == count - 1 and not rare_given
)
# 检查是否给出了稀有奖励（使用安全的方式访问）
reward_rarity = reward.get("rarity", "普通")
if reward_rarity in ["稀有", "史诗", "传奇"]:
# 检查是否给出了稀有奖励
if reward.get("rarity", "普通") in ["稀有", "史诗", "传奇"]:
rare_given = True
rewards.append(reward)
@@ -6773,278 +6853,166 @@ class TCPGameServer(TCPServer):
return rewards
#生成单个抽奖奖励
def _generate_single_lucky_reward(self, common_seeds, good_seeds, rare_seeds, epic_seeds, legendary_seeds, force_rare=False):
def _generate_single_lucky_reward(self, seed_pools: dict, config: dict, force_rare=False):
"""生成单个幸运抽奖奖励"""
import random
# 概率配置
prob_config = config.get("概率配置", {})
# 决定稀有度
if force_rare:
# 强制稀有：33%稀有，33%史诗，34%传奇
rand = random.random()
if rand < 0.33:
reward_type = "rare"
rarity = "稀有"
elif rand < 0.66:
reward_type = "epic"
rarity = "史诗"
else:
reward_type = "legendary"
rarity = "传奇"
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"
cumulative = 0
rarity = "普通"
for r, config_data in prob_config.items():
prob = config_data.get("概率", 0)
cumulative += prob
if rand < cumulative:
rarity = r
break
reward = {}
if reward_type == "empty":
# 谢谢惠顾
empty_messages = ["谢谢惠顾", "下次再来", "再试一次", "继续努力"]
reward = {
# 根据稀有度生成奖励
if rarity == "空奖":
empty_messages = prob_config.get("空奖", {}).get("提示语", ["谢谢惠顾"])
return {
"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 = {
# 获取稀有度配置
rarity_config = prob_config.get(rarity, {})
# 根据奖励类型权重选择奖励类型
type_weights = config.get("奖励类型权重", {}).get(rarity, {"金币": 0.5, "经验": 0.3, "种子": 0.2})
# 随机选择奖励类型
rand = random.random()
cumulative = 0
reward_type = "金币"
for r_type, weight in type_weights.items():
cumulative += weight
if rand < cumulative:
reward_type = r_type
break
# 生成具体奖励
if reward_type == "金币":
coin_range = rarity_config.get("金币范围", [100, 300])
return {
"type": "coins",
"name": "金币",
"rarity": rarity,
"amount": random.randint(coin_range[0], coin_range[1])
}
elif reward_type == "经验":
exp_range = rarity_config.get("经验范围", [50, 150])
return {
"type": "exp",
"name": "经验",
"rarity": rarity,
"amount": random.randint(exp_range[0], exp_range[1])
}
elif reward_type == "种子":
seeds = seed_pools.get(rarity, [])
if not seeds:
# 如果没有对应稀有度的种子，给金币
coin_range = rarity_config.get("金币范围", [100, 300])
return {
"type": "coins",
"name": "金币",
"rarity": "普通",
"amount": random.randint(100, 300)
"rarity": rarity,
"amount": random.randint(coin_range[0], coin_range[1])
}
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)
}
seed_count_range = rarity_config.get("种子数量", [1, 2])
return {
"type": "seed",
"name": random.choice(seeds),
"rarity": rarity,
"amount": random.randint(seed_count_range[0], seed_count_range[1])
}
elif reward_type == "good":
# 优良奖励：更多金币经验或优良种子
reward_choice = random.choice(["coins", "exp", "seed", "package"])
if reward_choice == "coins":
reward = {
elif reward_type == "礼包":
package_config = config.get("礼包配置", {})
package_names = [name for name, info in package_config.items() if info.get("稀有度") == rarity]
if not package_names:
# 如果没有对应稀有度的礼包，给金币
coin_range = rarity_config.get("金币范围", [100, 300])
return {
"type": "coins",
"name": "金币",
"rarity": "优良",
"amount": random.randint(300, 600)
"rarity": rarity,
"amount": random.randint(coin_range[0], coin_range[1])
}
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 = {
package_name = random.choice(package_names)
package_info = package_config[package_name]
contents = []
# 生成礼包内容
content_config = package_info.get("内容", {})
if "金币" in content_config:
coin_range = content_config["金币"]
contents.append({
"type": "coins",
"name": "金币",
"rarity": "稀有",
"amount": random.randint(600, 1000)
}
elif reward_choice == "exp":
reward = {
"amount": random.randint(coin_range[0], coin_range[1]),
"rarity": rarity
})
if "经验" in content_config:
exp_range = content_config["经验"]
contents.append({
"type": "exp",
"name": "经验",
"rarity": "稀有",
"amount": random.randint(300, 500)
}
elif reward_choice == "seed":
if rare_seeds:
seed_name = random.choice(rare_seeds)
reward = {
"amount": random.randint(exp_range[0], exp_range[1]),
"rarity": rarity
})
if "种子数量" in content_config:
seed_count_range = content_config["种子数量"]
lower_rarity = {"优良": "普通", "稀有": "优良", "史诗": "稀有", "传奇": "史诗"}.get(rarity, "普通")
seeds = seed_pools.get(lower_rarity, [])
if seeds:
contents.append({
"type": "seed",
"name": 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)}
]
}
"name": random.choice(seeds),
"amount": random.randint(seed_count_range[0], seed_count_range[1]),
"rarity": rarity
})
return {
"type": "package",
"name": package_name,
"rarity": rarity,
"amount": 1,
"contents": contents
}
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
# 默认给金币
coin_range = rarity_config.get("金币范围", [100, 300])
return {
"type": "coins",
"name": "金币",
"rarity": rarity,
"amount": random.randint(coin_range[0], coin_range[1])
}
#应用幸运抽奖奖励到玩家数据
def _apply_lucky_draw_rewards(self, player_data, rewards):
@@ -7640,6 +7608,10 @@ class TCPGameServer(TCPServer):
"success": False,
"message": message
})
#==========================稻草人系统处理==========================
#==========================智慧树系统处理==========================
def _handle_wisdom_tree_operation(self, client_id, message):
@@ -8303,7 +8275,6 @@ class TCPGameServer(TCPServer):
# 更新杀虫时间为当前时间，避免重复扣血
wisdom_tree_config["距离上一次杀虫时间"] = current_time
#==========================智慧树系统处理==========================
#==========================稻草人系统处理==========================

82
Server/config/daily_checkin_config.json Normal file
View File

@@ -0,0 +1,82 @@
{
"基础奖励": {
"金币": {
"最小值": 200,
"最大值": 500,
"图标": "💰",
"颜色": "#FFD700"
},
"经验": {
"最小值": 50,
"最大值": 120,
"图标": "⭐",
"颜色": "#00BFFF"
}
},
"种子奖励": {
"普通": {
"概率": 0.6,
"数量范围": [2, 5],
"种子池": ["小麦", "胡萝卜", "土豆", "稻谷"]
},
"优良": {
"概率": 0.25,
"数量范围": [2, 4],
"种子池": ["玉米", "番茄", "洋葱", "大豆", "豌豆", "黄瓜", "大白菜"]
},
"稀有": {
"概率": 0.12,
"数量范围": [1, 3],
"种子池": ["草莓", "花椰菜", "柿子", "蓝莓", "树莓"]
},
"史诗": {
"概率": 0.025,
"数量范围": [1, 2],
"种子池": ["葡萄", "南瓜", "芦笋", "茄子", "向日葵", "蕨菜"]
},
"传奇": {
"概率": 0.005,
"数量范围": [1, 1],
"种子池": ["西瓜", "甘蔗", "香草", "甜菜", "人参", "富贵竹", "芦荟", "哈密瓜"]
}
},
"连续签到奖励": {
"第3天": {
"额外金币": 100,
"额外经验": 50,
"描述": "连续签到奖励"
},
"第7天": {
"额外金币": 200,
"额外经验": 100,
"描述": "一周连击奖励"
},
"第14天": {
"额外金币": 500,
"额外经验": 200,
"描述": "半月连击奖励"
},
"第21天": {
"额外金币": 800,
"额外经验": 300,
"描述": "三周连击奖励"
},
"第30天": {
"额外金币": 1500,
"额外经验": 500,
"描述": "满月连击奖励"
}
},
"连击倍率": {
"启用": true,
"基础倍率": 1.0,
"每日递增": 0.1,
"最大倍率": 3.0,
"说明": "连续签到可提升奖励倍率"
},
"历史记录": {
"保存天数": 30,
"清理规则": "超过30天的记录自动清理",
"格式": "年月日时分秒: 奖励描述"
}
}

113
Server/config/lucky_draw_config.json Normal file
View File

@@ -0,0 +1,113 @@
{
"抽奖费用": {
"单抽": 800,
"五连抽": 3600,
"十连抽": 6400
},
"概率配置": {
"普通": {
"概率": 0.45,
"金币范围": [100, 300],
"经验范围": [50, 150],
"种子数量": [2, 4]
},
"优良": {
"概率": 0.25,
"金币范围": [300, 600],
"经验范围": [150, 300],
"种子数量": [1, 3]
},
"稀有": {
"概率": 0.12,
"金币范围": [600, 1000],
"经验范围": [300, 500],
"种子数量": [1, 2]
},
"史诗": {
"概率": 0.025,
"金币范围": [1000, 1500],
"经验范围": [500, 800],
"种子数量": [1, 1]
},
"传奇": {
"概率": 0.005,
"金币范围": [1500, 2500],
"经验范围": [800, 1200],
"种子数量": [1, 1]
},
"空奖": {
"概率": 0.15,
"提示语": ["谢谢惠顾", "下次再来", "再试一次", "继续努力"]
}
},
"礼包配置": {
"成长套餐": {
"稀有度": "优良",
"内容": {
"金币": [200, 400],
"经验": [100, 200],
"种子数量": [2, 3]
}
},
"稀有礼包": {
"稀有度": "稀有",
"内容": {
"金币": [400, 700],
"经验": [200, 350],
"种子数量": [2, 3]
}
},
"史诗礼包": {
"稀有度": "史诗",
"内容": {
"金币": [700, 1200],
"经验": [350, 600],
"种子数量": [1, 2]
}
},
"传奇大礼包": {
"稀有度": "传奇",
"内容": {
"金币": [1000, 2000],
"经验": [600, 1000],
"史诗种子数量": [1, 1],
"稀有种子数量": [2, 3]
}
}
},
"保底机制": {
"十连抽保底": true,
"保底最低稀有度": "稀有"
},
"奖励类型权重": {
"普通": {
"金币": 0.4,
"经验": 0.3,
"种子": 0.3
},
"优良": {
"金币": 0.3,
"经验": 0.2,
"种子": 0.3,
"礼包": 0.2
},
"稀有": {
"金币": 0.2,
"经验": 0.2,
"种子": 0.4,
"礼包": 0.2
},
"史诗": {
"金币": 0.2,
"经验": 0.2,
"种子": 0.4,
"礼包": 0.2
},
"传奇": {
"金币": 0.1,
"经验": 0.1,
"种子": 0.5,
"礼包": 0.3
}
}
}

317
Server/game_saves/2143323382.json
View File

@@ -1,13 +1,13 @@
{
"experience": 1858,
"level": 26,
"money": 1223582,
"experience": 1826,
"level": 27,
"money": 1214966,
"farm_name": "柚大青の小农场",
"player_name": "柚大青",
"user_name": "2143323382",
"user_password": "tyh@19900420",
"last_login_time": "2025年07月09日19时17分38秒",
"total_login_time": "5时0分7秒",
"last_login_time": "2025年07月12日21时05分43秒",
"total_login_time": "5时10分30秒",
"farm_lots": [
{
"crop_type": "",
@@ -560,286 +560,23 @@
"土地等级": 0
}
],
"player_bag": [],
"player_bag": [
{
"name": "稻谷",
"quality": "普通",
"count": 2
},
{
"name": "土豆",
"quality": "普通",
"count": 3
}
],
"total_likes": 3,
"last_water_reset_date": "2025-06-05",
"daily_check_in": {
"2025-06-03": {
"rewards": {
"coins": 259,
"exp": 75,
"seeds": [
{
"name": "土豆",
"quantity": 5,
"quality": "普通"
},
{
"name": "小麦",
"quantity": 4,
"quality": "普通"
},
{
"name": "稻谷",
"quantity": 4,
"quality": "普通"
}
]
},
"consecutive_days": 0,
"timestamp": 1748950405.029992
},
"2025-06-04": {
"rewards": {
"coins": 455,
"exp": 93,
"seeds": [
{
"name": "小麦",
"quantity": 3,
"quality": "普通"
},
{
"name": "胡萝卜",
"quantity": 3,
"quality": "普通"
}
]
},
"consecutive_days": 1,
"timestamp": 1749033203.8079362
},
"2025-06-08": {
"rewards": {
"coins": 376,
"exp": 83,
"seeds": [
{
"name": "胡萝卜",
"quantity": 3,
"quality": "普通"
}
]
},
"consecutive_days": 0,
"timestamp": 1749387590.7727287
},
"2025-06-15": {
"rewards": {
"coins": 329,
"exp": 58,
"seeds": [
{
"name": "胡萝卜",
"quantity": 3,
"quality": "普通"
},
{
"name": "稻谷",
"quantity": 2,
"quality": "普通"
},
{
"name": "土豆",
"quantity": 5,
"quality": "普通"
}
]
},
"consecutive_days": 0,
"timestamp": 1749994853.8761835
},
"2025-06-16": {
"rewards": {
"coins": 219,
"exp": 107,
"seeds": [
{
"name": "稻谷",
"quantity": 5,
"quality": "普通"
},
{
"name": "胡萝卜",
"quantity": 4,
"quality": "普通"
}
]
},
"consecutive_days": 1,
"timestamp": 1750048317.4814892
},
"2025-06-17": {
"rewards": {
"coins": 292,
"exp": 125,
"seeds": [
{
"name": "胡萝卜",
"quantity": 2,
"quality": "普通"
},
{
"name": "小麦",
"quantity": 4,
"quality": "普通"
},
{
"name": "土豆",
"quantity": 5,
"quality": "普通"
}
]
},
"consecutive_days": 2,
"timestamp": 1750171931.7031996
},
"2025-06-19": {
"rewards": {
"coins": 325,
"exp": 93,
"seeds": [
{
"name": "小麦",
"quantity": 4,
"quality": "普通"
}
]
},
"consecutive_days": 0,
"timestamp": 1750313565.2168045
},
"2025-06-20": {
"rewards": {
"coins": 491,
"exp": 119,
"seeds": [
{
"name": "稻谷",
"quantity": 3,
"quality": "普通"
},
{
"name": "胡萝卜",
"quantity": 3,
"quality": "普通"
},
{
"name": "小麦",
"quantity": 2,
"quality": "普通"
}
]
},
"consecutive_days": 1,
"timestamp": 1750391114.5208066
},
"2025-06-21": {
"rewards": {
"coins": 419,
"exp": 111,
"seeds": [
{
"name": "小麦",
"quantity": 2,
"quality": "普通"
},
{
"name": "胡萝卜",
"quantity": 4,
"quality": "普通"
},
{
"name": "稻谷",
"quantity": 3,
"quality": "普通"
}
]
},
"consecutive_days": 2,
"timestamp": 1750474647.3564475
},
"2025-06-22": {
"rewards": {
"coins": 312,
"exp": 128,
"seeds": [
{
"name": "番茄",
"quantity": 5,
"quality": "优良"
},
{
"name": "豌豆",
"quantity": 5,
"quality": "优良"
},
{
"name": "玉米",
"quantity": 2,
"quality": "优良"
}
],
"bonus_coins": 100
},
"consecutive_days": 3,
"timestamp": 1750595733.8604188
},
"2025-06-23": {
"rewards": {
"coins": 403,
"exp": 67,
"seeds": [
{
"name": "大豆",
"quantity": 2,
"quality": "优良"
},
{
"name": "番茄",
"quantity": 4,
"quality": "优良"
}
],
"bonus_coins": 100
},
"consecutive_days": 4,
"timestamp": 1750645219.0674949
},
"2025-06-25": {
"rewards": {
"coins": 285,
"exp": 71,
"seeds": [
{
"name": "胡萝卜",
"quantity": 2,
"quality": "普通"
}
]
},
"consecutive_days": 0,
"timestamp": 1750843274.268298
},
"2025-06-27": {
"rewards": {
"coins": 264,
"exp": 71,
"seeds": [
{
"name": "土豆",
"quantity": 3,
"quality": "普通"
}
]
},
"consecutive_days": 0,
"timestamp": 1750985100.9851904
}
},
"体力值": 20,
"体力上次刷新时间": "2025-07-09",
"体力上次恢复时间": 1752023968.6234932,
"体力上次刷新时间": "2025-07-12",
"体力上次恢复时间": 1752323298.9468062,
"new_player_gift_claimed": true,
"new_player_gift_time": "2025-06-08 20:58:40",
"daily_likes": {
@@ -971,6 +708,11 @@
"start_time": 1752023968.623608,
"claimed_gifts": {},
"total_online_time": 1282.0
},
"2025-07-12": {
"start_time": 1752323298.9470074,
"claimed_gifts": {},
"total_online_time": 623.0
}
},
"注册时间": "2025年05月21日15时00分00秒",
@@ -1083,12 +825,8 @@
}
}
],
"巡逻宠物": [
"1751716398095"
],
"出战宠物": [
"1751716398095"
],
"巡逻宠物": ["1751716398095"],
"出战宠物": ["1751716398095"],
"稻草人配置": {
"已拥有稻草人类型": [
"稻草人1"
@@ -1126,5 +864,8 @@
"最大经验值": 480,
"最大生命值": 106,
"当前生命值": 106
},
"签到历史": {
"2025年07月12日21时05分47秒": "金币249 经验75 土豆x3"
}
}