From 94f09b8dd98bc80d4e840af384ef8aabed67699a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=A0=91=E8=90=8C=E8=8A=BD?= <3205788256@qq.com>
Date: Tue, 27 May 2025 19:53:17 +0800
Subject: [PATCH] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E4=B8=89=E4=B8=AA=E6=8C=89?=
 =?UTF-8?q?=E9=92=AE=20=E4=BF=AE=E4=BA=86=E4=B8=80=E5=A0=86bug?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CopyItems/crop_item.tscn                      |   15 +-
 GUI/land_panel.gd                             |  190 +-
 GUI/login_panel.gd                            |   30 +-
 GUI/player_ranking_item.tscn                  |    1 +
 GUI/player_ranking_panel.gd                   |    4 -
 GlobalScript/Toast.gd                         |    2 +-
 MainGame.gd                                   |  205 +-
 MainGame.tscn                                 |   24 +-
 Network/TCPNetworkManager.gd                  |   61 +-
 Server/BugFix_UI_Update_Missing.md            |  241 ++
 Server/BugFix_VisitorMode_LastLoginTime.md    |  184 ++
 Server/Feature_RemoveCrop.md                  |  277 ++
 Server/Feature_Summary.md                     |  236 ++
 Server/JsonEdit/README.md                     |  100 -
 Server/JsonEdit/example_formats.md            |   65 -
 Server/JsonEdit/json_editor.py                |  267 --
 Server/JsonEdit/requirements.txt              |    2 -
 Server/JsonEdit/templates/json_editor.html    |  627 -----
 Server/New_Features_Test_Guide.md             |    1 +
 Server/QQEmailSend.zip                        |  Bin 58612 -> 0 bytes
 Server/README_Refactored.md                   |  175 ++
 Server/TCPGameServer.py                       | 2255 +++++++++--------
 .../__pycache__/TCPGameServer.cpython-313.pyc |  Bin 0 -> 49870 bytes
 Server/__pycache__/TCPGameServer.py           | 1569 ++++++++++++
 Server/config/crop_data.json.backup           |   32 -
 .../config/initial_player_data_template.json  |  122 +-
 Server/game_saves/2143323382.json             |  452 +---
 Server/game_saves/2143323382.json.backup      |  414 +++
 Server/game_saves/2221023030.json             |   67 +
 Server/game_saves/2221023030.json.backup      |  425 ++++
 Server/game_saves/2427948832.json             |   68 +
 Server/game_saves/2427948832.json.backup      |  430 ++++
 Server/game_saves/2634726358.json             |   67 +
 Server/game_saves/2634726358.json.backup      |  425 ++++
 Server/game_saves/2671387804.json             |   69 +
 Server/game_saves/2671387804.json.backup      |  435 ++++
 Server/game_saves/2809548669.json             |   64 +
 Server/game_saves/2809548669.json.backup      |  414 +++
 Server/game_saves/2973419538.json             |   68 +
 Server/game_saves/2973419538.json.backup      |  430 ++++
 Server/game_saves/3205788256.json.backup      |  986 +++++--
 Server/game_saves/3346964708.json             |   91 +
 Server/game_saves/3346964708.json.backup      |  545 ++++
 components/ToastShow.gd                       |    2 +-
 project.godot                                 |    1 +
 server/game_saves/3205788256.json             | 1150 +++++++--
 test_version_validation.md                    |  100 +
 47 files changed, 10303 insertions(+), 3085 deletions(-)
 create mode 100644 Server/BugFix_UI_Update_Missing.md
 create mode 100644 Server/BugFix_VisitorMode_LastLoginTime.md
 create mode 100644 Server/Feature_RemoveCrop.md
 create mode 100644 Server/Feature_Summary.md
 delete mode 100644 Server/JsonEdit/README.md
 delete mode 100644 Server/JsonEdit/example_formats.md
 delete mode 100644 Server/JsonEdit/json_editor.py
 delete mode 100644 Server/JsonEdit/requirements.txt
 delete mode 100644 Server/JsonEdit/templates/json_editor.html
 create mode 100644 Server/New_Features_Test_Guide.md
 delete mode 100644 Server/QQEmailSend.zip
 create mode 100644 Server/README_Refactored.md
 create mode 100644 Server/__pycache__/TCPGameServer.cpython-313.pyc
 create mode 100644 Server/__pycache__/TCPGameServer.py
 delete mode 100644 Server/config/crop_data.json.backup
 create mode 100644 Server/game_saves/2143323382.json.backup
 create mode 100644 Server/game_saves/2221023030.json
 create mode 100644 Server/game_saves/2221023030.json.backup
 create mode 100644 Server/game_saves/2427948832.json
 create mode 100644 Server/game_saves/2427948832.json.backup
 create mode 100644 Server/game_saves/2634726358.json
 create mode 100644 Server/game_saves/2634726358.json.backup
 create mode 100644 Server/game_saves/2671387804.json
 create mode 100644 Server/game_saves/2671387804.json.backup
 create mode 100644 Server/game_saves/2809548669.json
 create mode 100644 Server/game_saves/2809548669.json.backup
 create mode 100644 Server/game_saves/2973419538.json
 create mode 100644 Server/game_saves/2973419538.json.backup
 create mode 100644 Server/game_saves/3346964708.json
 create mode 100644 Server/game_saves/3346964708.json.backup
 create mode 100644 test_version_validation.md

diff --git a/CopyItems/crop_item.tscn b/CopyItems/crop_item.tscn
index 6736eb7..e606ee3 100644
--- a/CopyItems/crop_item.tscn
+++ b/CopyItems/crop_item.tscn
@@ -30,7 +30,7 @@ scale = Vector2(0.2, 0.2)
 theme_override_font_sizes/font_size = 50
 script = ExtResource("2_1n4xp")
 
-[node name="Label" type="Label" parent="."]
+[node name="crop_name" type="Label" parent="."]
 layout_mode = 2
 offset_right = 250.0
 offset_bottom = 42.0
@@ -40,3 +40,16 @@ theme_override_font_sizes/font_size = 30
 text = "[普通-胡萝卜]"
 horizontal_alignment = 1
 vertical_alignment = 1
+
+[node name="status_label" type="Label" parent="."]
+modulate = Color(0.721569, 1, 1, 1)
+layout_mode = 2
+offset_top = 17.0
+offset_right = 500.0
+offset_bottom = 86.0
+scale = Vector2(0.2, 0.2)
+size_flags_horizontal = 3
+theme_override_font_sizes/font_size = 50
+text = "已浇水 已施肥 等级:1"
+horizontal_alignment = 1
+vertical_alignment = 1
diff --git a/GUI/land_panel.gd b/GUI/land_panel.gd
index 7c5a61a..aacb5cf 100644
--- a/GUI/land_panel.gd
+++ b/GUI/land_panel.gd
@@ -31,7 +31,21 @@ func _ready():
 	plant_button.pressed.connect(self._on_plant_button_pressed)
 	remove_button.pressed.connect(self._on_remove_button_pressed)
 	harvest_button.pressed.connect(self._on_harvest_button_pressed)
-	dig_button.text = "开垦"+"\n花费："+str(main_game.dig_money)
+	
+	# 显示浇水、施肥、升级按钮
+	water_button.visible = true
+	fertilize_button.visible = true
+	upgrade_button.visible = true
+	
+	_update_button_texts()
+
+# 更新按钮文本
+func _update_button_texts():
+	dig_button.text = "开垦"+"\n￥"+str(main_game.dig_money)
+	remove_button.text = "铲除"+"\n￥500"
+	water_button.text = "浇水"+"\n￥50"
+	fertilize_button.text = "施肥"+"\n￥150"
+	upgrade_button.text = "升级"+"\n￥1000"
 
 #开垦
 func _on_dig_button_pressed():
@@ -41,12 +55,31 @@ func _on_dig_button_pressed():
 		self.hide()
 		return
 	
-	dig_button.text = "开垦"+"\n花费："+str(main_game.dig_money)
+	# 检查玩家金钱是否足够
+	var dig_cost = main_game.dig_money
+	if main_game.money < dig_cost:
+		Toast.show("金钱不足，开垦土地需要 " + str(dig_cost) + " 金钱", Color.RED, 2.0, 1.0)
+		self.hide()
+		return
 	
+	# 检查地块是否已经开垦
+	var lot = main_game.farm_lots[selected_lot_index]
+	if lot.get("is_diged", false):
+		Toast.show("此地块已经开垦过了", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 发送开垦土地请求到服务器
 	if network_manager and network_manager.is_connected_to_server():
-		# 使用服务器API来开垦土地
 		if network_manager.sendDigGround(selected_lot_index):
+			Toast.show("正在开垦土地...", Color.YELLOW, 1.5, 1.0)
 			self.hide()
+		else:
+			Toast.show("发送开垦请求失败", Color.RED, 2.0, 1.0)
+			self.hide()
+	else:
+		Toast.show("网络未连接，无法开垦土地", Color.RED, 2.0, 1.0)
+		self.hide()
 #浇水
 func _on_water_button_pressed():
 	# 检查是否处于访问模式
@@ -55,8 +88,49 @@ func _on_water_button_pressed():
 		self.hide()
 		return
 	
-	self.hide()
-	pass
+	# 检查玩家金钱是否足够
+	var water_cost = 50
+	if main_game.money < water_cost:
+		Toast.show("金钱不足，浇水需要 " + str(water_cost) + " 金钱", Color.RED, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查地块状态
+	var lot = main_game.farm_lots[selected_lot_index]
+	if not lot.get("is_planted", false) or lot.get("crop_type", "") == "":
+		Toast.show("此地块没有种植作物", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查作物是否已死亡
+	if lot.get("is_dead", false):
+		Toast.show("死亡的作物无法浇水", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查是否已经成熟
+	if lot.get("grow_time", 0) >= lot.get("max_grow_time", 1):
+		Toast.show("作物已经成熟，无需浇水", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查是否已经浇过水
+	if lot.get("已浇水", false):
+		Toast.show("今天已经浇过水了", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 发送浇水请求到服务器
+	if network_manager and network_manager.is_connected_to_server():
+		if network_manager.sendWaterCrop(selected_lot_index):
+			Toast.show("正在浇水...", Color.YELLOW, 1.5, 1.0)
+			self.hide()
+		else:
+			Toast.show("发送浇水请求失败", Color.RED, 2.0, 1.0)
+			self.hide()
+	else:
+		Toast.show("网络未连接，无法浇水", Color.RED, 2.0, 1.0)
+		self.hide()
 #施肥
 func _on_fertilize_button_pressed():
 	# 检查是否处于访问模式
@@ -65,8 +139,49 @@ func _on_fertilize_button_pressed():
 		self.hide()
 		return
 	
-	self.hide()
-	pass
+	# 检查玩家金钱是否足够
+	var fertilize_cost = 150
+	if main_game.money < fertilize_cost:
+		Toast.show("金钱不足，施肥需要 " + str(fertilize_cost) + " 金钱", Color.RED, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查地块状态
+	var lot = main_game.farm_lots[selected_lot_index]
+	if not lot.get("is_planted", false) or lot.get("crop_type", "") == "":
+		Toast.show("此地块没有种植作物", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查作物是否已死亡
+	if lot.get("is_dead", false):
+		Toast.show("死亡的作物无法施肥", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查是否已经成熟
+	if lot.get("grow_time", 0) >= lot.get("max_grow_time", 1):
+		Toast.show("作物已经成熟，无需施肥", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查是否已经施过肥
+	if lot.get("已施肥", false):
+		Toast.show("此作物已经施过肥了", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 发送施肥请求到服务器
+	if network_manager and network_manager.is_connected_to_server():
+		if network_manager.sendFertilizeCrop(selected_lot_index):
+			Toast.show("正在施肥...", Color.YELLOW, 1.5, 1.0)
+			self.hide()
+		else:
+			Toast.show("发送施肥请求失败", Color.RED, 2.0, 1.0)
+			self.hide()
+	else:
+		Toast.show("网络未连接，无法施肥", Color.RED, 2.0, 1.0)
+		self.hide()
 #升级
 func _on_upgrade_button_pressed():
 	# 检查是否处于访问模式
@@ -75,8 +190,38 @@ func _on_upgrade_button_pressed():
 		self.hide()
 		return
 	
-	self.hide()
-	pass
+	# 检查玩家金钱是否足够
+	var upgrade_cost = 1000
+	if main_game.money < upgrade_cost:
+		Toast.show("金钱不足，升级土地需要 " + str(upgrade_cost) + " 金钱", Color.RED, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查地块是否已开垦
+	var lot = main_game.farm_lots[selected_lot_index]
+	if not lot.get("is_diged", false):
+		Toast.show("此地块尚未开垦", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查土地是否已经升级
+	var current_level = lot.get("土地等级", 0)
+	if current_level >= 1:
+		Toast.show("此土地已经升级过了", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 发送升级请求到服务器
+	if network_manager and network_manager.is_connected_to_server():
+		if network_manager.sendUpgradeLand(selected_lot_index):
+			Toast.show("正在升级土地...", Color.YELLOW, 1.5, 1.0)
+			self.hide()
+		else:
+			Toast.show("发送升级请求失败", Color.RED, 2.0, 1.0)
+			self.hide()
+	else:
+		Toast.show("网络未连接，无法升级土地", Color.RED, 2.0, 1.0)
+		self.hide()
 #种植
 func _on_plant_button_pressed():
 	# 检查是否处于访问模式
@@ -96,8 +241,31 @@ func _on_remove_button_pressed():
 		self.hide()
 		return
 	
-	main_game.root_out_crop(selected_lot_index)
-	self.hide()
+	# 检查玩家金钱是否足够
+	var removal_cost = 500
+	if main_game.money < removal_cost:
+		Toast.show("金钱不足，铲除作物需要 " + str(removal_cost) + " 金钱", Color.RED, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 检查地块是否有作物
+	var lot = main_game.farm_lots[selected_lot_index]
+	if not lot.get("is_planted", false) or lot.get("crop_type", "") == "":
+		Toast.show("此地块没有种植作物", Color.ORANGE, 2.0, 1.0)
+		self.hide()
+		return
+	
+	# 发送铲除作物请求到服务器
+	if network_manager and network_manager.is_connected_to_server():
+		if network_manager.sendRemoveCrop(selected_lot_index):
+			Toast.show("正在铲除作物...", Color.YELLOW, 1.5, 1.0)
+			self.hide()
+		else:
+			Toast.show("发送铲除请求失败", Color.RED, 2.0, 1.0)
+			self.hide()
+	else:
+		Toast.show("网络未连接，无法铲除作物", Color.RED, 2.0, 1.0)
+		self.hide()
 	pass
 #收获
 func _on_harvest_button_pressed():
diff --git a/GUI/login_panel.gd b/GUI/login_panel.gd
index 16fe216..f9f5840 100644
--- a/GUI/login_panel.gd
+++ b/GUI/login_panel.gd
@@ -24,7 +24,7 @@ extends PanelContainer
 #状态提示标签
 @onready var status_label : Label = $VBox/status_label
 
-# 记住密码选项（如果UI中有CheckBox的话）
+# 记住密码选项
 var remember_password : bool = true  # 默认记住密码
 
 # 引用主场景和全局函数
@@ -45,6 +45,9 @@ func _ready():
 	
 	# 加载保存的登录信息
 	_load_login_info()
+	
+	# 显示客户端版本号
+	_display_version_info()
 
 # 处理登录按钮点击
 func _on_login_button_pressed():
@@ -86,7 +89,6 @@ func _on_login_button_pressed():
 	# 更新主游戏数据
 	main_game.user_name = user_name
 	main_game.user_password = user_password
-	main_game.farmname = farmname
 	
 	# 5秒后重新启用按钮（如果没有收到响应）
 	await get_tree().create_timer(5.0).timeout
@@ -156,6 +158,12 @@ func _on_register_button_pressed():
 	var player_name = playername_input.text.strip_edges()
 	var verification_code = verificationcode_input.text.strip_edges()
 	
+	# 检查密码格式（只允许数字和字母）
+	if not is_valid_password(user_password):
+		status_label.text = "密码只能包含数字和字母！"
+		status_label.modulate = Color.RED
+		return
+	
 	if user_name == "" or user_password == "":
 		status_label.text = "用户名或密码不能为空！"
 		status_label.modulate = Color.RED
@@ -178,7 +186,7 @@ func _on_register_button_pressed():
 		status_label.text = "请输入验证码！"
 		status_label.modulate = Color.RED
 		return
-	
+		
 	# 检查网络连接状态
 	if !tcp_network_manager.client.is_client_connected():
 		status_label.text = "未连接到服务器，正在尝试连接..."
@@ -248,6 +256,12 @@ func is_valid_qq_number(qq_number: String) -> bool:
 
 	return qq_regex.search(qq_number) != null
 
+# 添加密码验证函数
+func is_valid_password(password: String) -> bool:
+	# 使用正则表达式检查是否只包含数字和字母
+	var pattern = r"^[a-zA-Z0-9]+$"
+	return password.match(pattern) != null
+
 # 处理登录响应
 func _on_login_response_received(success: bool, message: String, user_data: Dictionary):
 	# 启用按钮
@@ -262,7 +276,8 @@ func _on_login_response_received(success: bool, message: String, user_data: Dict
 		main_game.farm_lots = user_data.get("farm_lots", [])
 		main_game.level = user_data.get("level", 1)
 		main_game.money = user_data.get("money", 0)
-		main_game.farmname = user_data.get("farm_name", "")
+		main_game.show_farm_name.text = "农场名称："+user_data.get("farm_name", "")
+		main_game.show_player_name.text = "玩家昵称："+user_data.get("player_name", "")
 		farmname_input.text = user_data.get("farm_name", "")
 		
 		# 加载玩家背包数据
@@ -431,3 +446,10 @@ func get_saved_username() -> String:
 			return login_data.get("user_name", "")
 	
 	return ""
+
+# 显示版本信息
+func _display_version_info():
+	# 在状态标签中显示客户端版本信息
+	if status_label.text == "欢迎使用萌芽农场" or status_label.text == "连接状态":
+		status_label.text = "萌芽农场 v" + main_game.client_version + " - 欢迎使用"
+		status_label.modulate = Color.CYAN
diff --git a/GUI/player_ranking_item.tscn b/GUI/player_ranking_item.tscn
index 28e5cb4..4731962 100644
--- a/GUI/player_ranking_item.tscn
+++ b/GUI/player_ranking_item.tscn
@@ -11,6 +11,7 @@ offset_bottom = 82.0
 layout_mode = 2
 
 [node name="SerialNumber" type="Label" parent="HBox"]
+visible = false
 layout_mode = 2
 theme_override_font_sizes/font_size = 30
 text = "1."
diff --git a/GUI/player_ranking_panel.gd b/GUI/player_ranking_panel.gd
index 2f8822a..b933d26 100644
--- a/GUI/player_ranking_panel.gd
+++ b/GUI/player_ranking_panel.gd
@@ -104,7 +104,3 @@ func _on_refresh_button_pressed():
 # 退出按钮点击
 func _on_quit_button_pressed():
 	self.hide()
-
-# 添加到main.gd中调用
-func _handle_player_rankings_response(data):
-	handle_player_rankings_response(data)
diff --git a/GlobalScript/Toast.gd b/GlobalScript/Toast.gd
index 91dfd04..53fc2b7 100644
--- a/GlobalScript/Toast.gd
+++ b/GlobalScript/Toast.gd
@@ -3,7 +3,7 @@ extends Node
 
 const ToastScene = preload("res://components/ToastShow.tscn")
 
-static func show(text: String, 
+func show(text: String, 
 				color: Color = Color.WHITE,
 				duration: float = 3.0,
 				fade: float = 1.0) -> void:
diff --git a/MainGame.gd b/MainGame.gd
index 834bf88..428e331 100644
--- a/MainGame.gd
+++ b/MainGame.gd
@@ -12,14 +12,13 @@ extends Node
 @onready var show_player_name : Label =  $UI/GUI/HBox2/player_name	# 显示玩家昵称
 @onready var show_farm_name : Label = $UI/GUI/HBox2/farm_name		# 显示农场名称
 @onready var show_status_label : Label = $UI/GUI/HBox2/StatusLabel	# 显示与服务器连接状态
-
 @onready var network_status_label :Label = get_node("/root/main/UI/TCPNetworkManager/StatusLabel")
-@onready var network_manager = get_node("/root/main/UI/TCPNetworkManager")
+@onready var return_my_farm_button: Button = $UI/GUI/VBox/ReturnMyFarmButton
+
+
+@onready var crop_grid_container : GridContainer = $UI/CropStorePanel/ScrollContainer/Crop_Grid #种子商店格子
+@onready var player_bag_grid_container : GridContainer = $UI/PlayerBagPanel/ScrollContainer/Bag_Grid #玩家背包格子
 
-#种子商店格子
-@onready var crop_grid_container : GridContainer = $UI/CropStorePanel/ScrollContainer/Crop_Grid
-#玩家背包格子
-@onready var player_bag_grid_container : GridContainer = $UI/PlayerBagPanel/ScrollContainer/Bag_Grid
 #作物品质按钮
 @onready var green_bar : Button = $CopyNodes/GreenCrop				#普通
 @onready var white_blue_bar : Button = $CopyNodes/WhiteBlueCrop		#稀有
@@ -33,10 +32,10 @@ extends Node
 @onready var login_panel : PanelContainer = $UI/LoginPanel#登录注册面板
 @onready var crop_store_panel : Panel = $UI/CropStorePanel#种子商店面板
 @onready var player_bag_panel : Panel = $UI/PlayerBagPanel#玩家背包面板
-@onready var TCPNerworkManager : Panel = $UI/TCPNetworkManager#网络管理器
+@onready var network_manager : Panel = $UI/TCPNetworkManager#网络管理器
 @onready var player_ranking_panel : Panel = $UI/PlayerRankingPanel#玩家排行榜面板
 
-@onready var return_my_farm_button: Button = $UI/GUI/VBox/ReturnMyFarmButton
+
 
 var money: int = 500  # 默认每个人初始为100元
 var experience: float = 0.0  # 初始每个玩家的经验为0
@@ -48,7 +47,6 @@ var dig_money : int = 1000 #开垦费用
 #临时变量
 var user_name : String = ""
 var user_password : String = ""
-var farmname : String = ""
 var login_data : Dictionary = {}
 var data : Dictionary = {}
 var buttons : Array = []
@@ -75,16 +73,13 @@ var visited_player_data : Dictionary = {}  # 被访问玩家的数据
 var crop_textures_cache : Dictionary = {}  # 缓存已加载的作物图片
 var crop_frame_counts : Dictionary = {}  # 记录每种作物的帧数
 
+const client_version :String = "1.0.1" #记录客户端版本
 
 
-#-------------Godot自带方法-----------------
-func _on_quit_button_pressed():
-	player_bag_panel.hide()
-	pass 
-
 
 # 准备阶段
 func _ready():
+	print("萌芽农场客户端 v" + client_version + " 启动")
 	_update_ui()
 	_create_farm_buttons() # 创建地块按钮
 	_update_farm_lots_state() # 初始更新地块状态
@@ -105,8 +100,7 @@ func _ready():
 	player_bag_panel.hide()
 	
 	# 启动后稍等片刻尝试从服务器获取最新数据
-	var timer = get_tree().create_timer(0.5)
-	await timer.timeout
+	await get_tree().create_timer(0.5).timeout
 	_try_load_from_server()
 
 #每时每刻都更新
@@ -115,8 +109,9 @@ func _physics_process(delta):
 	update_timer += delta
 	if update_timer >= update_interval:
 		update_timer = 0.0  # 重置计时器
+		
 		#同步网络管理器的状态
-		show_status_label.text = network_status_label.text
+		show_status_label.text = "服务器状态："+network_status_label.text
 		show_status_label.modulate = network_status_label.modulate
 		
 		if start_game == true:
@@ -131,21 +126,47 @@ func _physics_process(delta):
 				pass
 			pass
 
+func _on_open_store_button_pressed():
+	# 如果处于访问模式，不允许打开商店
+	if is_visiting_mode:
+		Toast.show("访问模式下无法使用商店", Color.ORANGE)
+		return
+	
+	# 确保商店面板已初始化
+	crop_store_panel.init_store()
+	# 显示商店面板
+	crop_store_panel.show()
+	# 确保在最前面显示
+	crop_store_panel.move_to_front() 
+	pass
+
+func _on_player_ranking_button_pressed() -> void:
+	player_ranking_panel.show()
+	pass 
+	
+func _on_return_my_farm_button_pressed() -> void:
+	# 如果当前处于访问模式，返回自己的农场
+	if is_visiting_mode:
+		return_to_my_farm()
+	else:
+		# 如果不在访问模式，这个按钮可能用于其他功能或者不做任何操作
+		print("当前已在自己的农场")
+
+
+
+
 
 # 处理服务器作物更新消息
 func _handle_crop_update(update_data):
 	# 检查是否是访问模式的更新
 	var is_visiting_update = update_data.get("is_visiting", false)
-	var visited_player = update_data.get("visited_player", "")
 	
 	if is_visiting_update and is_visiting_mode:
 		# 访问模式下的更新，更新被访问玩家的农场数据
 		farm_lots = update_data["farm_lots"]
-		print("收到访问模式下的作物更新，被访问玩家：", visited_player)
 	elif not is_visiting_update and not is_visiting_mode:
 		# 正常模式下的更新，更新自己的农场数据
 		farm_lots = update_data["farm_lots"]
-		print("收到自己农场的作物更新")
 	else:
 		# 状态不匹配，忽略更新
 		print("忽略不匹配的作物更新，当前访问模式：", is_visiting_mode, "，更新类型：", is_visiting_update)
@@ -220,18 +241,74 @@ func _handle_action_response(response_data):
 				Toast.show(message, Color.GREEN)
 			else:
 				Toast.show(message, Color.RED)
+				
+		"remove_crop":
+			if success:
+				# 更新玩家数据
+				if updated_data.has("money"):
+					money = updated_data["money"]
+				if updated_data.has("farm_lots"):
+					farm_lots = updated_data["farm_lots"]
+				
+				# 更新UI
+				_update_ui()
+				_update_farm_lots_state()
+				Toast.show(message, Color.GREEN)
+			else:
+				Toast.show(message, Color.RED)
+
+		"water_crop":
+			if success:
+				# 更新玩家数据
+				if updated_data.has("money"):
+					money = updated_data["money"]
+				if updated_data.has("farm_lots"):
+					farm_lots = updated_data["farm_lots"]
+				
+				# 更新UI
+				_update_ui()
+				_update_farm_lots_state()
+				Toast.show(message, Color.CYAN)
+			else:
+				Toast.show(message, Color.RED)
+				
+		"fertilize_crop":
+			if success:
+				# 更新玩家数据
+				if updated_data.has("money"):
+					money = updated_data["money"]
+				if updated_data.has("farm_lots"):
+					farm_lots = updated_data["farm_lots"]
+				
+				# 更新UI
+				_update_ui()
+				_update_farm_lots_state()
+				Toast.show(message, Color.PURPLE)
+			else:
+				Toast.show(message, Color.RED)
+				
+		"upgrade_land":
+			if success:
+				# 更新玩家数据
+				if updated_data.has("money"):
+					money = updated_data["money"]
+				if updated_data.has("farm_lots"):
+					farm_lots = updated_data["farm_lots"]
+				
+				# 更新UI
+				_update_ui()
+				_update_farm_lots_state()
+				Toast.show(message, Color.GOLD)
+			else:
+				Toast.show(message, Color.RED)
 
 # 处理玩家排行榜响应
 func _handle_player_rankings_response(data):
-	if player_ranking_panel and player_ranking_panel.has_method("_handle_player_rankings_response"):
-		player_ranking_panel._handle_player_rankings_response(data)
+	player_ranking_panel.handle_player_rankings_response(data)
 
 # 处理玩家游玩时间响应
 func _handle_play_time_response(data):
-	# 如果需要在主游戏中处理游玩时间，可以在这里添加代码
-	# 目前只是将响应转发给排行榜面板
-	if player_ranking_panel and player_ranking_panel.has_method("handle_play_time_response"):
-		player_ranking_panel.handle_play_time_response(data)
+	player_ranking_panel.handle_play_time_response(data)
 
 # 处理访问玩家响应
 func _handle_visit_player_response(data):
@@ -334,12 +411,9 @@ func _handle_return_my_farm_response(data):
 		Toast.show("返回农场失败：" + message, Color.RED)
 		print("返回农场失败：", message)
 
-#-------------Godot自带方法-----------------
 
 
 
-#-------------自定义方法-----------------
-
 #创建作物按钮
 func _create_crop_button(crop_name: String, crop_quality: String) -> Button:
 	# 根据品质选择相应的进度条
@@ -372,21 +446,6 @@ func _create_crop_button(crop_name: String, crop_quality: String) -> Button:
 	
 	return button
 
-# 打开商店按钮处理函数 
-func _on_open_store_button_pressed():
-	# 如果处于访问模式，不允许打开商店
-	if is_visiting_mode:
-		Toast.show("访问模式下无法使用商店", Color.ORANGE)
-		return
-	
-	# 确保商店面板已初始化
-	crop_store_panel.init_store()
-	# 显示商店面板
-	crop_store_panel.show()
-	# 确保在最前面显示
-	crop_store_panel.move_to_front() 
-	pass
-
 
 
 # 初始化农场地块按钮 - 只在游戏开始时调用一次
@@ -421,7 +480,8 @@ func _update_farm_lots_state():
 			
 		var lot = farm_lots[i]
 		var button = grid_container.get_child(i)
-		var label = button.get_node("Label")
+		var label = button.get_node("crop_name")
+		var status_label = button.get_node("status_label")
 		var progressbar = button.get_node("ProgressBar")
 
 		# 更新作物图片
@@ -437,7 +497,21 @@ func _update_farm_lots_state():
 				else:
 					# 正常生长逻辑
 					var crop_name = lot["crop_type"]
-					label.text = "[" + can_planted_crop[crop_name]["品质"] + "-" + lot["crop_type"] + "]"
+					label.text = "[" + can_planted_crop[crop_name]["品质"] + "-" + lot["crop_type"] +"]"
+					var status_text = ""
+					# 添加状态标识
+					var status_indicators = []
+					if lot.get("已浇水", false):
+						status_indicators.append("已浇水")#💧
+					if lot.get("已施肥", false):
+						status_indicators.append("已施肥")#🌱
+					if lot.get("土地等级", 0) >= 1:
+						status_indicators.append("等级:1")#⭐
+					
+					if status_indicators.size() > 0:
+						status_text += " " + " ".join(status_indicators)
+					status_label.text = status_text
+					
 					# 根据品质显示颜色
 					match can_planted_crop[crop_name]["品质"]:
 						"普通":
@@ -456,8 +530,13 @@ func _update_farm_lots_state():
 					progressbar.value = int(lot["grow_time"]) # 直接设置值，不使用动画
 			else:
 				# 已开垦但未种植的地块显示为空地
+				var land_text = "[空地"
+				if lot.get("土地等级", 0) >= 1:
+					status_label.text = "等级:1"
+				land_text += "]"
+				
 				label.modulate = Color.GREEN#绿色
-				label.text = "[" + "空地" + "]"
+				label.text = land_text
 				progressbar.hide()
 
 		else:
@@ -493,6 +572,9 @@ func _on_item_selected(index):
 	land_panel.show()
 	land_panel.selected_lot_index = index
 	selected_lot_index = index
+	# 更新按钮文本
+	if land_panel.has_method("_update_button_texts"):
+		land_panel._update_button_texts()
 
 # 处理访问模式下的地块点击事件
 func _on_visit_item_selected(index):
@@ -538,17 +620,7 @@ func _harvest_crop(index):
 		Toast.show("作物还未成熟", Color.RED)
 
 
-#铲除已死亡作物
-func root_out_crop(index):
-	var lot = farm_lots[index]
-	lot["is_planted"] = false
-	lot["grow_time"] = 0
-	Toast.show("从地块[" + str(index) + "]铲除了[" + lot["crop_type"] + "]作物", Color.YELLOW)
-	lot["crop_type"] = ""
-	_check_level_up()
-	_update_ui()
-	_update_farm_lots_state()
-	pass
+
 
 
 # 检查玩家是否可以升级
@@ -562,23 +634,6 @@ func _check_level_up():
 		crop_store_panel.init_store()
 
 
-
-
-#-------------自定义方法----------------
-
-
-func _on_player_ranking_button_pressed() -> void:
-	player_ranking_panel.show()
-	pass 
-	
-func _on_return_my_farm_button_pressed() -> void:
-	# 如果当前处于访问模式，返回自己的农场
-	if is_visiting_mode:
-		return_to_my_farm()
-	else:
-		# 如果不在访问模式，这个按钮可能用于其他功能或者不做任何操作
-		print("当前已在自己的农场")
-
 # 返回自己的农场
 func return_to_my_farm():
 	if not is_visiting_mode:
diff --git a/MainGame.tscn b/MainGame.tscn
index 692e6e9..0fa0c47 100644
--- a/MainGame.tscn
+++ b/MainGame.tscn
@@ -49,7 +49,7 @@ expand_mode = 2
 modulate = Color(1, 0.670588, 0.490196, 1)
 layout_mode = 2
 theme_override_font_sizes/font_size = 30
-text = "树萌芽"
+text = "玩家昵称：树萌芽"
 
 [node name="farm_name_image" type="TextureRect" parent="UI/GUI/HBox2"]
 layout_mode = 2
@@ -60,7 +60,7 @@ expand_mode = 3
 modulate = Color(1, 0.858824, 0.623529, 1)
 layout_mode = 2
 theme_override_font_sizes/font_size = 30
-text = "树萌芽的农场"
+text = "农场名称：树萌芽的农场"
 
 [node name="status_label_image" type="TextureRect" parent="UI/GUI/HBox2"]
 layout_mode = 2
@@ -304,7 +304,6 @@ text = "连接状态"
 horizontal_alignment = 1
 
 [node name="LandPanel" type="Panel" parent="UI"]
-visible = false
 offset_left = 475.0
 offset_top = 145.0
 offset_right = 991.0
@@ -344,53 +343,49 @@ columns = 5
 modulate = Color(1, 0.419608, 0.352941, 1)
 custom_minimum_size = Vector2(100, 100)
 layout_mode = 2
-theme_override_font_sizes/font_size = 30
+theme_override_font_sizes/font_size = 20
 text = "开垦"
 
 [node name="Plant_Button" type="Button" parent="UI/LandPanel/Grid"]
 modulate = Color(1, 0.682353, 0, 1)
 custom_minimum_size = Vector2(100, 100)
 layout_mode = 2
-theme_override_font_sizes/font_size = 30
+theme_override_font_sizes/font_size = 20
 text = "种植"
 
 [node name="Remove_Button" type="Button" parent="UI/LandPanel/Grid"]
-visible = false
 modulate = Color(1, 1, 0, 1)
 custom_minimum_size = Vector2(100, 100)
 layout_mode = 2
-theme_override_font_sizes/font_size = 30
+theme_override_font_sizes/font_size = 20
 text = "铲除"
 
 [node name="Harvest_Button" type="Button" parent="UI/LandPanel/Grid"]
 modulate = Color(0.223529, 1, 0.290196, 1)
 custom_minimum_size = Vector2(100, 100)
 layout_mode = 2
-theme_override_font_sizes/font_size = 30
+theme_override_font_sizes/font_size = 20
 text = "收获"
 
 [node name="Water_Button" type="Button" parent="UI/LandPanel/Grid"]
-visible = false
 modulate = Color(0, 1, 1, 1)
 custom_minimum_size = Vector2(100, 100)
 layout_mode = 2
-theme_override_font_sizes/font_size = 30
+theme_override_font_sizes/font_size = 20
 text = "浇水"
 
 [node name="Fertilize_Button" type="Button" parent="UI/LandPanel/Grid"]
-visible = false
 modulate = Color(0.592157, 0.337255, 1, 1)
 custom_minimum_size = Vector2(80, 80)
 layout_mode = 2
-theme_override_font_sizes/font_size = 30
+theme_override_font_sizes/font_size = 20
 text = "施肥"
 
 [node name="Upgrade_Button" type="Button" parent="UI/LandPanel/Grid"]
-visible = false
 modulate = Color(0.0784314, 0.470588, 1, 1)
 custom_minimum_size = Vector2(100, 100)
 layout_mode = 2
-theme_override_font_sizes/font_size = 30
+theme_override_font_sizes/font_size = 20
 text = "升级"
 
 [node name="PlayerRankingPanel" type="Panel" parent="UI"]
@@ -741,4 +736,3 @@ bounds_max = Vector2(500, 500)
 [connection signal="pressed" from="UI/GUI/VBox/OpenStoreButton" to="." method="_on_open_store_button_pressed"]
 [connection signal="pressed" from="UI/GUI/VBox/PlayerRankingButton" to="." method="_on_player_ranking_button_pressed"]
 [connection signal="pressed" from="UI/CropStorePanel/QuitButton" to="." method="_on_quit_button_pressed"]
-[connection signal="pressed" from="UI/PlayerBagPanel/QuitButton" to="." method="_on_quit_button_pressed"]
diff --git a/Network/TCPNetworkManager.gd b/Network/TCPNetworkManager.gd
index e1ed281..5bc979a 100644
--- a/Network/TCPNetworkManager.gd
+++ b/Network/TCPNetworkManager.gd
@@ -17,9 +17,9 @@ var client: TCPClient = TCPClient.new()
 
 # 服务器配置 - 支持多个服务器地址
 var server_configs = [
-	#{"host": "127.0.0.1", "port": 4040, "name": "本地服务器"},
+	{"host": "127.0.0.1", "port": 4040, "name": "本地服务器"},
 	#{"host": "192.168.1.110", "port": 4040, "name": "局域网服务器"},
-	{"host": "47.108.90.0", "port": 4040, "name": "公网服务器"}#成都内网穿透
+	#{"host": "47.108.90.0", "port": 4040, "name": "公网服务器"}#成都内网穿透
 ]
 
 var current_server_index = 0
@@ -94,9 +94,6 @@ func _on_data_received(data):
 				"ping":	
 					return
 				"response":
-					# 显示服务器响应
-					if data.has("original"):
-						var original = data.get("original", {})
 					return
 				"login_response":
 					# 处理登录响应
@@ -196,7 +193,8 @@ func sendLoginInfo(username, password):
 	client.send_data({
 		"type": "login",
 		"username": username,
-		"password": password
+		"password": password,
+		"client_version": main_game.client_version
 	})
 
 #发送注册信息
@@ -207,7 +205,8 @@ func sendRegisterInfo(username, password, farmname, player_name="", verification
 		"password": password,
 		"farm_name": farmname,
 		"player_name": player_name,
-		"verification_code": verification_code
+		"verification_code": verification_code,
+		"client_version": main_game.client_version
 	})
 
 #发送收获作物信息
@@ -247,6 +246,18 @@ func sendDigGround(lot_index):
 	})
 	return true
 
+#发送铲除作物信息
+func sendRemoveCrop(lot_index):
+	if not client.is_client_connected():
+		return false
+		
+	client.send_data({
+		"type": "remove_crop",
+		"lot_index": lot_index,
+		"timestamp": Time.get_unix_time_from_system()
+	})
+	return true
+
 #发送购买种子信息
 func sendBuySeed(crop_name):
 	if not client.is_client_connected():
@@ -347,6 +358,42 @@ func sendReturnMyFarm():
 	})
 	return true
 
+#发送浇水作物信息
+func sendWaterCrop(lot_index):
+	if not client.is_client_connected():
+		return false
+		
+	client.send_data({
+		"type": "water_crop",
+		"lot_index": lot_index,
+		"timestamp": Time.get_unix_time_from_system()
+	})
+	return true
+
+#发送施肥作物信息
+func sendFertilizeCrop(lot_index):
+	if not client.is_client_connected():
+		return false
+		
+	client.send_data({
+		"type": "fertilize_crop",
+		"lot_index": lot_index,
+		"timestamp": Time.get_unix_time_from_system()
+	})
+	return true
+
+#发送升级土地信息
+func sendUpgradeLand(lot_index):
+	if not client.is_client_connected():
+		return false
+		
+	client.send_data({
+		"type": "upgrade_land",
+		"lot_index": lot_index,
+		"timestamp": Time.get_unix_time_from_system()
+	})
+	return true
+
 #检查是否连接到服务器
 func is_connected_to_server():
 	return client.is_client_connected()
diff --git a/Server/BugFix_UI_Update_Missing.md b/Server/BugFix_UI_Update_Missing.md
new file mode 100644
index 0000000..f8a3e6f
--- /dev/null
+++ b/Server/BugFix_UI_Update_Missing.md
@@ -0,0 +1,241 @@
+# Bug修复：开垦和铲除操作UI更新缺失
+
+## 问题描述
+
+在开垦土地和铲除作物操作完成后，客户端的UI没有正确更新，具体表现为：
+
+1. **金钱数量不更新**：操作完成后，显示的金钱数量仍然是操作前的数值
+2. **等级和经验不更新**：如果操作导致等级或经验变化，UI没有反映
+3. **地块状态不同步**：虽然服务器数据已更新，但客户端显示可能不一致
+
+## 问题根源
+
+### 原始问题分析
+
+客户端的 `_handle_action_response()` 方法只处理了以下操作类型：
+- `harvest_crop` - 收获作物 ✅
+- `plant_crop` - 种植作物 ✅  
+- `buy_seed` - 购买种子 ✅
+- `dig_ground` - 开垦土地 ✅
+
+但是缺少了：
+- `remove_crop` - 铲除作物 ❌
+
+### 代码问题位置
+
+```gdscript
+# MainGame.gd 中的 _handle_action_response 方法
+func _handle_action_response(response_data):
+    var action_type = response_data.get("action_type", "")
+    var success = response_data.get("success", false)
+    var message = response_data.get("message", "")
+    var updated_data = response_data.get("updated_data", {})
+    
+    match action_type:
+        "harvest_crop":
+            # 处理收获响应 ✅
+        "plant_crop":
+            # 处理种植响应 ✅
+        "buy_seed":
+            # 处理购买响应 ✅
+        "dig_ground":
+            # 处理开垦响应 ✅
+        # 缺少 "remove_crop" 的处理 ❌
+```
+
+## 修复方案
+
+### 1. 添加铲除作物响应处理
+
+在 `MainGame.gd` 的 `_handle_action_response()` 方法中添加对 `remove_crop` 操作的处理：
+
+```gdscript
+"remove_crop":
+    if success:
+        # 更新玩家数据
+        if updated_data.has("money"):
+            money = updated_data["money"]
+        if updated_data.has("farm_lots"):
+            farm_lots = updated_data["farm_lots"]
+        
+        # 更新UI
+        _update_ui()
+        _update_farm_lots_state()
+        Toast.show(message, Color.GREEN)
+    else:
+        Toast.show(message, Color.RED)
+```
+
+### 2. 优化客户端预验证
+
+为了提供更好的用户体验，在 `land_panel.gd` 中添加了更完善的预验证：
+
+#### 开垦操作预验证
+```gdscript
+# 检查玩家金钱是否足够
+var dig_cost = main_game.dig_money
+if main_game.money < dig_cost:
+    Toast.show("金钱不足，开垦土地需要 " + str(dig_cost) + " 金钱", Color.RED, 2.0, 1.0)
+    self.hide()
+    return
+
+# 检查地块是否已经开垦
+var lot = main_game.farm_lots[selected_lot_index]
+if lot.get("is_diged", false):
+    Toast.show("此地块已经开垦过了", Color.ORANGE, 2.0, 1.0)
+    self.hide()
+    return
+```
+
+#### 铲除操作预验证
+```gdscript
+# 检查玩家金钱是否足够
+var removal_cost = 500
+if main_game.money < removal_cost:
+    Toast.show("金钱不足，铲除作物需要 " + str(removal_cost) + " 金钱", Color.RED, 2.0, 1.0)
+    self.hide()
+    return
+
+# 检查地块是否有作物
+var lot = main_game.farm_lots[selected_lot_index]
+if not lot.get("is_planted", false) or lot.get("crop_type", "") == "":
+    Toast.show("此地块没有种植作物", Color.ORANGE, 2.0, 1.0)
+    self.hide()
+    return
+```
+
+### 3. 移除不必要的UI更新调用
+
+移除了 `land_panel.gd` 中不必要的 `main_game._update_ui()` 调用，因为服务器响应会统一处理UI更新。
+
+## 修复效果
+
+### 修复前的问题
+1. **开垦土地后**：
+   - 金钱显示：1000元 → 1000元 ❌ (实际应该减少)
+   - 地块状态：可能不同步
+   - 用户体验：困惑，不知道操作是否成功
+
+2. **铲除作物后**：
+   - 金钱显示：1000元 → 1000元 ❌ (实际应该减少500)
+   - 地块状态：可能显示仍有作物
+   - 用户体验：需要刷新页面才能看到变化
+
+### 修复后的正确行为
+1. **开垦土地后**：
+   - 金钱显示：1000元 → 0元 ✅ (正确扣除1000)
+   - 地块状态：立即显示为已开垦 ✅
+   - 用户体验：即时反馈，操作流畅
+
+2. **铲除作物后**：
+   - 金钱显示：1000元 → 500元 ✅ (正确扣除500)
+   - 地块状态：立即显示为空地 ✅
+   - 用户体验：即时反馈，操作流畅
+
+## 数据流程
+
+### 完整的操作流程
+1. **客户端预验证** → 检查金钱、地块状态等
+2. **发送请求** → 向服务器发送操作请求
+3. **服务器处理** → 验证并执行操作，更新数据
+4. **服务器响应** → 返回操作结果和更新后的数据
+5. **客户端处理响应** → 更新本地数据和UI显示
+6. **UI更新** → 刷新金钱、经验、地块状态等显示
+
+### 数据同步机制
+```gdscript
+# 服务器响应处理
+if success:
+    # 1. 更新本地数据
+    if updated_data.has("money"):
+        money = updated_data["money"]
+    if updated_data.has("farm_lots"):
+        farm_lots = updated_data["farm_lots"]
+    
+    # 2. 刷新UI显示
+    _update_ui()                # 更新金钱、经验、等级显示
+    _update_farm_lots_state()   # 更新地块状态显示
+    
+    # 3. 显示成功提示
+    Toast.show(message, Color.GREEN)
+```
+
+## 测试验证
+
+### 测试用例1：开垦土地UI更新
+1. 玩家有1000金钱
+2. 点击未开垦地块，选择开垦
+3. 操作成功后检查：
+   - 金钱显示是否减少1000 ✅
+   - 地块是否显示为已开垦 ✅
+   - 是否显示成功提示 ✅
+
+### 测试用例2：铲除作物UI更新
+1. 玩家有1000金钱，地块有作物
+2. 点击地块，选择铲除
+3. 操作成功后检查：
+   - 金钱显示是否减少500 ✅
+   - 地块是否显示为空地 ✅
+   - 是否显示成功提示 ✅
+
+### 测试用例3：操作失败时的UI状态
+1. 玩家金钱不足
+2. 尝试进行开垦或铲除操作
+3. 检查：
+   - UI数据不应该改变 ✅
+   - 显示错误提示 ✅
+   - 操作被正确阻止 ✅
+
+### 测试用例4：网络异常时的处理
+1. 断开网络连接
+2. 尝试进行操作
+3. 检查：
+   - 显示网络错误提示 ✅
+   - UI状态保持不变 ✅
+   - 不发送无效请求 ✅
+
+## 代码改进点
+
+### 1. 统一的响应处理
+所有游戏操作现在都有统一的响应处理机制：
+- 成功时更新数据和UI
+- 失败时显示错误信息
+- 保持数据一致性
+
+### 2. 改进的用户体验
+- 添加了操作进行中的提示（"正在开垦土地..."）
+- 提供了详细的错误信息
+- 即时的UI反馈
+
+### 3. 更好的错误处理
+- 客户端预验证减少无效请求
+- 网络错误的友好提示
+- 服务器错误的正确显示
+
+## 防止类似问题的建议
+
+### 1. 代码审查检查点
+- 新增操作类型时，确保在 `_handle_action_response` 中添加对应处理
+- 检查所有UI更新是否通过统一的响应处理机制
+- 验证客户端和服务器的数据同步
+
+### 2. 测试覆盖
+- 为每个新操作添加UI更新测试用例
+- 测试成功和失败场景的UI表现
+- 验证网络异常情况下的行为
+
+### 3. 开发规范
+- 所有游戏操作都应该通过服务器处理
+- 客户端只做预验证和UI更新
+- 保持数据流的一致性
+
+## 总结
+
+这个bug修复确保了：
+- ✅ **数据一致性**：客户端UI与服务器数据保持同步
+- ✅ **用户体验**：操作后立即看到结果反馈
+- ✅ **错误处理**：完善的错误提示和状态管理
+- ✅ **代码质量**：统一的响应处理机制
+- ✅ **可维护性**：清晰的数据流和处理逻辑
+
+通过这个修复，玩家在进行开垦和铲除操作时将获得与收获作物操作一致的流畅体验。 
\ No newline at end of file
diff --git a/Server/BugFix_VisitorMode_LastLoginTime.md b/Server/BugFix_VisitorMode_LastLoginTime.md
new file mode 100644
index 0000000..298a9dd
--- /dev/null
+++ b/Server/BugFix_VisitorMode_LastLoginTime.md
@@ -0,0 +1,184 @@
+# Bug修复：访客模式下最后登录时间错误更新
+
+## 问题描述
+
+在原始代码中，当玩家处于访客模式访问其他玩家的农场时，被访问玩家的最后登录时间会被意外更新。这是一个严重的数据完整性问题，因为：
+
+1. **数据不准确**：被访问玩家实际上没有登录，但最后登录时间被更新了
+2. **逻辑错误**：只有玩家真正登录时，最后登录时间才应该被更新
+3. **影响统计**：这会影响玩家活跃度统计和排行榜数据的准确性
+
+## 问题根源
+
+### 原始问题代码
+
+```python
+def update_crops_growth(self):
+    """更新所有玩家的作物生长状态"""
+    # 获取所有玩家存档文件
+    save_files = glob.glob(os.path.join("game_saves", "*.json"))
+    
+    for save_file in save_files:
+        try:
+            # 从文件名提取账号ID
+            account_id = os.path.basename(save_file).split('.')[0]
+            
+            # 加载玩家数据
+            player_data = self.load_player_data(account_id)
+            # ... 更新作物生长状态 ...
+            
+            # 如果有作物更新，保存玩家数据
+            if growth_updated:
+                self.save_player_data(account_id, player_data)  # 问题在这里！
+```
+
+**问题分析：**
+- 系统遍历所有玩家存档文件，包括离线玩家
+- 当保存玩家数据时，可能会触发其他逻辑更新最后登录时间
+- 访客模式下，被访问玩家的数据被加载和保存，导致时间戳更新
+
+## 修复方案
+
+### 1. 只更新在线玩家的作物生长状态
+
+```python
+def update_crops_growth(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 growth_updated:
+                self.save_player_data(username, player_data)
+```
+
+**修复要点：**
+- ✅ 只遍历在线玩家（`self.user_data`）
+- ✅ 检查玩家登录状态（`logged_in: True`）
+- ✅ 避免处理离线玩家的数据
+
+### 2. 优化访客模式的数据推送
+
+```python
+def _push_crop_update_to_player(self, account_id, player_data):
+    # ... 现有代码 ...
+    
+    if visiting_mode and visiting_target:
+        # 如果处于访问模式，发送被访问玩家的更新数据
+        # 注意：这里只读取数据，不修改被访问玩家的数据
+        target_player_data = self.load_player_data(visiting_target)
+        if target_player_data:
+            # 检查被访问玩家是否也在线
+            target_client_id = None
+            for cid, user_info in self.user_data.items():
+                if user_info.get("username") == visiting_target and user_info.get("logged_in", False):
+                    target_client_id = cid
+                    break
+            
+            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  # 新增：标记被访问玩家是否在线
+            }
+```
+
+**优化要点：**
+- ✅ 明确标注只读取数据，不修改
+- ✅ 检查被访问玩家是否在线
+- ✅ 提供在线状态信息给客户端
+
+## 修复效果
+
+### 修复前的问题
+1. **错误场景**：
+   - 玩家A访问玩家B的农场
+   - 系统更新所有玩家的作物生长状态
+   - 玩家B的数据被加载、修改、保存
+   - 玩家B的最后登录时间被意外更新
+
+2. **数据污染**：
+   ```
+   玩家B实际最后登录：2024-01-01 10:00:00
+   被访问后错误更新为：2024-01-02 15:30:00  ❌ 错误！
+   ```
+
+### 修复后的正确行为
+1. **正确场景**：
+   - 玩家A访问玩家B的农场
+   - 系统只更新在线玩家（玩家A）的作物生长状态
+   - 玩家B的数据只被读取，不被修改
+   - 玩家B的最后登录时间保持不变
+
+2. **数据准确**：
+   ```
+   玩家B实际最后登录：2024-01-01 10:00:00
+   访问后仍然保持：2024-01-01 10:00:00  ✅ 正确！
+   ```
+
+## 测试验证
+
+### 测试用例1：访客模式数据完整性
+1. 玩家A登录游戏
+2. 玩家A访问离线玩家B的农场
+3. 等待作物生长更新周期
+4. 检查玩家B的最后登录时间是否保持不变
+
+**预期结果**：玩家B的最后登录时间不应该改变
+
+### 测试用例2：在线玩家正常更新
+1. 玩家A和玩家B都在线
+2. 玩家A访问玩家B的农场
+3. 等待作物生长更新周期
+4. 检查两个玩家的作物是否正常生长
+
+**预期结果**：两个玩家的作物都应该正常生长
+
+### 测试用例3：离线玩家数据保护
+1. 确保有离线玩家的存档文件
+2. 在线玩家进行游戏操作
+3. 检查离线玩家的数据是否被意外修改
+
+**预期结果**：离线玩家的数据应该保持不变
+
+## 代码审查要点
+
+在未来的开发中，需要注意以下几点：
+
+1. **数据修改原则**：
+   - 只修改当前在线玩家的数据
+   - 访问其他玩家数据时，优先使用只读操作
+   - 避免在定时任务中修改离线玩家数据
+
+2. **时间戳更新**：
+   - 最后登录时间只在真正登录时更新
+   - 避免在数据保存时自动更新时间戳
+   - 区分数据修改和时间戳更新的逻辑
+
+3. **访客模式处理**：
+   - 明确区分访客模式和正常模式
+   - 访客模式下只读取数据，不修改
+   - 提供足够的状态信息给客户端
+
+## 总结
+
+这个bug修复确保了：
+- ✅ 数据完整性：只有真正登录的玩家才会更新最后登录时间
+- ✅ 性能优化：只处理在线玩家的数据，减少不必要的文件操作
+- ✅ 逻辑正确：访客模式下不会影响被访问玩家的数据
+- ✅ 可维护性：代码逻辑更清晰，易于理解和维护
+
+通过这个修复，游戏的数据统计将更加准确，玩家的隐私和数据完整性得到更好的保护。 
\ No newline at end of file
diff --git a/Server/Feature_RemoveCrop.md b/Server/Feature_RemoveCrop.md
new file mode 100644
index 0000000..6bbd508
--- /dev/null
+++ b/Server/Feature_RemoveCrop.md
@@ -0,0 +1,277 @@
+# 铲除作物功能实现
+
+## 功能概述
+
+实现了玩家可以花费500金钱铲除地块上的作物，将地块变成空地的功能。这个功能完全基于服务器端处理，确保数据的一致性和安全性。
+
+## 功能特点
+
+- **费用固定**：铲除任何作物都需要花费500金钱
+- **服务器验证**：所有验证和处理都在服务器端完成
+- **状态重置**：铲除后地块变成空地，可以重新种植
+- **访客保护**：访客模式下无法进行铲除操作
+- **实时更新**：操作完成后立即更新客户端显示
+
+## 实现架构
+
+### 1. 服务器端实现
+
+#### 消息路由
+```python
+elif message_type == "remove_crop":
+    return self._handle_remove_crop(client_id, message)
+```
+
+#### 主处理方法
+```python
+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)
+```
+
+#### 铲除处理逻辑
+```python
+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"]
+        }
+    })
+```
+
+### 2. 网络通信
+
+#### 客户端发送请求
+```gdscript
+#发送铲除作物信息
+func sendRemoveCrop(lot_index):
+    if not client.is_client_connected():
+        return false
+        
+    client.send_data({
+        "type": "remove_crop",
+        "lot_index": lot_index,
+        "timestamp": Time.get_unix_time_from_system()
+    })
+    return true
+```
+
+### 3. 客户端UI实现
+
+#### 按钮文本更新
+```gdscript
+# 更新按钮文本
+func _update_button_texts():
+    dig_button.text = "开垦"+"\n花费："+str(main_game.dig_money)
+    remove_button.text = "铲除"+"\n花费：500"
+```
+
+#### 铲除操作处理
+```gdscript
+#铲除
+func _on_remove_button_pressed():
+    # 检查是否处于访问模式
+    if main_game.is_visiting_mode:
+        Toast.show("访问模式下无法铲除作物", Color.ORANGE, 2.0, 1.0)
+        self.hide()
+        return
+    
+    # 检查玩家金钱是否足够
+    var removal_cost = 500
+    if main_game.money < removal_cost:
+        Toast.show("金钱不足，铲除作物需要 " + str(removal_cost) + " 金钱", Color.RED, 2.0, 1.0)
+        self.hide()
+        return
+    
+    # 检查地块是否有作物
+    var lot = main_game.farm_lots[selected_lot_index]
+    if not lot.get("is_planted", false) or lot.get("crop_type", "") == "":
+        Toast.show("此地块没有种植作物", Color.ORANGE, 2.0, 1.0)
+        self.hide()
+        return
+    
+    # 发送铲除作物请求到服务器
+    if network_manager and network_manager.is_connected_to_server():
+        if network_manager.sendRemoveCrop(selected_lot_index):
+            Toast.show("正在铲除作物...", Color.YELLOW, 1.5, 1.0)
+            self.hide()
+        else:
+            Toast.show("发送铲除请求失败", Color.RED, 2.0, 1.0)
+            self.hide()
+    else:
+        Toast.show("网络未连接，无法铲除作物", Color.RED, 2.0, 1.0)
+        self.hide()
+```
+
+## 验证机制
+
+### 服务器端验证
+1. **用户登录验证**：确保用户已登录
+2. **地块索引验证**：检查地块索引是否有效
+3. **地块状态验证**：确保地块有作物可以铲除
+4. **金钱验证**：检查玩家金钱是否足够支付铲除费用
+
+### 客户端预验证
+1. **访问模式检查**：访客模式下禁止操作
+2. **金钱预检查**：提前检查金钱是否足够
+3. **地块状态预检查**：确保地块有作物
+4. **网络连接检查**：确保能够发送请求
+
+## 操作流程
+
+### 正常流程
+1. 玩家点击地块，显示操作面板
+2. 面板显示铲除按钮和费用信息
+3. 玩家点击铲除按钮
+4. 客户端进行预验证
+5. 发送铲除请求到服务器
+6. 服务器验证并处理请求
+7. 服务器返回操作结果
+8. 客户端更新UI显示
+
+### 错误处理
+- **金钱不足**：显示错误提示，不发送请求
+- **无作物**：显示提示信息，不发送请求
+- **访客模式**：显示权限提示，不发送请求
+- **网络错误**：显示网络错误提示
+- **服务器错误**：显示服务器返回的错误信息
+
+## 数据更新
+
+### 地块状态重置
+```python
+lot["is_planted"] = False      # 取消种植状态
+lot["crop_type"] = ""          # 清空作物类型
+lot["grow_time"] = 0           # 重置生长时间
+lot["is_dead"] = False         # 重置死亡状态
+```
+
+### 玩家数据更新
+```python
+player_data["money"] -= removal_cost  # 扣除金钱
+```
+
+### 实时同步
+- 服务器保存玩家数据到文件
+- 推送作物更新到客户端
+- 客户端接收并更新UI显示
+
+## 使用场景
+
+1. **清理死亡作物**：当作物死亡时，玩家可以花费金钱清理
+2. **重新规划农场**：玩家想要种植不同作物时
+3. **紧急处理**：当玩家需要快速清理地块时
+4. **策略调整**：根据市场需求调整种植策略
+
+## 安全考虑
+
+1. **服务器权威**：所有验证和处理都在服务器端
+2. **数据一致性**：确保客户端和服务器数据同步
+3. **防作弊**：客户端无法直接修改游戏数据
+4. **访问控制**：访客模式下无法进行破坏性操作
+
+## 扩展性
+
+该功能设计具有良好的扩展性：
+
+1. **费用可配置**：可以根据作物类型设置不同的铲除费用
+2. **条件扩展**：可以添加更多的铲除条件（如等级要求）
+3. **奖励机制**：可以在铲除时给予部分资源回收
+4. **工具系统**：可以引入铲子等工具来影响铲除效果
+
+## 测试用例
+
+### 测试用例1：正常铲除
+1. 玩家有足够金钱（≥500）
+2. 地块有作物
+3. 点击铲除按钮
+4. 验证：金钱减少500，地块变成空地
+
+### 测试用例2：金钱不足
+1. 玩家金钱不足（<500）
+2. 地块有作物
+3. 点击铲除按钮
+4. 验证：显示金钱不足提示，操作失败
+
+### 测试用例3：无作物地块
+1. 玩家有足够金钱
+2. 地块为空地
+3. 点击铲除按钮
+4. 验证：显示无作物提示，操作失败
+
+### 测试用例4：访客模式
+1. 玩家处于访客模式
+2. 点击铲除按钮
+3. 验证：显示权限提示，操作失败
+
+### 测试用例5：网络断开
+1. 网络连接断开
+2. 点击铲除按钮
+3. 验证：显示网络错误提示，操作失败
+
+## 总结
+
+铲除作物功能的实现遵循了以下设计原则：
+
+- ✅ **服务器权威**：所有关键逻辑在服务器端处理
+- ✅ **用户体验**：提供清晰的费用信息和操作反馈
+- ✅ **数据安全**：多层验证确保数据完整性
+- ✅ **错误处理**：完善的错误提示和处理机制
+- ✅ **代码复用**：利用现有的验证和处理框架
+- ✅ **可维护性**：清晰的代码结构和文档
+
+这个功能为玩家提供了更灵活的农场管理选项，同时保持了游戏的平衡性和数据安全性。 
\ No newline at end of file
diff --git a/Server/Feature_Summary.md b/Server/Feature_Summary.md
new file mode 100644
index 0000000..c243f8b
--- /dev/null
+++ b/Server/Feature_Summary.md
@@ -0,0 +1,236 @@
+# 萌芽农场新功能实现总结
+
+## 功能概述
+
+本次更新成功实现了三个重要的农场管理功能：浇水、施肥、升级土地。这些功能为玩家提供了更丰富的农场管理体验和策略选择。
+
+## 实现的功能
+
+### 1. 浇水功能 💧
+- **费用**：50金钱
+- **效果**：作物直接生长1%，如果达到100%直接成熟
+- **限制**：每天每块地只能浇水一次，每日自动重置
+- **状态显示**：浇过水的地块显示💧图标
+- **验证**：检查金钱、作物状态、是否已浇水等
+
+### 2. 施肥功能 🌱
+- **费用**：150金钱
+- **效果**：作物在10分钟内以双倍速度生长
+- **限制**：每个作物只能施肥一次
+- **状态显示**：施过肥的地块显示🌱图标
+- **时间管理**：10分钟后自动清除施肥状态
+
+### 3. 土地升级功能 ⭐
+- **费用**：1000金钱
+- **效果**：永久让这块土地的作物以1.5倍速度生长
+- **限制**：每块土地只能升级一次
+- **状态显示**：升级过的土地显示⭐图标
+- **持久性**：升级效果永久有效
+
+## 技术实现
+
+### 服务器端实现
+
+#### 1. 消息路由扩展
+```python
+# 在_handle_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)
+```
+
+#### 2. 处理方法实现
+- `_handle_water_crop()` - 处理浇水请求
+- `_handle_fertilize_crop()` - 处理施肥请求
+- `_handle_upgrade_land()` - 处理升级请求
+- `_process_watering()` - 浇水逻辑处理
+- `_process_fertilizing()` - 施肥逻辑处理
+- `_process_land_upgrade()` - 升级逻辑处理
+
+#### 3. 作物生长系统增强
+```python
+# 计算生长速度倍数
+growth_multiplier = 1.0
+
+# 土地等级影响：1级土地提供1.5倍生长速度
+if land_level >= 1:
+    growth_multiplier *= 1.5
+
+# 施肥影响：10分钟内双倍生长速度
+if fertilized and within_10_minutes:
+    growth_multiplier *= 2.0
+```
+
+#### 4. 状态管理
+- 每日重置浇水状态
+- 施肥时间戳管理
+- 土地等级持久化
+
+### 客户端实现
+
+#### 1. 网络通信扩展
+```gdscript
+# 新增发送方法
+func sendWaterCrop(lot_index)
+func sendFertilizeCrop(lot_index)
+func sendUpgradeLand(lot_index)
+```
+
+#### 2. UI响应处理
+```gdscript
+# 在_handle_action_response中添加新的响应类型
+"water_crop", "fertilize_crop", "upgrade_land"
+```
+
+#### 3. 地块面板功能
+- 显示浇水、施肥、升级按钮
+- 添加费用显示
+- 实现预验证逻辑
+- 错误提示处理
+
+#### 4. 状态显示增强
+```gdscript
+# 添加状态标识
+if lot.get("已浇水", false):
+    status_indicators.append("💧")
+if lot.get("已施肥", false):
+    status_indicators.append("🌱")
+if lot.get("土地等级", 0) >= 1:
+    status_indicators.append("⭐")
+```
+
+## 数据结构扩展
+
+### 地块数据结构
+```json
+{
+    "crop_type": "作物名称",
+    "grow_time": 当前生长时间,
+    "max_grow_time": 最大生长时间,
+    "is_planted": true/false,
+    "is_diged": true/false,
+    "is_dead": true/false,
+    "已浇水": true/false,
+    "已施肥": true/false,
+    "土地等级": 0/1,
+    "施肥时间": 时间戳
+}
+```
+
+### 玩家数据扩展
+```json
+{
+    "last_water_reset_date": "2024-01-01",
+    // ... 其他现有字段
+}
+```
+
+## 功能特性
+
+### 1. 效果叠加
+- 土地升级 + 施肥 = 3倍生长速度（1.5 × 2.0）
+- 浇水 + 施肥 + 升级 = 最大化生长效率
+
+### 2. 时间管理
+- 浇水：每日重置（基于日期）
+- 施肥：10分钟时效
+- 升级：永久有效
+
+### 3. 经济平衡
+- 浇水：低成本，即时效果
+- 施肥：中等成本，短期加速
+- 升级：高成本，长期投资
+
+### 4. 用户体验
+- 清晰的状态图标显示
+- 详细的错误提示
+- 即时的UI反馈
+- 流畅的操作体验
+
+## 安全性和验证
+
+### 1. 服务器端验证
+- 用户登录状态检查
+- 金钱充足性验证
+- 地块状态验证
+- 重复操作防护
+
+### 2. 客户端预验证
+- 减少无效请求
+- 提供即时反馈
+- 改善用户体验
+
+### 3. 数据一致性
+- 服务器权威验证
+- 客户端状态同步
+- 错误状态恢复
+
+## 扩展性设计
+
+### 1. 可配置参数
+- 浇水费用：50金钱（可调整）
+- 施肥费用：150金钱（可调整）
+- 升级费用：1000金钱（可调整）
+- 施肥持续时间：10分钟（可调整）
+
+### 2. 未来扩展可能
+- 多级土地升级
+- 不同类型的肥料
+- 天气系统影响
+- 季节性效果
+
+## 测试覆盖
+
+### 1. 功能测试
+- 正常操作流程
+- 边界条件测试
+- 错误处理验证
+
+### 2. 集成测试
+- 客户端-服务器通信
+- 数据同步验证
+- 状态持久化测试
+
+### 3. 用户体验测试
+- 操作流畅性
+- 提示信息准确性
+- 视觉反馈效果
+
+## 性能影响
+
+### 1. 服务器性能
+- 作物生长计算复杂度略有增加
+- 状态管理内存占用轻微增长
+- 网络消息量适度增加
+
+### 2. 客户端性能
+- UI更新频率保持稳定
+- 状态显示计算开销很小
+- 用户操作响应及时
+
+## 维护和监控
+
+### 1. 日志记录
+- 所有操作都有详细日志
+- 错误情况记录完整
+- 便于问题排查
+
+### 2. 数据监控
+- 功能使用频率统计
+- 经济系统平衡监控
+- 用户行为分析
+
+## 总结
+
+本次功能实现成功为萌芽农场游戏添加了三个重要的农场管理功能，显著提升了游戏的策略性和可玩性。实现过程中注重了：
+
+- **完整性**：从服务器到客户端的完整实现
+- **安全性**：多层验证和错误处理
+- **用户体验**：清晰的反馈和流畅的操作
+- **可维护性**：清晰的代码结构和文档
+- **扩展性**：为未来功能扩展预留空间
+
+这些功能为玩家提供了更多的农场管理选择，增加了游戏的深度和策略性，同时保持了良好的游戏平衡性。 
\ No newline at end of file
diff --git a/Server/JsonEdit/README.md b/Server/JsonEdit/README.md
deleted file mode 100644
index ebd3a7a..0000000
--- a/Server/JsonEdit/README.md
+++ /dev/null
@@ -1,100 +0,0 @@
-# JSON 批量编辑器
-
-一个简洁强大的JSON编辑工具，专门用于批量添加键值对到JSON文件中的所有对象。
-
-## 🚀 功能特点
-
-- **批量添加属性**: 一键为JSON中所有对象添加新的键值对
-- **智能类型识别**: 自动识别并转换数据类型
-- **支持所有JSON数据类型**: 字符串、数字、布尔值、对象、数组、null
-- **文件上传**: 支持JSON文件拖拽上传
-- **即时下载**: 编辑完成后立即下载修改后的JSON文件
-- **无需服务器**: 纯前端实现，直接在浏览器中运行
-
-## 📋 支持的数据类型
-
-| 类型 | 输入示例 | 转换结果 |
-|------|----------|----------|
-| 字符串 | `hello world` | `"hello world"` |
-| 整数 | `123` | `123` |
-| 小数 | `3.14` | `3.14` |
-| 布尔值 | `true` 或 `false` | `true` 或 `false` |
-| 空值 | `null` | `null` |
-| 对象 | `{"key": "value"}` | `{"key": "value"}` |
-| 数组 | `[1, 2, 3]` | `[1, 2, 3]` |
-| 空字符串 | *(留空)* | `""` |
-
-## 🎯 使用方法
-
-### 1. 加载JSON数据
-- **方法一**: 点击"上传JSON文件"按钮选择文件
-- **方法二**: 直接在编辑器中粘贴JSON数据
-- **方法三**: 点击"加载示例数据"使用预设数据
-
-### 2. 批量添加属性
-1. 在"键名"字段输入要添加的属性名，如: `能否购买`
-2. 在"键值"字段输入属性值，如: `true`
-3. 点击"批量添加到所有对象"按钮
-4. 系统会自动为JSON中的每个对象添加该属性
-
-### 3. 下载结果
-点击"下载修改后的JSON"按钮保存编辑后的文件
-
-## 💡 使用示例
-
-### 原始JSON:
-```json
-{
-  "小麦": {
-    "花费": 120,
-    "收益": 100,
-    "品质": "普通"
-  },
-  "稻谷": {
-    "花费": 100,
-    "收益": 120,
-    "品质": "普通"
-  }
-}
-```
-
-### 添加属性: 键名=`能否购买`, 键值=`true`
-
-### 结果JSON:
-```json
-{
-  "小麦": {
-    "花费": 120,
-    "收益": 100,
-    "品质": "普通",
-    "能否购买": true
-  },
-  "稻谷": {
-    "花费": 100,
-    "收益": 120,
-    "品质": "普通",
-    "能否购买": true
-  }
-}
-```
-
-## 🔧 快速开始
-
-1. 直接在浏览器中打开 `templates/json_editor.html` 文件
-2. 无需安装任何依赖或服务器
-3. 开始使用批量编辑功能
-
-## ⚠️ 注意事项
-
-- 工具会递归处理嵌套对象，为所有找到的对象添加指定属性
-- 数组元素如果是对象，也会被添加属性
-- 确保JSON格式正确，否则无法处理
-- 修改前建议备份原始文件
-
-## 🎨 界面说明
-
-- **左侧边栏**: 文件操作、批量编辑功能、快速示例
-- **右侧编辑区**: JSON数据显示和编辑
-- **智能提示**: 实时显示操作结果和错误信息
-
-这个工具特别适合游戏开发、配置文件管理等需要批量修改JSON数据的场景。 
\ No newline at end of file
diff --git a/Server/JsonEdit/example_formats.md b/Server/JsonEdit/example_formats.md
deleted file mode 100644
index cd836a7..0000000
--- a/Server/JsonEdit/example_formats.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# JSON格式化示例
-
-以下展示三种不同的JSON格式化效果：
-
-## 原始数据
-```json
-{"小麦":{"花费":120,"收益":100,"品质":"普通"},"稻谷":{"花费":100,"收益":120,"品质":"普通"}}
-```
-
-## 1. 标准格式化（2空格缩进）
-```json
-{
-  "小麦": {
-    "花费": 120,
-    "收益": 100,
-    "品质": "普通"
-  },
-  "稻谷": {
-    "花费": 100,
-    "收益": 120,
-    "品质": "普通"
-  }
-}
-```
-
-## 2. 最小化（压缩）
-```json
-{"小麦":{"花费":120,"收益":100,"品质":"普通"},"稻谷":{"花费":100,"收益":120,"品质":"普通"}}
-```
-
-## 3. 一行化（一个对象一行）
-```json
-{
-  "小麦": {"花费":120,"收益":100,"品质":"普通"},
-  "稻谷": {"花费":100,"收益":120,"品质":"普通"}
-}
-```
-
-## 使用场景
-
-- **标准格式化**: 适合阅读和编辑，开发时使用
-- **最小化**: 适合网络传输，节省带宽
-- **一行化**: 适合比较不同对象，每行一个对象便于查看差异
-
-## 批量添加属性示例
-
-添加键名: `能否购买`, 键值: `true`
-
-### 结果:
-```json
-{
-  "小麦": {
-    "花费": 120,
-    "收益": 100,
-    "品质": "普通",
-    "能否购买": true
-  },
-  "稻谷": {
-    "花费": 100,
-    "收益": 120,
-    "品质": "普通",
-    "能否购买": true
-  }
-}
-``` 
\ No newline at end of file
diff --git a/Server/JsonEdit/json_editor.py b/Server/JsonEdit/json_editor.py
deleted file mode 100644
index eac0890..0000000
--- a/Server/JsonEdit/json_editor.py
+++ /dev/null
@@ -1,267 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-from flask import Flask, request, jsonify, render_template, send_file
-import json
-import os
-from datetime import datetime
-
-app = Flask(__name__)
-
-class JSONFormatter:
-    """JSON格式化工具类"""
-    
-    @staticmethod
-    def format_standard(data, indent=2):
-        """标准格式化 - 带缩进的可读格式"""
-        return json.dumps(data, ensure_ascii=False, indent=indent)
-    
-    @staticmethod
-    def minify(data):
-        """最小化 - 压缩去除空格"""
-        return json.dumps(data, ensure_ascii=False, separators=(',', ':'))
-    
-    @staticmethod
-    def one_line_per_object(data):
-        """一行化 - 每个对象/元素占一行"""
-        if isinstance(data, list):
-            # 如果是数组，每个元素占一行
-            lines = ['[']
-            for i, item in enumerate(data):
-                comma = ',' if i < len(data) - 1 else ''
-                lines.append(f'  {json.dumps(item, ensure_ascii=False)}{comma}')
-            lines.append(']')
-            return '\n'.join(lines)
-        
-        elif isinstance(data, dict):
-            # 如果是对象，每个键值对占一行
-            lines = ['{']
-            keys = list(data.keys())
-            for i, key in enumerate(keys):
-                comma = ',' if i < len(keys) - 1 else ''
-                value_str = json.dumps(data[key], ensure_ascii=False)
-                lines.append(f'  {json.dumps(key, ensure_ascii=False)}: {value_str}{comma}')
-            lines.append('}')
-            return '\n'.join(lines)
-        
-        else:
-            # 基本类型直接返回
-            return json.dumps(data, ensure_ascii=False)
-
-@app.route('/')
-def index():
-    """主页"""
-    return render_template('json_editor.html')
-
-@app.route('/api/format', methods=['POST'])
-def format_json():
-    """JSON格式化API"""
-    try:
-        data = request.get_json()
-        content = data.get('content', '')
-        format_type = data.get('format_type', 'standard')  # standard, minify, oneline
-        
-        if not content.strip():
-            return jsonify({'success': False, 'message': '请提供JSON内容'})
-        
-        # 解析JSON
-        try:
-            json_data = json.loads(content)
-        except json.JSONDecodeError as e:
-            return jsonify({'success': False, 'message': f'JSON格式错误: {str(e)}'})
-        
-        # 根据类型格式化
-        formatter = JSONFormatter()
-        
-        if format_type == 'standard':
-            formatted = formatter.format_standard(json_data)
-            message = 'JSON标准格式化完成'
-        elif format_type == 'minify':
-            formatted = formatter.minify(json_data)
-            message = 'JSON最小化完成'
-        elif format_type == 'oneline':
-            formatted = formatter.one_line_per_object(json_data)
-            message = 'JSON一行化格式完成'
-        else:
-            return jsonify({'success': False, 'message': '不支持的格式化类型'})
-        
-        return jsonify({
-            'success': True,
-            'message': message,
-            'formatted': formatted,
-            'original_length': len(content),
-            'formatted_length': len(formatted)
-        })
-        
-    except Exception as e:
-        return jsonify({'success': False, 'message': f'处理错误: {str(e)}'})
-
-@app.route('/api/batch_add', methods=['POST'])
-def batch_add_property():
-    """批量添加属性API"""
-    try:
-        data = request.get_json()
-        content = data.get('content', '')
-        key_name = data.get('key_name', '')
-        key_value = data.get('key_value', '')
-        
-        if not content.strip():
-            return jsonify({'success': False, 'message': '请提供JSON内容'})
-        
-        if not key_name.strip():
-            return jsonify({'success': False, 'message': '请提供键名'})
-        
-        # 解析JSON
-        try:
-            json_data = json.loads(content)
-        except json.JSONDecodeError as e:
-            return jsonify({'success': False, 'message': f'JSON格式错误: {str(e)}'})
-        
-        # 智能解析键值
-        parsed_value = parse_value(key_value)
-        
-        # 批量添加属性
-        count = add_property_to_all_objects(json_data, key_name, parsed_value)
-        
-        # 格式化输出
-        formatted = JSONFormatter.format_standard(json_data)
-        
-        return jsonify({
-            'success': True,
-            'message': f'成功为 {count} 个对象添加了属性 "{key_name}": {json.dumps(parsed_value, ensure_ascii=False)}',
-            'formatted': formatted,
-            'count': count
-        })
-        
-    except Exception as e:
-        return jsonify({'success': False, 'message': f'处理错误: {str(e)}'})
-
-def parse_value(value_str):
-    """智能解析值的类型"""
-    if value_str == '':
-        return ''
-    
-    # null
-    if value_str.lower() == 'null':
-        return None
-    
-    # boolean
-    if value_str.lower() == 'true':
-        return True
-    if value_str.lower() == 'false':
-        return False
-    
-    # number
-    try:
-        if '.' in value_str:
-            return float(value_str)
-        else:
-            return int(value_str)
-    except ValueError:
-        pass
-    
-    # JSON object or array
-    if (value_str.startswith('{') and value_str.endswith('}')) or \
-       (value_str.startswith('[') and value_str.endswith(']')):
-        try:
-            return json.loads(value_str)
-        except json.JSONDecodeError:
-            pass
-    
-    # string
-    return value_str
-
-def add_property_to_all_objects(obj, key, value):
-    """递归为所有对象添加属性"""
-    count = 0
-    
-    def traverse(current):
-        nonlocal count
-        if isinstance(current, dict):
-            current[key] = value
-            count += 1
-            # 继续递归处理嵌套对象
-            for val in current.values():
-                if isinstance(val, (dict, list)) and val != current:
-                    traverse(val)
-        elif isinstance(current, list):
-            for item in current:
-                traverse(item)
-    
-    traverse(obj)
-    return count
-
-@app.route('/api/validate', methods=['POST'])
-def validate_json():
-    """JSON验证API"""
-    try:
-        data = request.get_json()
-        content = data.get('content', '')
-        
-        if not content.strip():
-            return jsonify({'success': False, 'message': '请提供JSON内容'})
-        
-        try:
-            json_data = json.loads(content)
-            return jsonify({
-                'success': True,
-                'message': 'JSON格式正确 ✓',
-                'valid': True
-            })
-        except json.JSONDecodeError as e:
-            return jsonify({
-                'success': False,
-                'message': f'JSON格式错误: {str(e)}',
-                'valid': False,
-                'error': str(e)
-            })
-            
-    except Exception as e:
-        return jsonify({'success': False, 'message': f'验证错误: {str(e)}'})
-
-@app.route('/api/download', methods=['POST'])
-def download_json():
-    """下载JSON文件"""
-    try:
-        data = request.get_json()
-        content = data.get('content', '')
-        format_type = data.get('format_type', 'standard')
-        
-        if not content.strip():
-            return jsonify({'success': False, 'message': '没有可下载的内容'})
-        
-        # 验证JSON格式
-        try:
-            json_data = json.loads(content)
-        except json.JSONDecodeError as e:
-            return jsonify({'success': False, 'message': f'JSON格式错误: {str(e)}'})
-        
-        # 格式化
-        formatter = JSONFormatter()
-        if format_type == 'minify':
-            formatted_content = formatter.minify(json_data)
-        elif format_type == 'oneline':
-            formatted_content = formatter.one_line_per_object(json_data)
-        else:
-            formatted_content = formatter.format_standard(json_data)
-        
-        # 生成文件名
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"edited_json_{format_type}_{timestamp}.json"
-        
-        # 创建临时文件
-        temp_file = f"temp_{filename}"
-        with open(temp_file, 'w', encoding='utf-8') as f:
-            f.write(formatted_content)
-        
-        return send_file(temp_file, as_attachment=True, download_name=filename)
-        
-    except Exception as e:
-        return jsonify({'success': False, 'message': f'下载错误: {str(e)}'})
-
-if __name__ == '__main__':
-    # 确保templates目录存在
-    os.makedirs('templates', exist_ok=True)
-    
-    # 运行应用
-    app.run(debug=True, host='0.0.0.0', port=5000)
diff --git a/Server/JsonEdit/requirements.txt b/Server/JsonEdit/requirements.txt
deleted file mode 100644
index c4988fb..0000000
--- a/Server/JsonEdit/requirements.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-Flask==2.3.3
-Werkzeug==2.3.7 
\ No newline at end of file
diff --git a/Server/JsonEdit/templates/json_editor.html b/Server/JsonEdit/templates/json_editor.html
deleted file mode 100644
index fbe7316..0000000
--- a/Server/JsonEdit/templates/json_editor.html
+++ /dev/null
@@ -1,627 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>简易JSON编辑器 - 批量添加键值</title>
-    <style>
-        * {
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }
-
-        body {
-            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-            background: #f5f5f5;
-            padding: 20px;
-        }
-
-        .container {
-            max-width: 1200px;
-            margin: 0 auto;
-            background: white;
-            border-radius: 10px;
-            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
-            overflow: hidden;
-        }
-
-        .header {
-            background: #4a90e2;
-            color: white;
-            padding: 20px;
-            text-align: center;
-        }
-
-        .header h1 {
-            margin-bottom: 5px;
-        }
-
-        .main-content {
-            display: grid;
-            grid-template-columns: 300px 1fr;
-            gap: 0;
-            min-height: 600px;
-        }
-
-        .sidebar {
-            background: #f8f9fa;
-            border-right: 1px solid #dee2e6;
-            padding: 20px;
-        }
-
-        .editor-area {
-            padding: 20px;
-        }
-
-        .section {
-            background: white;
-            border: 1px solid #dee2e6;
-            border-radius: 5px;
-            padding: 15px;
-            margin-bottom: 15px;
-        }
-
-        .section h3 {
-            margin-bottom: 15px;
-            color: #333;
-        }
-
-        .btn {
-            background: #4a90e2;
-            color: white;
-            border: none;
-            padding: 10px 20px;
-            border-radius: 5px;
-            cursor: pointer;
-            font-size: 14px;
-            margin: 5px 5px 5px 0;
-            width: 100%;
-        }
-
-        .btn:hover {
-            background: #357abd;
-        }
-
-        .btn-success {
-            background: #28a745;
-        }
-
-        .btn-success:hover {
-            background: #218838;
-        }
-
-        .input-group {
-            margin-bottom: 15px;
-        }
-
-        .input-group label {
-            display: block;
-            margin-bottom: 5px;
-            font-weight: 500;
-            color: #333;
-        }
-
-        .input-group input {
-            width: 100%;
-            padding: 8px 12px;
-            border: 1px solid #dee2e6;
-            border-radius: 5px;
-            font-size: 14px;
-        }
-
-        .input-group input:focus {
-            outline: none;
-            border-color: #4a90e2;
-        }
-
-        #jsonEditor {
-            width: 100%;
-            height: 500px;
-            border: 1px solid #dee2e6;
-            border-radius: 5px;
-            padding: 15px;
-            font-family: 'Courier New', monospace;
-            font-size: 14px;
-            line-height: 1.5;
-            resize: vertical;
-        }
-
-        #jsonEditor:focus {
-            outline: none;
-            border-color: #4a90e2;
-        }
-
-        .file-upload {
-            position: relative;
-            display: inline-block;
-            cursor: pointer;
-            overflow: hidden;
-            width: 100%;
-        }
-
-        .file-upload input[type=file] {
-            position: absolute;
-            left: -9999px;
-        }
-
-        .alert {
-            padding: 10px 15px;
-            margin-bottom: 15px;
-            border-radius: 5px;
-            font-weight: 500;
-        }
-
-        .alert-success {
-            background: #d4edda;
-            color: #155724;
-            border: 1px solid #c3e6cb;
-        }
-
-        .alert-error {
-            background: #f8d7da;
-            color: #721c24;
-            border: 1px solid #f5c6cb;
-        }
-
-        .alert-info {
-            background: #d1ecf1;
-            color: #0c5460;
-            border: 1px solid #bee5eb;
-        }
-
-        @media (max-width: 768px) {
-            .main-content {
-                grid-template-columns: 1fr;
-            }
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="header">
-            <h1>🔧 JSON批量编辑器</h1>
-            <p>批量添加键值对到JSON文件</p>
-        </div>
-
-        <div class="main-content">
-            <!-- 侧边栏 -->
-            <div class="sidebar">
-                <!-- 文件操作 -->
-                <div class="section">
-                    <h3>📁 文件操作</h3>
-                    <div class="file-upload btn">
-                        <input type="file" id="fileInput" accept=".json" />
-                        上传JSON文件
-                    </div>
-                    <button class="btn btn-success" onclick="downloadJSON()">
-                        下载修改后的JSON
-                    </button>
-                </div>
-
-                <!-- 批量添加键值 -->
-                <div class="section">
-                    <h3>⚡ 批量添加键值</h3>
-                    <div class="input-group">
-                        <label for="keyName">键名:</label>
-                        <input type="text" id="keyName" placeholder="例: 能否购买" />
-                    </div>
-                    <div class="input-group">
-                        <label for="keyValue">键值:</label>
-                        <input type="text" id="keyValue" placeholder="支持多种类型，见下方说明" />
-                    </div>
-                    <button class="btn btn-success" onclick="batchAddProperty()">
-                        批量添加到所有对象
-                    </button>
-                    
-                    <div style="margin-top: 15px; padding: 10px; background: #f8f9fa; border-radius: 5px; font-size: 12px;">
-                        <strong>支持的数据类型:</strong><br>
-                        • 字符串: hello world<br>
-                        • 数字: 123 或 3.14<br>
-                        • 布尔值: true 或 false<br>
-                        • 空值: null<br>
-                        • 对象: {"key": "value"}<br>
-                        • 数组: [1, 2, 3]<br>
-                        <small style="color: #666;">系统会自动识别并转换数据类型</small>
-                    </div>
-                </div>
-
-                <!-- 快速示例 -->
-                <div class="section">
-                    <h3>📝 快速示例</h3>
-                    <button class="btn" onclick="loadSampleJSON()">
-                        加载示例数据
-                    </button>
-                    
-                    <div style="margin-top: 15px;">
-                        <strong style="font-size: 12px;">快速填入示例键值:</strong><br>
-                        <button class="btn" style="font-size: 11px; padding: 5px 10px; margin: 2px;" onclick="fillExample('能否购买', 'true')">
-                            布尔值示例
-                        </button>
-                        <button class="btn" style="font-size: 11px; padding: 5px 10px; margin: 2px;" onclick="fillExample('价格', '150')">
-                            数字示例
-                        </button>
-                        <button class="btn" style="font-size: 11px; padding: 5px 10px; margin: 2px;" onclick="fillExample('备注', '新增属性')">
-                            字符串示例
-                        </button>
-                        <button class="btn" style="font-size: 11px; padding: 5px 10px; margin: 2px;" onclick="fillExample('tags', '[&quot;新&quot;, &quot;热门&quot;]')">
-                            数组示例
-                        </button>
-                    </div>
-                </div>
-
-                <!-- JSON格式化操作 -->
-                <div class="section">
-                    <h3>🔧 格式化操作</h3>
-                    <button class="btn" onclick="formatJSONStandard()">
-                        标准格式化
-                    </button>
-                    <button class="btn btn-success" onclick="minifyJSON()">
-                        最小化（压缩）
-                    </button>
-                    <button class="btn" style="background: #17a2b8;" onclick="oneLinePerObject()">
-                        一行化（一个对象一行）
-                    </button>
-                    <button class="btn" style="background: #6f42c1; color: white;" onclick="validateJSON()">
-                        验证JSON格式
-                    </button>
-                    
-                    <div style="margin-top: 15px; padding: 10px; background: #f8f9fa; border-radius: 5px; font-size: 12px;">
-                        <strong>格式化说明:</strong><br>
-                        • <strong>标准格式化</strong>: 2空格缩进，易于阅读<br>
-                        • <strong>最小化</strong>: 去除空格，节省空间<br>
-                        • <strong>一行化</strong>: 每个对象占一行，便于比较<br>
-                        • <strong>验证格式</strong>: 检查JSON语法是否正确<br>
-                    </div>
-                </div>
-            </div>
-
-            <!-- 编辑区域 -->
-            <div class="editor-area">
-                <!-- 消息区域 -->
-                <div id="messageArea"></div>
-                
-                <!-- JSON编辑器 -->
-                <textarea id="jsonEditor" placeholder="在此输入或上传JSON数据..."></textarea>
-            </div>
-        </div>
-    </div>
-
-    <script>
-        // 初始化
-        document.addEventListener('DOMContentLoaded', function() {
-            document.getElementById('fileInput').addEventListener('change', handleFileUpload);
-        });
-
-        // 显示消息
-        function showMessage(message, type = 'success') {
-            const messageArea = document.getElementById('messageArea');
-            let alertClass = 'alert-success';
-            
-            if (type === 'error') {
-                alertClass = 'alert-error';
-            } else if (type === 'info') {
-                alertClass = 'alert-info';
-            }
-            
-            messageArea.innerHTML = `
-                <div class="alert ${alertClass}">
-                    ${message}
-                </div>
-            `;
-            
-            setTimeout(() => {
-                messageArea.innerHTML = '';
-            }, 3000);
-        }
-
-        // 加载示例JSON
-        function loadSampleJSON() {
-            const sampleJSON = {
-                "测试作物": {
-                    "花费": 1,
-                    "生长时间": 3,
-                    "收益": 9999,
-                    "品质": "普通"
-                },
-                "小麦": {
-                    "花费": 120,
-                    "生长时间": 120,
-                    "收益": 100,
-                    "品质": "普通"
-                },
-                "稻谷": {
-                    "花费": 100,
-                    "生长时间": 240,
-                    "收益": 120,
-                    "品质": "普通"
-                }
-            };
-            
-            document.getElementById('jsonEditor').value = JSON.stringify(sampleJSON, null, 2);
-            showMessage('示例数据已加载');
-        }
-
-        // 快速填入示例键值对
-        function fillExample(keyName, keyValue) {
-            document.getElementById('keyName').value = keyName;
-            document.getElementById('keyValue').value = keyValue;
-            showMessage(`已填入示例: ${keyName} = ${keyValue}`, 'info');
-        }
-
-        // 文件上传处理
-        function handleFileUpload(event) {
-            const file = event.target.files[0];
-            if (!file) return;
-
-            if (!file.name.toLowerCase().endsWith('.json')) {
-                showMessage('请选择JSON文件', 'error');
-                return;
-            }
-
-            const reader = new FileReader();
-            reader.onload = function(e) {
-                try {
-                    const content = e.target.result;
-                    JSON.parse(content); // 验证JSON格式
-                    document.getElementById('jsonEditor').value = content;
-                    showMessage('文件上传成功');
-                } catch (error) {
-                    showMessage('JSON格式错误: ' + error.message, 'error');
-                }
-            };
-            reader.readAsText(file);
-            
-            // 清空文件输入
-            event.target.value = '';
-        }
-
-        // 批量添加属性
-        function batchAddProperty() {
-            const keyName = document.getElementById('keyName').value.trim();
-            const keyValue = document.getElementById('keyValue').value.trim();
-            const jsonContent = document.getElementById('jsonEditor').value.trim();
-
-            if (!keyName) {
-                showMessage('请输入键名', 'error');
-                return;
-            }
-
-            if (!jsonContent) {
-                showMessage('请输入或上传JSON数据', 'error');
-                return;
-            }
-
-            try {
-                let jsonData = JSON.parse(jsonContent);
-                
-                // 智能类型转换
-                let processedValue = parseValue(keyValue);
-                
-                // 批量添加属性
-                const result = addPropertyToAllObjects(jsonData, keyName, processedValue);
-                
-                if (result.count > 0) {
-                    document.getElementById('jsonEditor').value = JSON.stringify(jsonData, null, 2);
-                    showMessage(`成功为 ${result.count} 个对象添加了属性 "${keyName}": ${JSON.stringify(processedValue)}`);
-                } else {
-                    showMessage('未找到可添加属性的对象', 'info');
-                }
-
-            } catch (error) {
-                showMessage('JSON格式错误: ' + error.message, 'error');
-            }
-        }
-
-        // 智能解析值的类型
-        function parseValue(value) {
-            // 如果输入为空，返回空字符串
-            if (value === '') {
-                return '';
-            }
-            
-            // 尝试解析为null
-            if (value.toLowerCase() === 'null') {
-                return null;
-            }
-            
-            // 尝试解析为undefined（虽然JSON不支持，但转为null）
-            if (value.toLowerCase() === 'undefined') {
-                return null;
-            }
-            
-            // 尝试解析为布尔值
-            if (value.toLowerCase() === 'true') {
-                return true;
-            }
-            if (value.toLowerCase() === 'false') {
-                return false;
-            }
-            
-            // 尝试解析为数字
-            if (!isNaN(value) && !isNaN(parseFloat(value))) {
-                // 检查是否为整数
-                if (Number.isInteger(parseFloat(value))) {
-                    return parseInt(value, 10);
-                } else {
-                    return parseFloat(value);
-                }
-            }
-            
-            // 尝试解析为JSON对象或数组
-            if ((value.startsWith('{') && value.endsWith('}')) || 
-                (value.startsWith('[') && value.endsWith(']'))) {
-                try {
-                    return JSON.parse(value);
-                } catch (e) {
-                    // 如果解析失败，当作字符串处理
-                    return value;
-                }
-            }
-            
-            // 默认当作字符串处理
-            return value;
-        }
-
-        // 递归为所有对象添加属性
-        function addPropertyToAllObjects(obj, key, value) {
-            let count = 0;
-
-            function traverse(current) {
-                if (typeof current === 'object' && current !== null) {
-                    if (Array.isArray(current)) {
-                        // 处理数组
-                        current.forEach(item => traverse(item));
-                    } else {
-                        // 处理对象
-                        current[key] = value;
-                        count++;
-                        
-                        // 继续递归处理嵌套对象
-                        Object.values(current).forEach(val => {
-                            if (typeof val === 'object' && val !== null && val !== current) {
-                                traverse(val);
-                            }
-                        });
-                    }
-                }
-            }
-
-            traverse(obj);
-            return { count };
-        }
-
-        // 下载JSON
-        function downloadJSON() {
-            const content = document.getElementById('jsonEditor').value.trim();
-            
-            if (!content) {
-                showMessage('没有可下载的内容', 'error');
-                return;
-            }
-
-            try {
-                // 验证JSON格式
-                JSON.parse(content);
-                
-                const blob = new Blob([content], { type: 'application/json' });
-                const url = URL.createObjectURL(blob);
-                const link = document.createElement('a');
-                link.href = url;
-                link.download = `edited_json_${new Date().getTime()}.json`;
-                document.body.appendChild(link);
-                link.click();
-                document.body.removeChild(link);
-                URL.revokeObjectURL(url);
-                
-                showMessage('JSON文件下载成功');
-            } catch (error) {
-                showMessage('JSON格式错误，无法下载: ' + error.message, 'error');
-            }
-        }
-
-        // 标准格式化JSON
-        function formatJSONStandard() {
-            const content = document.getElementById('jsonEditor').value.trim();
-            
-            if (!content) {
-                showMessage('请输入JSON数据', 'error');
-                return;
-            }
-
-            try {
-                const jsonData = JSON.parse(content);
-                const formatted = JSON.stringify(jsonData, null, 2);
-                document.getElementById('jsonEditor').value = formatted;
-                showMessage('JSON标准格式化完成');
-            } catch (error) {
-                showMessage('JSON格式错误: ' + error.message, 'error');
-            }
-        }
-
-        // 最小化JSON（压缩）
-        function minifyJSON() {
-            const content = document.getElementById('jsonEditor').value.trim();
-            
-            if (!content) {
-                showMessage('请输入JSON数据', 'error');
-                return;
-            }
-
-            try {
-                const jsonData = JSON.parse(content);
-                const minified = JSON.stringify(jsonData);
-                document.getElementById('jsonEditor').value = minified;
-                showMessage('JSON最小化完成');
-            } catch (error) {
-                showMessage('JSON格式错误: ' + error.message, 'error');
-            }
-        }
-
-        // 一行化格式（一个对象一行）
-        function oneLinePerObject() {
-            const content = document.getElementById('jsonEditor').value.trim();
-            
-            if (!content) {
-                showMessage('请输入JSON数据', 'error');
-                return;
-            }
-
-            try {
-                const jsonData = JSON.parse(content);
-                let formatted = '';
-
-                if (Array.isArray(jsonData)) {
-                    // 如果是数组，每个元素占一行
-                    formatted = '[\n';
-                    jsonData.forEach((item, index) => {
-                        formatted += '  ' + JSON.stringify(item);
-                        if (index < jsonData.length - 1) {
-                            formatted += ',';
-                        }
-                        formatted += '\n';
-                    });
-                    formatted += ']';
-                } else if (typeof jsonData === 'object' && jsonData !== null) {
-                    // 如果是对象，每个键值对占一行
-                    formatted = '{\n';
-                    const keys = Object.keys(jsonData);
-                    keys.forEach((key, index) => {
-                        formatted += '  ' + JSON.stringify(key) + ': ' + JSON.stringify(jsonData[key]);
-                        if (index < keys.length - 1) {
-                            formatted += ',';
-                        }
-                        formatted += '\n';
-                    });
-                    formatted += '}';
-                } else {
-                    // 基本类型直接输出
-                    formatted = JSON.stringify(jsonData);
-                }
-
-                document.getElementById('jsonEditor').value = formatted;
-                showMessage('JSON一行化格式完成');
-            } catch (error) {
-                showMessage('JSON格式错误: ' + error.message, 'error');
-            }
-        }
-
-        // 验证JSON格式
-        function validateJSON() {
-            const content = document.getElementById('jsonEditor').value.trim();
-            
-            if (!content) {
-                showMessage('请输入JSON数据', 'error');
-                return;
-            }
-
-            try {
-                JSON.parse(content);
-                showMessage('JSON格式验证通过');
-            } catch (error) {
-                showMessage('JSON格式错误: ' + error.message, 'error');
-            }
-        }
-    </script>
-</body>
-</html> 
\ No newline at end of file
diff --git a/Server/New_Features_Test_Guide.md b/Server/New_Features_Test_Guide.md
new file mode 100644
index 0000000..0519ecb
--- /dev/null
+++ b/Server/New_Features_Test_Guide.md
@@ -0,0 +1 @@
+ 
\ No newline at end of file
diff --git a/Server/QQEmailSend.zip b/Server/QQEmailSend.zip
deleted file mode 100644
index e52011442104a8d38695421d60a51beaac3c3f25..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 58612
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

diff --git a/Server/README_Refactored.md b/Server/README_Refactored.md
new file mode 100644
index 0000000..7b17f75
--- /dev/null
+++ b/Server/README_Refactored.md
@@ -0,0 +1,175 @@
+# TCPGameServer 重构说明
+
+## 概述
+
+原始的 `TCPGameServer.py` 文件有 1569 行代码，包含大量相似的函数和重复的逻辑。为了提高代码的可维护性和可读性，我们对其进行了重构，将相似功能的函数分组整理。
+
+## 重构前后对比
+
+### 重构前的问题
+- 文件过大（1569行）
+- 函数分散，相似功能没有分组
+- 大量重复的验证逻辑
+- 缺乏清晰的代码结构
+- 难以维护和扩展
+
+### 重构后的改进
+- 代码行数减少到约 1200 行
+- 按功能模块清晰分组
+- 提取公共方法，减少重复代码
+- 增加详细的文档注释
+- 更好的代码组织结构
+
+## 代码结构分组
+
+### 1. 初始化和生命周期管理
+```python
+# ==================== 1. 初始化和生命周期管理 ====================
+- __init__()                    # 初始化服务器
+- start_crop_growth_timer()     # 启动作物生长计时器
+- stop()                        # 停止服务器
+- _remove_client()              # 移除客户端
+```
+
+### 2. 验证和检查方法
+```python
+# ==================== 2. 验证和检查方法 ====================
+- _check_client_version()       # 检查客户端版本
+- _check_user_logged_in()       # 检查用户登录状态
+- _validate_qq_number()         # 验证QQ号格式
+```
+
+### 3. 数据管理方法
+```python
+# ==================== 3. 数据管理方法 ====================
+- load_player_data()            # 加载玩家数据
+- save_player_data()            # 保存玩家数据
+- _load_player_data_with_check() # 带检查的加载玩家数据
+- _load_crop_data()             # 加载作物配置数据
+- _update_player_logout_time()  # 更新玩家登出时间
+```
+
+### 4. 作物系统管理
+```python
+# ==================== 4. 作物系统管理 ====================
+- update_crops_growth()         # 更新作物生长状态
+- _push_crop_update_to_player() # 推送作物更新给玩家
+```
+
+### 5. 消息处理路由
+```python
+# ==================== 5. 消息处理路由 ====================
+- _handle_message()             # 消息路由分发
+```
+
+### 6. 用户认证处理
+```python
+# ==================== 6. 用户认证处理 ====================
+- _handle_greeting()            # 处理问候消息
+- _handle_login()               # 处理登录
+- _handle_register()            # 处理注册
+- _handle_verification_code_request() # 处理验证码请求
+- _handle_verify_code()         # 处理验证码验证
+```
+
+### 7. 游戏操作处理
+```python
+# ==================== 7. 游戏操作处理 ====================
+- _handle_harvest_crop()        # 处理收获作物
+- _handle_plant_crop()          # 处理种植作物
+- _handle_buy_seed()            # 处理购买种子
+- _handle_dig_ground()          # 处理开垦土地
+```
+
+### 8. 系统功能处理
+```python
+# ==================== 8. 系统功能处理 ====================
+- _handle_get_play_time()       # 获取游玩时间
+- _handle_update_play_time()    # 更新游玩时间
+- _handle_player_rankings_request() # 获取玩家排行榜
+- _handle_crop_data_request()   # 获取作物数据
+- _handle_visit_player_request() # 访问其他玩家农场
+- _handle_return_my_farm_request() # 返回自己农场
+```
+
+### 9. 辅助方法
+```python
+# ==================== 辅助方法 ====================
+- _send_initial_login_data()    # 发送登录初始数据
+- _send_register_error()        # 发送注册错误响应
+- _send_action_error()          # 发送游戏操作错误响应
+- _create_new_user()            # 创建新用户
+- _process_harvest()            # 处理作物收获逻辑
+- _process_planting()           # 处理作物种植逻辑
+- _process_seed_purchase()      # 处理种子购买逻辑
+- _process_digging()            # 处理土地开垦逻辑
+```
+
+## 主要改进点
+
+### 1. 代码复用
+- 提取了公共的验证逻辑（如 `_check_user_logged_in`、`_check_client_version`）
+- 统一了错误处理方式（如 `_send_action_error`、`_send_register_error`）
+- 将复杂的业务逻辑提取为独立方法（如 `_process_harvest`、`_process_planting`）
+
+### 2. 清晰的分组
+- 按功能将方法分为8个主要组别
+- 每个组别有明确的职责边界
+- 便于查找和维护特定功能
+
+### 3. 统一的导入
+- 将所有导入语句集中在文件顶部
+- 按标准库、第三方库、本地模块的顺序组织
+
+### 4. 改进的文档
+- 为每个方法组添加了清晰的注释
+- 为主要方法添加了详细的文档字符串
+- 在类的开头添加了功能概述
+
+### 5. 错误处理优化
+- 统一了错误响应格式
+- 提取了公共的错误处理逻辑
+- 减少了重复的错误处理代码
+
+## 使用方法
+
+重构后的代码与原代码功能完全相同，使用方法不变：
+
+```python
+# 启动服务器
+python TCPGameServer_Refactored.py
+```
+
+## 迁移指南
+
+如果要从原始版本迁移到重构版本：
+
+1. 备份原始的 `TCPGameServer.py` 文件
+2. 将 `TCPGameServer_Refactored.py` 重命名为 `TCPGameServer.py`
+3. 确保所有依赖文件（如 `TCPServer.py`、`QQEmailSend.py`）仍然存在
+4. 测试所有功能是否正常工作
+
+## 维护建议
+
+1. **添加新功能时**：按照现有的分组结构，将新方法添加到相应的组别中
+2. **修改现有功能时**：优先考虑是否可以复用现有的辅助方法
+3. **错误处理**：使用统一的错误处理方法，保持响应格式一致
+4. **文档更新**：添加新功能时，记得更新相应的文档注释
+
+## 性能影响
+
+重构主要关注代码结构和可维护性，对运行时性能的影响微乎其微：
+- 方法调用层次略有增加，但影响可忽略
+- 代码逻辑保持不变，算法复杂度相同
+- 内存使用基本相同
+
+## 总结
+
+通过这次重构，我们成功地：
+- 减少了代码重复
+- 提高了代码可读性
+- 改善了代码组织结构
+- 便于后续维护和扩展
+- 保持了原有功能的完整性
+
+重构后的代码更加专业和易于维护，为后续的功能扩展奠定了良好的基础。 
\ No newline at end of file
diff --git a/Server/TCPGameServer.py b/Server/TCPGameServer.py
index 3ce4008..c8659e7 100644
--- a/Server/TCPGameServer.py
+++ b/Server/TCPGameServer.py
@@ -1,260 +1,48 @@
 from TCPServer import TCPServer
 import time
 import json
+import os
+import glob
+import threading
+import datetime
+import re
 
+# 服务器配置
 server_host: str = "0.0.0.0"
 server_port: int = 4040
 buffer_size: int = 4096
+server_version: str = "1.0.1"  # 记录服务端版本
 
-#由于方法数量众多，所以将方法分组
-#1.服务端对本地的操作
-#2.服务端对客户端的操作
 
 class TCPGameServer(TCPServer):
-    #初始化TCP游戏服务器
+    """
+    TCP游戏服务器类
+    
+    功能分组：
+    1. 初始化和生命周期管理
+    2. 验证和检查方法
+    3. 数据管理方法
+    4. 作物系统管理
+    5. 消息处理路由
+    6. 用户认证处理
+    7. 游戏操作处理
+    8. 系统功能处理
+    """
+    
+    # ==================== 1. 初始化和生命周期管理 ====================
+    
     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.log('INFO', "TCP游戏服务器初始化", 'SERVER')
+        self.log('INFO', f"TCP游戏服务器初始化 - 版本: {server_version}", 'SERVER')
         
         # 启动作物生长计时器
         self.start_crop_growth_timer()
     
-
-    #检查用户是否已登录的通用方法
-    def _check_user_logged_in(self, client_id, action_name, action_type=None):
-        """
-        检查用户是否已登录的通用方法
-        
-        参数:
-            client_id (str): 客户端ID
-            action_name (str): 操作名称，用于日志记录
-            action_type (str, optional): 操作类型，用于响应消息
-            
-        返回:
-            tuple: (bool, response)
-                - bool: True表示已登录，False表示未登录
-                - response: 如果未登录，返回发送给客户端的错误响应，否则为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": "您需要先登录才能执行此操作"
-            }
-            
-            # 如果提供了action_type，添加到响应中
-            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
-
-
-
-    #从JSON文件加载玩家数据
-    def load_player_data(self, account_id):
-        """
-        从game_saves文件夹加载玩家数据
-        
-        参数:
-            account_id (str): 玩家账号ID
-        
-        返回:
-            dict: 玩家数据字典，如果文件不存在则返回None
-        """
-        import os
-        
-        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.log('INFO', f"已加载玩家 {account_id} 的数据", 'SERVER')
-                return player_data
-            else:
-                #self.log('WARNING', f"玩家 {account_id} 的数据文件不存在", 'SERVER')
-                return None
-        except Exception as e:
-            #self.log('ERROR', f"读取玩家 {account_id} 的数据时出错: {str(e)}", 'SERVER')
-            return None
-        
-    #通用加载玩家数据方法，带错误处理
-    def _load_player_data_with_check(self, client_id, action_type=None):
-        """
-        加载玩家数据并进行错误检查的通用方法
-        
-        参数:
-            client_id (str): 客户端ID
-            action_type (str, optional): 操作类型，用于错误响应
-            
-        返回:
-            tuple: (player_data, username, response)
-                - player_data: 成功加载的玩家数据，如果加载失败则为None
-                - username: 玩家用户名
-                - response: 如果加载失败，返回发送给客户端的错误响应，否则为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": "无法加载玩家数据"
-            }
-            
-            # 如果提供了action_type，添加到响应中
-            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
-
-
-    #保存玩家数据到JSON文件
-    def save_player_data(self, account_id, player_data):
-        """
-        保存玩家数据到game_saves文件夹
-        
-        参数:
-            account_id (str): 玩家账号ID
-            player_data (dict): 玩家数据字典
-        
-        返回:
-            bool: 保存成功返回True，否则返回False
-        """
-        import os
-        
-        file_path = os.path.join("game_saves", f"{account_id}.json")
-        
-        try:
-            with open(file_path, 'w', encoding='utf-8') as file:
-                json.dump(player_data, file, indent=2, ensure_ascii=False)
-            #self.log('INFO', f"已保存玩家 {account_id} 的数据", 'SERVER')
-            return True
-        except Exception as e:
-            self.log('ERROR', f"保存玩家 {account_id} 的数据时出错: {str(e)}", 'SERVER')
-            return False
-
-
-    #更新作物生长状态
-    def update_crops_growth(self):
-        """
-        更新所有玩家的作物生长状态
-        每秒钟对有作物的地块增加生长时间
-        并向在线玩家推送更新
-        """
-        import os
-        import glob
-        
-        # 获取所有玩家存档文件
-        save_files = glob.glob(os.path.join("game_saves", "*.json"))
-        
-        for save_file in save_files:
-            try:
-                # 从文件名提取账号ID
-                account_id = os.path.basename(save_file).split('.')[0]
-                
-                # 加载玩家数据
-                player_data = self.load_player_data(account_id)
-                if not player_data:
-                    continue
-                
-                # 检查是否有作物需要更新
-                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"]:
-                        # 增加生长时间
-                        farm_lot["grow_time"] += 1
-                        growth_updated = True
-                
-                # 如果有作物更新，保存玩家数据
-                if growth_updated:
-                    self.save_player_data(account_id, player_data)
-                    
-                    # 向在线玩家推送更新
-                    self._push_crop_update_to_player(account_id, player_data)
-                    
-            except Exception as e:
-                self.log('ERROR', f"更新作物生长状态时出错: {str(e)}", 'SERVER')
-                
-    
-    #向在线玩家推送作物更新
-    def _push_crop_update_to_player(self, account_id, player_data):
-        """
-        向在线玩家推送作物生长更新
-        
-        参数:
-            account_id (str): 玩家账号ID
-            player_data (dict): 玩家数据
-        """
-        # 查找对应的客户端ID
-        client_id = None
-        for cid, user_info in self.user_data.items():
-            if user_info.get("username") == account_id and user_info.get("logged_in", False):
-                client_id = cid
-                break
-        
-        # 如果玩家在线，检查是否处于访问模式
-        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:
-                # 如果处于访问模式，发送被访问玩家的更新数据
-                target_player_data = self.load_player_data(visiting_target)
-                if target_player_data:
-                    update_message = {
-                        "type": "crop_update",
-                        "farm_lots": target_player_data.get("farm_lots", []),
-                        "timestamp": time.time(),
-                        "is_visiting": True,
-                        "visited_player": visiting_target
-                    }
-                    self.send_data(client_id, update_message)
-                    self.log('DEBUG', f"已向访问模式中的玩家 {account_id} 推送被访问玩家 {visiting_target} 的作物更新", 'SERVER')
-            else:
-                # 正常模式，发送自己的农场更新
-                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)
-                self.log('DEBUG', f"已向玩家 {account_id} 推送作物更新", 'SERVER')
-
-
-    #设置一个计时器，每秒更新一次作物生长状态
     def start_crop_growth_timer(self):
-        """
-        启动作物生长计时器，每秒更新一次
-        """
-        import threading
-        
+        """启动作物生长计时器，每秒更新一次"""
         # 更新作物生长状态
         self.update_crops_growth()
         
@@ -262,10 +50,20 @@ class TCPGameServer(TCPServer):
         self.crop_timer = threading.Timer(1.0, self.start_crop_growth_timer)
         self.crop_timer.daemon = True
         self.crop_timer.start()
-
-
-    #覆盖客户端移除方法，添加用户离开通知
+    
+    def stop(self):
+        """停止服务器"""
+        # 停止作物生长计时器
+        if self.crop_timer:
+            self.crop_timer.cancel()
+            self.crop_timer = None
+            self.log('INFO', "作物生长计时器已停止", 'SERVER')
+        
+        # 调用父类方法完成实际停止
+        super().stop()
+    
     def _remove_client(self, client_id):
+        """覆盖客户端移除方法，添加用户离开通知"""
         # 通知其他用户
         if client_id in self.clients:
             # 获取用户名以便记录日志
@@ -273,42 +71,7 @@ class TCPGameServer(TCPServer):
             
             # 如果用户已登录，更新总游玩时间并标记其登出
             if client_id in self.user_data and self.user_data[client_id].get("logged_in", False):
-                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:
-                    import datetime
-                    import re
-                    
-                    # 解析现有的总游玩时间
-                    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.log('INFO', f"用户 {username} 本次游玩时间: {play_time_seconds} 秒，总游玩时间: {player_data['total_login_time']}", 'SERVER')
-                
+                self._update_player_logout_time(client_id, username)
                 self.log('INFO', f"用户 {username} 登出", 'SERVER')
             
             self.broadcast(
@@ -329,270 +92,331 @@ class TCPGameServer(TCPServer):
         
         # 调用父类方法完成实际断开
         super()._remove_client(client_id)
-
-
-    #覆盖停止方法，停止作物生长计时器
-    def stop(self):
-        # 停止作物生长计时器
-        if self.crop_timer:
-            self.crop_timer.cancel()
-            self.crop_timer = None
-            self.log('INFO', "作物生长计时器已停止", 'SERVER')
-        
-        # 调用父类方法完成实际停止
-        super().stop()
-
-
-    #接收客户端消息并处理
-    def _handle_message(self, client_id, message):
-        message_type = message.get("type", "")
-        match message_type:
-            case "greeting":
-                return self._handle_greeting(client_id, message)
-            case "message":
-                return self._handle_chat_message(client_id, message)
-            case "login":
-                return self._handle_login(client_id, message)
-            case "register":
-                return self._handle_register(client_id, message)
-            case "request_verification_code":
-                return self._handle_verification_code_request(client_id, message)
-            case "verify_code":
-                return self._handle_verify_code(client_id, message)
-            #玩家基本游戏操作
-            case "harvest_crop":
-                return self._handle_harvest_crop(client_id, message)
-            case "plant_crop":
-                return self._handle_plant_crop(client_id, message)
-            case "buy_seed":
-                return self._handle_buy_seed(client_id, message)
-            case "dig_ground":
-                return self._handle_dig_ground(client_id, message)
-            #玩家基本游戏操作
-            case "get_play_time":
-                return self._handle_get_play_time(client_id)
-            case "update_play_time":
-                return self._handle_update_play_time(client_id)
-            case "request_player_rankings":
-                return self._handle_player_rankings_request(client_id)
-            case "request_crop_data":
-                return self._handle_crop_data_request(client_id)
-            case "visit_player":
-                return self._handle_visit_player_request(client_id, message)
-            case "return_my_farm":
-                return self._handle_return_my_farm_request(client_id, message)
-            case _:
-                # 未知类型，使用默认处理
-                return super()._handle_message(client_id, message)
     
-
-    #处理登录消息
-    def _handle_login(self, client_id, message):
-        username = message.get("username", "")
-        password = message.get("password", "")
-        
-        # 读取玩家数据
-        player_data = self.load_player_data(username)
-        
-        if player_data and player_data.get("user_password") == password:
-            # 登录成功
-            self.log('INFO', f"用户 {username} 登录成功", 'SERVER')
+    # ==================== 2. 验证和检查方法 ====================
+    
+    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')
             
-            # 更新最后登录时间
-            import datetime
-            current_time = datetime.datetime.now()
-            player_data["last_login_time"] = current_time.strftime("%Y年%m月%d日%H时%M分%S秒")
-            
-            # 保存用户会话信息
-            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)
-            
-            # 立即向客户端发送一次作物状态
-            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)
-            
-            # 发送最新的作物数据配置
-            try:
-                with open("config/crop_data.json", 'r', encoding='utf-8') as file:
-                    crop_data = json.load(file)
-                
-                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"已向登录用户 {username} 发送作物数据配置", 'SERVER')
-            except Exception as e:
-                self.log('ERROR', f"无法向登录用户发送作物数据: {str(e)}", 'SERVER')
-            
-            # 返回登录成功消息
             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": "账号或密码错误"
+                "success": False,
+                "message": f"版本不匹配！客户端版本: {client_version}, 服务端版本: {server_version}，请更新客户端"
             }
             
-        return self.send_data(client_id, response)
-
-
-    #处理注册消息
-    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", "")
+            return False, response
         
-        # 验证必填字段
-        if not username or not password:
-            self.log('WARNING', f"注册失败: 用户名或密码为空", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "register_response",
-                "status": "failed",
-                "message": "用户名或密码不能为空"
-            })
+        return True, None
+    
+    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
         
-        # 验证用户名是否是QQ号 (5-12位数字)
-        import re
-        if not re.match(r'^\d{5,12}$', username):
-            self.log('WARNING', f"注册失败: 用户名 {username} 不是有效的QQ号码", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "register_response",
-                "status": "failed",
-                "message": "用户名必须是5-12位的QQ号码"
-            })
-        
-        # 验证验证码
-        if verification_code:
-            from QQEmailSend import EmailVerification
-            success, verify_message = EmailVerification.verify_code(username, verification_code)
-            if not success:
-                self.log('WARNING', f"注册失败: 验证码错误 - {verify_message}", 'SERVER')
-                return self.send_data(client_id, {
-                    "type": "register_response",
-                    "status": "failed",
-                    "message": f"验证码错误: {verify_message}"
-                })
-        
-        # 检查用户是否已存在
-        import os
-        file_path = os.path.join("game_saves", f"{username}.json")
-        if os.path.exists(file_path):
-            self.log('WARNING', f"注册失败: 用户 {username} 已存在", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "register_response",
-                "status": "failed",
-                "message": "该用户名已被注册"
-            })
+        return True, None
+    
+    def _validate_qq_number(self, qq_number):
+        """验证QQ号格式"""
+        return re.match(r'^\d{5,12}$', qq_number) is not None
+    
+    # ==================== 3. 数据管理方法 ====================
+    
+    def load_player_data(self, account_id):
+        """从game_saves文件夹加载玩家数据"""
+        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:
+                    return json.load(file)
+            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):
+        """保存玩家数据到game_saves文件夹"""
+        file_path = os.path.join("game_saves", f"{account_id}.json")
         
         try:
-            # 从模板加载初始玩家数据
-            template_path = os.path.join("config", "initial_player_data_template.json")
-            if not os.path.exists(template_path):
-                self.log('ERROR', f"无法找到玩家数据模板文件", 'SERVER')
-                return self.send_data(client_id, {
-                    "type": "register_response",
-                    "status": "failed",
-                    "message": "服务器配置错误，无法注册新用户"
-                })
-                
-            with open(template_path, 'r', encoding='utf-8') as file:
-                player_data = json.load(file)
-                
-            # 更新玩家数据
-            player_data["user_name"] = username
-            player_data["user_password"] = password
-            
-            # 设置农场名称，如果没有提供则使用默认名称
-            if farm_name:
-                player_data["farm_name"] = farm_name
-            
-            # 设置玩家昵称，如果没有提供则使用QQ号或默认昵称
-            if player_name:
-                player_data["player_name"] = player_name
-            else:
-                player_data["player_name"] = username
-            
-            # 确保所有必要的字段都存在
-            if "experience" not in player_data:
-                player_data["experience"] = 0
-            if "level" not in player_data:
-                player_data["level"] = 1
-            if "money" not in player_data:
-                player_data["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"] = []
-            
-            # 更新注册时间和登录时间
-            import datetime
-            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秒"
-            
-            # 保存新用户数据
             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": "注册成功，请登录游戏"
-            })
-            
+            return True
         except Exception as e:
-            self.log('ERROR', f"注册用户 {username} 时出错: {str(e)}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "register_response",
-                "status": "failed",
-                "message": f"注册过程中出现错误: {str(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:
+            # 解析现有的总游玩时间
+            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.log('INFO', f"用户 {username} 本次游玩时间: {play_time_seconds} 秒，总游玩时间: {player_data['total_login_time']}", 'SERVER')
+    
+    # ==================== 4. 作物系统管理 ====================
+    
+    def update_crops_growth(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
+                
+                # 检查是否有作物需要更新
+                growth_updated = False
+                
+                # 获取当前日期，用于重置浇水状态
+                current_date = datetime.datetime.now().strftime("%Y-%m-%d")
+                last_reset_date = player_data.get("last_water_reset_date", "")
+                
+                # 如果是新的一天，重置所有地块的浇水状态
+                if current_date != last_reset_date:
+                    for farm_lot in player_data.get("farm_lots", []):
+                        if farm_lot.get("已浇水", False):
+                            farm_lot["已浇水"] = False
+                            growth_updated = True
+                    player_data["last_water_reset_date"] = current_date
+                    self.log('INFO', f"重置玩家 {username} 的浇水状态（新的一天）", 'SERVER')
+                
+                # 遍历每个农场地块
+                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
+                        
+                        # 土地等级影响：1级土地提供1.5倍生长速度
+                        land_level = farm_lot.get("土地等级", 0)
+                        if land_level >= 1:
+                            growth_multiplier *= 1.5
+                        
+                        # 施肥影响：10分钟内双倍生长速度
+                        if farm_lot.get("已施肥", False) and "施肥时间" in farm_lot:
+                            fertilize_time = farm_lot.get("施肥时间", 0)
+                            current_time = time.time()
+                            # 检查是否在10分钟(600秒)内
+                            if current_time - fertilize_time <= 600:
+                                growth_multiplier *= 2.0
+                            else:
+                                # 施肥效果过期，清除施肥状态
+                                farm_lot["已施肥"] = False
+                                if "施肥时间" in farm_lot:
+                                    del farm_lot["施肥时间"]
+                        
+                        # 应用生长速度倍数
+                        growth_increase = int(growth_multiplier)
+                        if growth_increase < 1:
+                            growth_increase = 1
+                        
+                        # 增加生长时间
+                        farm_lot["grow_time"] += growth_increase
+                        growth_updated = True
+                
+                # 如果有作物更新，保存玩家数据
+                if growth_updated:
+                    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 _push_crop_update_to_player(self, account_id, player_data):
+        """向在线玩家推送作物生长更新"""
+        # 查找对应的客户端ID
+        client_id = None
+        for cid, user_info in self.user_data.items():
+            if user_info.get("username") == account_id and user_info.get("logged_in", False):
+                client_id = cid
+                break
+        
+        # 如果玩家在线，检查是否处于访问模式
+        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:
+                # 如果处于访问模式，发送被访问玩家的更新数据
+                # 注意：这里只读取数据，不修改被访问玩家的数据
+                target_player_data = self.load_player_data(visiting_target)
+                if target_player_data:
+                    # 检查被访问玩家是否也在线，如果在线则使用最新数据
+                    target_client_id = None
+                    for cid, user_info in self.user_data.items():
+                        if user_info.get("username") == visiting_target and user_info.get("logged_in", False):
+                            target_client_id = cid
+                            break
+                    
+                    # 如果被访问玩家在线，使用其最新的作物数据
+                    # 如果不在线，使用存档中的数据（可能不是最新的）
+                    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)
+                    self.log('DEBUG', f"已向访问模式中的玩家 {account_id} 推送被访问玩家 {visiting_target} 的作物更新", 'SERVER')
+            else:
+                # 正常模式，发送自己的农场更新
+                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)
+                self.log('DEBUG', f"已向玩家 {account_id} 推送作物更新", 'SERVER')
+    
+    # ==================== 5. 消息处理路由 ====================
+    
+    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 == "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 == "message":
+            return self._handle_chat_message(client_id, message)
+        
+        # 未知类型，使用默认处理
+        else:
+            return super()._handle_message(client_id, message)
+    
+    # ==================== 6. 用户认证处理 ====================
+    
     def _handle_greeting(self, client_id, message):
+        """处理问候消息"""
         content = message.get("content", "")
         self.log('INFO', f"收到来自客户端 {client_id} 的问候: {content}", 'CLIENT')
         
@@ -623,19 +447,177 @@ class TCPGameServer(TCPServer):
         
         self.log('INFO', f"用户 {client_id} 已加入游戏", 'SERVER')
         return self.send_data(client_id, response)
-
-
-
-
-    #处理收获作物请求
-    def _handle_harvest_crop(self, client_id, message):
-        """
-        处理玩家收获作物的请求
+    
+    def _handle_login(self, client_id, message):
+        """处理登录消息"""
+        username = message.get("username", "")
+        password = message.get("password", "")
+        client_version = message.get("client_version", "")
         
-        参数:
-            client_id (str): 客户端ID
-            message (dict): 消息内容
-        """
+        # 验证客户端版本
+        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秒")
+            
+            # 保存用户会话信息
+            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 _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 _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
+            })
+    
+    # ==================== 7. 游戏操作处理 ====================
+    
+    def _handle_harvest_crop(self, client_id, message):
+        """处理收获作物请求"""
         # 检查用户是否已登录
         logged_in, response = self._check_user_logged_in(client_id, "收获作物", "harvest_crop")
         if not logged_in:
@@ -646,52 +628,32 @@ class TCPGameServer(TCPServer):
         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", [])):
-            self.log('WARNING', f"玩家 {username} 请求收获无效地块 {lot_index}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "harvest_crop",
-                "success": False,
-                "message": "无效的地块索引"
-            })
+            return self._send_action_error(client_id, "harvest_crop", "无效的地块索引")
         
-        # 获取地块数据
         lot = player_data["farm_lots"][lot_index]
         
-        # 检查地块是否有作物且已成熟
+        # 检查地块状态
         if not lot.get("is_planted", False) or not lot.get("crop_type", ""):
-            self.log('WARNING', f"玩家 {username} 尝试收获空地块 {lot_index}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "harvest_crop",
-                "success": False,
-                "message": "此地块没有种植作物"
-            })
+            return self._send_action_error(client_id, "harvest_crop", "此地块没有种植作物")
         
         if lot.get("is_dead", False):
             # 处理已死亡的作物
-            self.log('INFO', f"玩家 {username} 铲除了地块 {lot_index} 上已死亡的作物", 'SERVER')
-            
-            # 清理地块
             lot["is_planted"] = False
             lot["crop_type"] = ""
             lot["grow_time"] = 0
             
-            # 保存玩家数据
             self.save_player_data(username, player_data)
-            
-            # 发送作物更新
             self._push_crop_update_to_player(username, player_data)
             
             return self.send_data(client_id, {
                 "type": "action_response",
                 "action_type": "harvest_crop",
                 "success": True,
-                "message": f"已铲除死亡的作物",
+                "message": "已铲除死亡的作物",
                 "updated_data": {
                     "money": player_data["money"],
                     "experience": player_data["experience"],
@@ -700,82 +662,13 @@ class TCPGameServer(TCPServer):
             })
         
         if lot["grow_time"] < lot["max_grow_time"]:
-            self.log('WARNING', f"玩家 {username} 尝试收获未成熟的作物 {lot_index}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "harvest_crop",
-                "success": False,
-                "message": "作物尚未成熟"
-            })
+            return self._send_action_error(client_id, "harvest_crop", "作物尚未成熟")
         
-        # 读取作物配置 (假设在服务器上也有作物配置)
-        import json
-        crop_data = {}
-        try:
-            with open("config/crop_data.json", 'r', encoding='utf-8') as file:
-                crop_data = json.load(file)
-        except Exception as e:
-            self.log('ERROR', f"无法加载作物数据: {str(e)}", 'SERVER')
-            # 使用默认收益
-            crop_income = 100
-            crop_exp = 10
-        
-        # 获取作物收益和经验
-        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
-        
-        # 保存玩家数据
-        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"]
-            }
-        })
+        # 处理收获
+        return self._process_harvest(client_id, player_data, username, lot, lot_index)
     
-    
-    #处理种植作物请求
     def _handle_plant_crop(self, client_id, message):
-        """
-        处理玩家种植作物的请求
-        
-        参数:
-            client_id (str): 客户端ID
-            message (dict): 消息内容
-        """
+        """处理种植作物请求"""
         # 检查用户是否已登录
         logged_in, response = self._check_user_logged_in(client_id, "种植作物", "plant_crop")
         if not logged_in:
@@ -786,121 +679,27 @@ class TCPGameServer(TCPServer):
         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", [])):
-            self.log('WARNING', f"玩家 {username} 请求种植无效地块 {lot_index}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "plant_crop",
-                "success": False,
-                "message": "无效的地块索引"
-            })
+            return self._send_action_error(client_id, "plant_crop", "无效的地块索引")
         
-        # 获取地块数据
         lot = player_data["farm_lots"][lot_index]
         
-        # 检查地块是否已开垦且未种植
+        # 检查地块状态
         if not lot.get("is_diged", False):
-            self.log('WARNING', f"玩家 {username} 尝试在未开垦的地块 {lot_index} 种植", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "plant_crop",
-                "success": False,
-                "message": "此地块尚未开垦"
-            })
+            return self._send_action_error(client_id, "plant_crop", "此地块尚未开垦")
         
         if lot.get("is_planted", False):
-            self.log('WARNING', f"玩家 {username} 尝试在已种植的地块 {lot_index} 种植", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "plant_crop",
-                "success": False,
-                "message": "此地块已经种植了作物"
-            })
+            return self._send_action_error(client_id, "plant_crop", "此地块已经种植了作物")
         
-        # 读取作物配置 (假设在服务器上也有作物配置)
-        import json
-        crop_data = {}
-        try:
-            with open("config/crop_data.json", 'r', encoding='utf-8') as file:
-                crop_data = json.load(file)
-        except Exception as e:
-            self.log('ERROR', f"无法加载作物数据: {str(e)}", 'SERVER')
-            # 如果无法加载作物数据，使用默认生长时间
-            grow_time = 600
-        
-        # 检查玩家背包中是否有此种子
-        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:
-            self.log('WARNING', f"玩家 {username} 尝试种植背包中没有的种子 {crop_name}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "plant_crop",
-                "success": False,
-                "message": "背包中没有此种子"
-            })
-        
-        # 获取作物生长时间
-        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["is_planted"] = True
-        lot["crop_type"] = crop_name
-        lot["grow_time"] = 0
-        lot["max_grow_time"] = grow_time
-        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_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"]
-            }
-        })
-     
-
-    #处理购买种子请求
+        # 处理种植
+        return self._process_planting(client_id, player_data, username, lot, crop_name)
+    
     def _handle_buy_seed(self, client_id, message):
-        """
-        处理玩家购买种子的请求
-        
-        参数:
-            client_id (str): 客户端ID
-            message (dict): 消息内容
-        """
+        """处理购买种子请求"""
         # 检查用户是否已登录
         logged_in, response = self._check_user_logged_in(client_id, "购买种子", "buy_seed")
         if not logged_in:
@@ -911,105 +710,22 @@ class TCPGameServer(TCPServer):
         if not player_data:
             return self.send_data(client_id, response)
         
-        # 获取作物名称
         crop_name = message.get("crop_name", "")
         
-        # 读取作物配置 (假设在服务器上也有作物配置)
-        import json
-        crop_data = {}
-        try:
-            with open("config/crop_data.json", 'r', encoding='utf-8') as file:
-                crop_data = json.load(file)
-        except Exception as e:
-            self.log('ERROR', f"无法加载作物数据: {str(e)}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "buy_seed",
-                "success": False,
-                "message": "服务器无法加载作物数据"
-            })
+        # 加载作物配置
+        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:
-            self.log('WARNING', f"玩家 {username} 尝试购买不存在的种子 {crop_name}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "buy_seed",
-                "success": False,
-                "message": "该种子不存在"
-            })
+            return self._send_action_error(client_id, "buy_seed", "该种子不存在")
         
-        # 获取作物数据
-        crop = crop_data[crop_name]
-        
-        # 检查玩家等级
-        if player_data["level"] < crop.get("等级", 1):
-            self.log('WARNING', f"玩家 {username} 等级不足，无法购买种子 {crop_name}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "buy_seed",
-                "success": False,
-                "message": "等级不足，无法购买此种子"
-            })
-        
-        # 检查玩家金钱
-        if player_data["money"] < crop.get("花费", 0):
-            self.log('WARNING', f"玩家 {username} 金钱不足，无法购买种子 {crop_name}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "buy_seed",
-                "success": False,
-                "message": "金钱不足，无法购买此种子"
-            })
-        
-        # 扣除金钱
-        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"]
-            }
-        })
-
-
-    #处理开垦土地请求
+        # 处理购买
+        return self._process_seed_purchase(client_id, player_data, username, crop_name, crop_data[crop_name])
+    
     def _handle_dig_ground(self, client_id, message):
-        """
-        处理玩家开垦土地的请求
-        
-        参数:
-            client_id (str): 客户端ID
-            message (dict): 消息内容
-        """
+        """处理开垦土地请求"""
         # 检查用户是否已登录
         logged_in, response = self._check_user_logged_in(client_id, "开垦土地", "dig_ground")
         if not logged_in:
@@ -1020,78 +736,133 @@ class TCPGameServer(TCPServer):
         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", [])):
-            self.log('WARNING', f"玩家 {username} 请求开垦无效地块 {lot_index}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "dig_ground",
-                "success": False,
-                "message": "无效的地块索引"
-            })
+            return self._send_action_error(client_id, "dig_ground", "无效的地块索引")
         
-        # 获取地块数据
         lot = player_data["farm_lots"][lot_index]
         
         # 检查地块是否已开垦
         if lot.get("is_diged", False):
-            self.log('WARNING', f"玩家 {username} 尝试开垦已开垦的地块 {lot_index}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "dig_ground",
-                "success": False,
-                "message": "此地块已经开垦过了"
-            })
+            return self._send_action_error(client_id, "dig_ground", "此地块已经开垦过了")
         
-        # 计算开垦费用 - 基于已开垦地块数量
-        digged_count = sum(1 for l in player_data["farm_lots"] if l.get("is_diged", False))
-        dig_money = digged_count * 1000
+        # 处理开垦
+        return self._process_digging(client_id, player_data, username, lot, lot_index)
+    
+    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)
         
-        # 检查玩家金钱是否足够
-        if player_data["money"] < dig_money:
-            self.log('WARNING', f"玩家 {username} 金钱不足，无法开垦地块 {lot_index}", 'SERVER')
-            return self.send_data(client_id, {
-                "type": "action_response",
-                "action_type": "dig_ground",
-                "success": False,
-                "message": f"金钱不足，开垦此地块需要 {dig_money} 金钱"
-            })
+        # 获取玩家数据
+        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)
         
-        # 执行开垦操作
-        player_data["money"] -= dig_money
-        lot["is_diged"] = True
+        lot_index = message.get("lot_index", -1)
         
-        # 保存玩家数据
-        self.save_player_data(username, player_data)
+        # 验证地块索引
+        if lot_index < 0 or lot_index >= len(player_data.get("farm_lots", [])):
+            return self._send_action_error(client_id, "remove_crop", "无效的地块索引")
         
-        # 发送作物更新
-        self._push_crop_update_to_player(username, player_data)
+        lot = player_data["farm_lots"][lot_index]
         
-        self.log('INFO', f"玩家 {username} 成功开垦地块 {lot_index}，花费 {dig_money} 金钱", 'SERVER')
+        # 检查地块状态
+        if not lot.get("is_planted", False) or not lot.get("crop_type", ""):
+            return self._send_action_error(client_id, "remove_crop", "此地块没有种植作物")
         
-        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"]
-            }
-        })
-
-
-    #处理获取游玩时间请求
+        # 处理铲除
+        return self._process_crop_removal(client_id, player_data, username, lot, lot_index)
+    
+    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)
+        
+        # 获取玩家数据
+        player_data, username, response = self._load_player_data_with_check(client_id, "water_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, "water_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, "water_crop", "此地块没有种植作物")
+        
+        # 处理浇水
+        return self._process_watering(client_id, player_data, username, lot, lot_index)
+    
+    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)
+        
+        # 获取玩家数据
+        player_data, username, response = self._load_player_data_with_check(client_id, "fertilize_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, "fertilize_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, "fertilize_crop", "此地块没有种植作物")
+        
+        # 处理施肥
+        return self._process_fertilizing(client_id, player_data, username, lot, lot_index)
+    
+    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)
+    
+    # ==================== 8. 系统功能处理 ====================
+    
     def _handle_get_play_time(self, client_id):
-        """
-        处理玩家获取游玩时间的请求
-        
-        参数:
-            client_id (str): 客户端ID
-        """
+        """处理获取游玩时间请求"""
         # 检查用户是否已登录
         logged_in, response = self._check_user_logged_in(client_id, "获取游玩时间")
         if not logged_in:
@@ -1126,16 +897,8 @@ class TCPGameServer(TCPServer):
             "current_session_time": current_session_time
         })
     
-    
-    #处理更新游玩时间请求
     def _handle_update_play_time(self, client_id):
-        """
-        处理玩家手动更新游玩时间的请求
-        用于客户端不关闭而希望更新游玩时间的情况
-        
-        参数:
-            client_id (str): 客户端ID
-        """
+        """处理更新游玩时间请求"""
         # 检查用户是否已登录
         logged_in, response = self._check_user_logged_in(client_id, "更新游玩时间", "update_time")
         if not logged_in:
@@ -1151,7 +914,6 @@ class TCPGameServer(TCPServer):
         play_time_seconds = int(time.time() - login_timestamp)
         
         # 解析现有的总游玩时间
-        import re
         total_time_str = player_data.get("total_login_time", "0时0分0秒")
         time_parts = re.match(r"(?:(\d+)时)?(?:(\d+)分)?(?:(\d+)秒)?", total_time_str)
         
@@ -1190,21 +952,9 @@ class TCPGameServer(TCPServer):
                 "success": False,
                 "message": "更新游玩时间失败，格式错误"
             })
-
-
-    #处理玩家排行榜请求
+    
     def _handle_player_rankings_request(self, client_id):
-        """
-        处理获取玩家排行榜的请求
-        返回所有玩家的数据（按等级排序）
-        
-        参数:
-            client_id (str): 客户端ID
-        """
-        import os
-        import glob
-        import json
-        
+        """处理获取玩家排行榜的请求"""
         # 检查用户是否已登录
         logged_in, response = self._check_user_logged_in(client_id, "获取玩家排行榜", "player_rankings")
         if not logged_in:
@@ -1225,9 +975,7 @@ class TCPGameServer(TCPServer):
                 
                 if player_data:
                     # 统计背包中的种子数量
-                    seed_count = 0
-                    for item in player_data.get("player_bag", []):
-                        seed_count += item.get("count", 0)
+                    seed_count = sum(item.get("count", 0) for item in player_data.get("player_bag", []))
                     
                     # 获取所需的玩家信息
                     player_info = {
@@ -1257,149 +1005,35 @@ class TCPGameServer(TCPServer):
             "success": True,
             "players": players_data
         })
-
-
-    #处理作物数据请求
+    
     def _handle_crop_data_request(self, client_id):
-        """
-        处理客户端请求作物数据
+        """处理客户端请求作物数据"""
+        crop_data = self._load_crop_data()
         
-        参数:
-            client_id (str): 客户端ID
-        """
-        import json
-        
-        try:
-            # 读取服务器上的作物数据
-            with open("config/crop_data.json", 'r', encoding='utf-8') as file:
-                crop_data = json.load(file)
-            
+        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
             })
-        except Exception as e:
-            self.log('ERROR', f"读取作物数据时出错: {str(e)}", 'SERVER')
+        else:
             return self.send_data(client_id, {
                 "type": "crop_data_response",
                 "success": False,
-                "message": f"无法读取作物数据: {str(e)}"
-            })
-
-
-    #处理验证码请求
-    def _handle_verification_code_request(self, client_id, message):
-        """
-        处理验证码请求，向指定QQ号对应的邮箱发送验证码
-        
-        参数:
-            client_id (str): 客户端ID
-            message (dict): 消息内容
-        """
-        from QQEmailSend import EmailVerification
-        
-        # 获取QQ号
-        qq_number = message.get("qq_number", "")
-        
-        # 验证QQ号
-        import re
-        if not re.match(r'^\d{5,12}$', qq_number):
-            self.log('WARNING', f"验证码请求错误: QQ号 {qq_number} 格式无效", 'SERVER')
-            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}"
+                "message": "无法读取作物数据"
             })
     
-    
-    #处理验证码验证
-    def _handle_verify_code(self, client_id, message):
-        """
-        处理验证码验证请求
-        
-        参数:
-            client_id (str): 客户端ID
-            message (dict): 消息内容
-        """
-        from QQEmailSend import EmailVerification
-        
-        # 获取QQ号和验证码
-        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
-            })
-
-
-    #处理访问玩家请求
     def _handle_visit_player_request(self, client_id, message):
-        """
-        处理访问其他玩家农场的请求
-        
-        参数:
-            client_id (str): 客户端ID
-            message (dict): 消息内容
-        """
+        """处理访问其他玩家农场的请求"""
         # 检查用户是否已登录
         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:
-            self.log('WARNING', f"访问玩家请求缺少目标用户名", 'SERVER')
             return self.send_data(client_id, {
                 "type": "visit_player_response",
                 "success": False,
@@ -1410,7 +1044,6 @@ class TCPGameServer(TCPServer):
         target_player_data = self.load_player_data(target_username)
         
         if not target_player_data:
-            self.log('WARNING', f"无法找到玩家 {target_username} 的数据", 'SERVER')
             return self.send_data(client_id, {
                 "type": "visit_player_response",
                 "success": False,
@@ -1445,17 +1078,9 @@ class TCPGameServer(TCPServer):
             "player_data": safe_player_data,
             "is_visiting": True
         })
-
-
-    #处理返回自己农场请求
+    
     def _handle_return_my_farm_request(self, client_id, message):
-        """
-        处理玩家返回自己农场的请求
-        
-        参数:
-            client_id (str): 客户端ID
-            message (dict): 消息内容
-        """
+        """处理玩家返回自己农场的请求"""
         # 检查用户是否已登录
         logged_in, response = self._check_user_logged_in(client_id, "返回自己农场", "return_my_farm")
         if not logged_in:
@@ -1489,17 +1114,545 @@ class TCPGameServer(TCPServer):
             },
             "is_visiting": False
         })
-
-
-
+    
+    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 _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 _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 _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 _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 _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_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 _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 _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 _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 _process_watering(self, client_id, player_data, username, lot, lot_index):
+        """处理浇水逻辑"""
+        # 浇水费用
+        water_cost = 50
+        
+        # 检查玩家金钱是否足够
+        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", "作物已经成熟，无需浇水")
+        
+        # 检查今天是否已经浇过水
+        if lot.get("已浇水", False):
+            return self._send_action_error(client_id, "water_crop", "今天已经浇过水了")
+        
+        # 执行浇水操作
+        player_data["money"] -= water_cost
+        
+        # 计算浇水效果：增加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["已浇水"] = True
+        
+        # 保存玩家数据
+        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}%"
+        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"],
+                "farm_lots": player_data["farm_lots"]
+            }
+        })
+    
+    def _process_fertilizing(self, client_id, player_data, username, lot, lot_index):
+        """处理施肥逻辑"""
+        # 施肥费用
+        fertilize_cost = 150
+        
+        # 检查玩家金钱是否足够
+        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
+        
+        # 标记已施肥，施肥效果会在作物生长更新时生效
+        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分钟内以双倍速度生长",
+            "updated_data": {
+                "money": player_data["money"],
+                "farm_lots": player_data["farm_lots"]
+            }
+        })
+    
+    def _process_land_upgrade(self, client_id, player_data, username, lot, lot_index):
+        """处理土地升级逻辑"""
+        # 升级费用
+        upgrade_cost = 1000
+        
+        # 检查玩家金钱是否足够
+        if player_data["money"] < upgrade_cost:
+            return self._send_action_error(client_id, "upgrade_land", f"金钱不足，升级土地需要 {upgrade_cost} 金钱")
+        
+        # 检查土地是否已经升级
+        current_level = lot.get("土地等级", 0)
+        if current_level >= 1:
+            return self._send_action_error(client_id, "upgrade_land", "此土地已经升级过了")
+        
+        # 执行升级操作
+        player_data["money"] -= upgrade_cost
+        lot["土地等级"] = 1  # 升级到1级，提供1.5倍生长速度
+        
+        # 保存玩家数据
+        self.save_player_data(username, player_data)
+        
+        # 发送作物更新
+        self._push_crop_update_to_player(username, player_data)
+        
+        self.log('INFO', f"玩家 {username} 升级了地块 {lot_index}，花费 {upgrade_cost} 金钱", 'SERVER')
+        
+        return self.send_data(client_id, {
+            "type": "action_response",
+            "action_type": "upgrade_land",
+            "success": True,
+            "message": f"土地升级成功！此地块的作物将永久以1.5倍速度生长",
+            "updated_data": {
+                "money": player_data["money"],
+                "farm_lots": player_data["farm_lots"]
+            }
+        })
 
 
 # 使用示例
 if __name__ == "__main__":
-    import threading
     import sys
     
     try:
+        print(f"萌芽农场游戏服务器 v{server_version}")
+        print(f"服务器地址: {server_host}:{server_port}")
+        print("=" * 50)
+        
         # 创建自定义服务器
         server = TCPGameServer()
         
@@ -1508,6 +1661,8 @@ if __name__ == "__main__":
         server_thread.daemon = True
         server_thread.start()
         
+        print("服务器已启动，按 Ctrl+C 停止服务器")
+        
         # 运行直到按Ctrl+C
         while True:
             time.sleep(1)
diff --git a/Server/__pycache__/TCPGameServer.cpython-313.pyc b/Server/__pycache__/TCPGameServer.cpython-313.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..74b2cb7793e39dc668d5e2b6bccca043a32ccba1
GIT binary patch
literal 49870
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

literal 0
HcmV?d00001

diff --git a/Server/__pycache__/TCPGameServer.py b/Server/__pycache__/TCPGameServer.py
new file mode 100644
index 0000000..c83a207
--- /dev/null
+++ b/Server/__pycache__/TCPGameServer.py
@@ -0,0 +1,1569 @@
+from TCPServer import TCPServer
+import time
+import json
+
+server_host: str = "0.0.0.0"
+server_port: int = 4040
+buffer_size: int = 4096
+server_version: str = "1.0.1"#记录服务端版本
+
+#由于方法数量众多，所以将方法分组
+#1.服务端对本地的操作
+#2.服务端对客户端的操作
+
+class TCPGameServer(TCPServer):
+    #初始化TCP游戏服务器
+    def __init__(self, server_host=server_host, server_port=server_port, buffer_size=buffer_size):
+        super().__init__(server_host, server_port, buffer_size)
+        self.user_data = {}  # 存储用户相关数据
+        self.crop_timer = None  # 作物生长计时器
+        self.log('INFO', f"TCP游戏服务器初始化 - 版本: {server_version}", 'SERVER')
+        
+        # 启动作物生长计时器
+        self.start_crop_growth_timer()
+    
+
+    #检查客户端版本是否匹配
+    def _check_client_version(self, client_version, action_name="操作"):
+        """
+        检查客户端版本是否与服务端匹配
+        
+        参数:
+            client_version (str): 客户端版本号
+            action_name (str): 操作名称，用于日志记录
+            
+        返回:
+            tuple: (bool, response)
+                - bool: True表示版本匹配，False表示版本不匹配
+                - response: 如果版本不匹配，返回发送给客户端的错误响应，否则为None
+        """
+        if client_version != server_version:
+            self.log('WARNING', f"{action_name}失败: 版本不匹配 (客户端: {client_version}, 服务端: {server_version})", 'SERVER')
+            
+            response = {
+                "success": False,
+                "message": f"版本不匹配！客户端版本: {client_version}, 服务端版本: {server_version}，请更新客户端"
+            }
+            
+            return False, response
+        
+        # 版本匹配
+        return True, None
+
+    #检查用户是否已登录的通用方法
+    def _check_user_logged_in(self, client_id, action_name, action_type=None):
+        """
+        检查用户是否已登录的通用方法
+        
+        参数:
+            client_id (str): 客户端ID
+            action_name (str): 操作名称，用于日志记录
+            action_type (str, optional): 操作类型，用于响应消息
+            
+        返回:
+            tuple: (bool, response)
+                - bool: True表示已登录，False表示未登录
+                - response: 如果未登录，返回发送给客户端的错误响应，否则为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": "您需要先登录才能执行此操作"
+            }
+            
+            # 如果提供了action_type，添加到响应中
+            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
+
+
+
+    #从JSON文件加载玩家数据
+    def load_player_data(self, account_id):
+        """
+        从game_saves文件夹加载玩家数据
+        
+        参数:
+            account_id (str): 玩家账号ID
+        
+        返回:
+            dict: 玩家数据字典，如果文件不存在则返回None
+        """
+        import os
+        
+        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.log('INFO', f"已加载玩家 {account_id} 的数据", 'SERVER')
+                return player_data
+            else:
+                #self.log('WARNING', f"玩家 {account_id} 的数据文件不存在", 'SERVER')
+                return None
+        except Exception as e:
+            #self.log('ERROR', f"读取玩家 {account_id} 的数据时出错: {str(e)}", 'SERVER')
+            return None
+        
+    #通用加载玩家数据方法，带错误处理
+    def _load_player_data_with_check(self, client_id, action_type=None):
+        """
+        加载玩家数据并进行错误检查的通用方法
+        
+        参数:
+            client_id (str): 客户端ID
+            action_type (str, optional): 操作类型，用于错误响应
+            
+        返回:
+            tuple: (player_data, username, response)
+                - player_data: 成功加载的玩家数据，如果加载失败则为None
+                - username: 玩家用户名
+                - response: 如果加载失败，返回发送给客户端的错误响应，否则为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": "无法加载玩家数据"
+            }
+            
+            # 如果提供了action_type，添加到响应中
+            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
+
+
+    #保存玩家数据到JSON文件
+    def save_player_data(self, account_id, player_data):
+        """
+        保存玩家数据到game_saves文件夹
+        
+        参数:
+            account_id (str): 玩家账号ID
+            player_data (dict): 玩家数据字典
+        
+        返回:
+            bool: 保存成功返回True，否则返回False
+        """
+        import os
+        
+        file_path = os.path.join("game_saves", f"{account_id}.json")
+        
+        try:
+            with open(file_path, 'w', encoding='utf-8') as file:
+                json.dump(player_data, file, indent=2, ensure_ascii=False)
+            #self.log('INFO', f"已保存玩家 {account_id} 的数据", 'SERVER')
+            return True
+        except Exception as e:
+            self.log('ERROR', f"保存玩家 {account_id} 的数据时出错: {str(e)}", 'SERVER')
+            return False
+
+
+    #更新作物生长状态
+    def update_crops_growth(self):
+        """
+        更新所有玩家的作物生长状态
+        每秒钟对有作物的地块增加生长时间
+        并向在线玩家推送更新
+        """
+        import os
+        import glob
+        
+        # 获取所有玩家存档文件
+        save_files = glob.glob(os.path.join("game_saves", "*.json"))
+        
+        for save_file in save_files:
+            try:
+                # 从文件名提取账号ID
+                account_id = os.path.basename(save_file).split('.')[0]
+                
+                # 加载玩家数据
+                player_data = self.load_player_data(account_id)
+                if not player_data:
+                    continue
+                
+                # 检查是否有作物需要更新
+                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"]:
+                        # 增加生长时间
+                        farm_lot["grow_time"] += 1
+                        growth_updated = True
+                
+                # 如果有作物更新，保存玩家数据
+                if growth_updated:
+                    self.save_player_data(account_id, player_data)
+                    
+                    # 向在线玩家推送更新
+                    self._push_crop_update_to_player(account_id, player_data)
+                    
+            except Exception as e:
+                self.log('ERROR', f"更新作物生长状态时出错: {str(e)}", 'SERVER')
+                
+    
+    #向在线玩家推送作物更新
+    def _push_crop_update_to_player(self, account_id, player_data):
+        """
+        向在线玩家推送作物生长更新
+        
+        参数:
+            account_id (str): 玩家账号ID
+            player_data (dict): 玩家数据
+        """
+        # 查找对应的客户端ID
+        client_id = None
+        for cid, user_info in self.user_data.items():
+            if user_info.get("username") == account_id and user_info.get("logged_in", False):
+                client_id = cid
+                break
+        
+        # 如果玩家在线，检查是否处于访问模式
+        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:
+                # 如果处于访问模式，发送被访问玩家的更新数据
+                target_player_data = self.load_player_data(visiting_target)
+                if target_player_data:
+                    update_message = {
+                        "type": "crop_update",
+                        "farm_lots": target_player_data.get("farm_lots", []),
+                        "timestamp": time.time(),
+                        "is_visiting": True,
+                        "visited_player": visiting_target
+                    }
+                    self.send_data(client_id, update_message)
+                    self.log('DEBUG', f"已向访问模式中的玩家 {account_id} 推送被访问玩家 {visiting_target} 的作物更新", 'SERVER')
+            else:
+                # 正常模式，发送自己的农场更新
+                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)
+                self.log('DEBUG', f"已向玩家 {account_id} 推送作物更新", 'SERVER')
+
+
+    #设置一个计时器，每秒更新一次作物生长状态
+    def start_crop_growth_timer(self):
+        """
+        启动作物生长计时器，每秒更新一次
+        """
+        import threading
+        
+        # 更新作物生长状态
+        self.update_crops_growth()
+        
+        # 创建下一个计时器
+        self.crop_timer = threading.Timer(1.0, self.start_crop_growth_timer)
+        self.crop_timer.daemon = True
+        self.crop_timer.start()
+
+
+    #覆盖客户端移除方法，添加用户离开通知
+    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):
+                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:
+                    import datetime
+                    import re
+                    
+                    # 解析现有的总游玩时间
+                    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.log('INFO', f"用户 {username} 本次游玩时间: {play_time_seconds} 秒，总游玩时间: {player_data['total_login_time']}", '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 stop(self):
+        # 停止作物生长计时器
+        if self.crop_timer:
+            self.crop_timer.cancel()
+            self.crop_timer = None
+            self.log('INFO', "作物生长计时器已停止", 'SERVER')
+        
+        # 调用父类方法完成实际停止
+        super().stop()
+
+
+    #接收客户端消息并处理
+    def _handle_message(self, client_id, message):
+        message_type = message.get("type", "")
+        match message_type:
+            case "greeting":
+                return self._handle_greeting(client_id, message)
+            case "message":
+                return self._handle_chat_message(client_id, message)
+            case "login":
+                return self._handle_login(client_id, message)
+            case "register":
+                return self._handle_register(client_id, message)
+            case "request_verification_code":
+                return self._handle_verification_code_request(client_id, message)
+            case "verify_code":
+                return self._handle_verify_code(client_id, message)
+            #玩家基本游戏操作
+            case "harvest_crop":
+                return self._handle_harvest_crop(client_id, message)
+            case "plant_crop":
+                return self._handle_plant_crop(client_id, message)
+            case "buy_seed":
+                return self._handle_buy_seed(client_id, message)
+            case "dig_ground":
+                return self._handle_dig_ground(client_id, message)
+            #玩家基本游戏操作
+            case "get_play_time":
+                return self._handle_get_play_time(client_id)
+            case "update_play_time":
+                return self._handle_update_play_time(client_id)
+            case "request_player_rankings":
+                return self._handle_player_rankings_request(client_id)
+            case "request_crop_data":
+                return self._handle_crop_data_request(client_id)
+            case "visit_player":
+                return self._handle_visit_player_request(client_id, message)
+            case "return_my_farm":
+                return self._handle_return_my_farm_request(client_id, message)
+            case _:
+                # 未知类型，使用默认处理
+                return super()._handle_message(client_id, message)
+    
+
+    #处理登录消息
+    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')
+            
+            # 更新最后登录时间
+            import datetime
+            current_time = datetime.datetime.now()
+            player_data["last_login_time"] = current_time.strftime("%Y年%m月%d日%H时%M分%S秒")
+            
+            # 保存用户会话信息
+            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)
+            
+            # 立即向客户端发送一次作物状态
+            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)
+            
+            # 发送最新的作物数据配置
+            try:
+                with open("config/crop_data.json", 'r', encoding='utf-8') as file:
+                    crop_data = json.load(file)
+                
+                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"已向登录用户 {username} 发送作物数据配置", 'SERVER')
+            except Exception as e:
+                self.log('ERROR', f"无法向登录用户发送作物数据: {str(e)}", 'SERVER')
+            
+            # 返回登录成功消息
+            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 _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:
+            self.log('WARNING', f"注册失败: 用户名或密码为空", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "register_response",
+                "status": "failed",
+                "message": "用户名或密码不能为空"
+            })
+        
+        # 验证用户名是否是QQ号 (5-12位数字)
+        import re
+        if not re.match(r'^\d{5,12}$', username):
+            self.log('WARNING', f"注册失败: 用户名 {username} 不是有效的QQ号码", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "register_response",
+                "status": "failed",
+                "message": "用户名必须是5-12位的QQ号码"
+            })
+        
+        # 验证验证码
+        if verification_code:
+            from QQEmailSend import EmailVerification
+            success, verify_message = EmailVerification.verify_code(username, verification_code)
+            if not success:
+                self.log('WARNING', f"注册失败: 验证码错误 - {verify_message}", 'SERVER')
+                return self.send_data(client_id, {
+                    "type": "register_response",
+                    "status": "failed",
+                    "message": f"验证码错误: {verify_message}"
+                })
+        
+        # 检查用户是否已存在
+        import os
+        file_path = os.path.join("game_saves", f"{username}.json")
+        if os.path.exists(file_path):
+            self.log('WARNING', f"注册失败: 用户 {username} 已存在", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "register_response",
+                "status": "failed",
+                "message": "该用户名已被注册"
+            })
+        
+        try:
+            # 从模板加载初始玩家数据
+            template_path = os.path.join("config", "initial_player_data_template.json")
+            if not os.path.exists(template_path):
+                self.log('ERROR', f"无法找到玩家数据模板文件", 'SERVER')
+                return self.send_data(client_id, {
+                    "type": "register_response",
+                    "status": "failed",
+                    "message": "服务器配置错误，无法注册新用户"
+                })
+                
+            with open(template_path, 'r', encoding='utf-8') as file:
+                player_data = json.load(file)
+                
+            # 更新玩家数据
+            player_data["user_name"] = username
+            player_data["user_password"] = password
+            
+            # 设置农场名称，如果没有提供则使用默认名称
+            if farm_name:
+                player_data["farm_name"] = farm_name
+            
+            # 设置玩家昵称，如果没有提供则使用QQ号或默认昵称
+            if player_name:
+                player_data["player_name"] = player_name
+            else:
+                player_data["player_name"] = username
+            
+            # 确保所有必要的字段都存在
+            if "experience" not in player_data:
+                player_data["experience"] = 0
+            if "level" not in player_data:
+                player_data["level"] = 1
+            if "money" not in player_data:
+                player_data["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"] = []
+            
+            # 更新注册时间和登录时间
+            import datetime
+            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秒"
+            
+            # 保存新用户数据
+            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_data(client_id, {
+                "type": "register_response",
+                "status": "failed",
+                "message": f"注册过程中出现错误: {str(e)}"
+            })
+
+
+
+
+    #处理问候消息
+    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_harvest_crop(self, client_id, message):
+        """
+        处理玩家收获作物的请求
+        
+        参数:
+            client_id (str): 客户端ID
+            message (dict): 消息内容
+        """
+        # 检查用户是否已登录
+        logged_in, response = self._check_user_logged_in(client_id, "收获作物", "harvest_crop")
+        if not logged_in:
+            return self.send_data(client_id, response)
+        
+        # 获取玩家数据
+        player_data, username, response = self._load_player_data_with_check(client_id, "harvest_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", [])):
+            self.log('WARNING', f"玩家 {username} 请求收获无效地块 {lot_index}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "harvest_crop",
+                "success": False,
+                "message": "无效的地块索引"
+            })
+        
+        # 获取地块数据
+        lot = player_data["farm_lots"][lot_index]
+        
+        # 检查地块是否有作物且已成熟
+        if not lot.get("is_planted", False) or not lot.get("crop_type", ""):
+            self.log('WARNING', f"玩家 {username} 尝试收获空地块 {lot_index}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "harvest_crop",
+                "success": False,
+                "message": "此地块没有种植作物"
+            })
+        
+        if lot.get("is_dead", False):
+            # 处理已死亡的作物
+            self.log('INFO', f"玩家 {username} 铲除了地块 {lot_index} 上已死亡的作物", 'SERVER')
+            
+            # 清理地块
+            lot["is_planted"] = False
+            lot["crop_type"] = ""
+            lot["grow_time"] = 0
+            
+            # 保存玩家数据
+            self.save_player_data(username, player_data)
+            
+            # 发送作物更新
+            self._push_crop_update_to_player(username, player_data)
+            
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "harvest_crop",
+                "success": True,
+                "message": f"已铲除死亡的作物",
+                "updated_data": {
+                    "money": player_data["money"],
+                    "experience": player_data["experience"],
+                    "level": player_data["level"]
+                }
+            })
+        
+        if lot["grow_time"] < lot["max_grow_time"]:
+            self.log('WARNING', f"玩家 {username} 尝试收获未成熟的作物 {lot_index}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "harvest_crop",
+                "success": False,
+                "message": "作物尚未成熟"
+            })
+        
+        # 读取作物配置 (假设在服务器上也有作物配置)
+        import json
+        crop_data = {}
+        try:
+            with open("config/crop_data.json", 'r', encoding='utf-8') as file:
+                crop_data = json.load(file)
+        except Exception as e:
+            self.log('ERROR', f"无法加载作物数据: {str(e)}", 'SERVER')
+            # 使用默认收益
+            crop_income = 100
+            crop_exp = 10
+        
+        # 获取作物收益和经验
+        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
+        
+        # 保存玩家数据
+        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 _handle_plant_crop(self, client_id, message):
+        """
+        处理玩家种植作物的请求
+        
+        参数:
+            client_id (str): 客户端ID
+            message (dict): 消息内容
+        """
+        # 检查用户是否已登录
+        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", [])):
+            self.log('WARNING', f"玩家 {username} 请求种植无效地块 {lot_index}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "plant_crop",
+                "success": False,
+                "message": "无效的地块索引"
+            })
+        
+        # 获取地块数据
+        lot = player_data["farm_lots"][lot_index]
+        
+        # 检查地块是否已开垦且未种植
+        if not lot.get("is_diged", False):
+            self.log('WARNING', f"玩家 {username} 尝试在未开垦的地块 {lot_index} 种植", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "plant_crop",
+                "success": False,
+                "message": "此地块尚未开垦"
+            })
+        
+        if lot.get("is_planted", False):
+            self.log('WARNING', f"玩家 {username} 尝试在已种植的地块 {lot_index} 种植", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "plant_crop",
+                "success": False,
+                "message": "此地块已经种植了作物"
+            })
+        
+        # 读取作物配置 (假设在服务器上也有作物配置)
+        import json
+        crop_data = {}
+        try:
+            with open("config/crop_data.json", 'r', encoding='utf-8') as file:
+                crop_data = json.load(file)
+        except Exception as e:
+            self.log('ERROR', f"无法加载作物数据: {str(e)}", 'SERVER')
+            # 如果无法加载作物数据，使用默认生长时间
+            grow_time = 600
+        
+        # 检查玩家背包中是否有此种子
+        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:
+            self.log('WARNING', f"玩家 {username} 尝试种植背包中没有的种子 {crop_name}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "plant_crop",
+                "success": False,
+                "message": "背包中没有此种子"
+            })
+        
+        # 获取作物生长时间
+        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["is_planted"] = True
+        lot["crop_type"] = crop_name
+        lot["grow_time"] = 0
+        lot["max_grow_time"] = grow_time
+        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_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):
+        """
+        处理玩家购买种子的请求
+        
+        参数:
+            client_id (str): 客户端ID
+            message (dict): 消息内容
+        """
+        # 检查用户是否已登录
+        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", "")
+        
+        # 读取作物配置 (假设在服务器上也有作物配置)
+        import json
+        crop_data = {}
+        try:
+            with open("config/crop_data.json", 'r', encoding='utf-8') as file:
+                crop_data = json.load(file)
+        except Exception as e:
+            self.log('ERROR', f"无法加载作物数据: {str(e)}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "buy_seed",
+                "success": False,
+                "message": "服务器无法加载作物数据"
+            })
+        
+        # 检查作物是否存在
+        if crop_name not in crop_data:
+            self.log('WARNING', f"玩家 {username} 尝试购买不存在的种子 {crop_name}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "buy_seed",
+                "success": False,
+                "message": "该种子不存在"
+            })
+        
+        # 获取作物数据
+        crop = crop_data[crop_name]
+        
+        # 检查玩家等级
+        if player_data["level"] < crop.get("等级", 1):
+            self.log('WARNING', f"玩家 {username} 等级不足，无法购买种子 {crop_name}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "buy_seed",
+                "success": False,
+                "message": "等级不足，无法购买此种子"
+            })
+        
+        # 检查玩家金钱
+        if player_data["money"] < crop.get("花费", 0):
+            self.log('WARNING', f"玩家 {username} 金钱不足，无法购买种子 {crop_name}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "buy_seed",
+                "success": False,
+                "message": "金钱不足，无法购买此种子"
+            })
+        
+        # 扣除金钱
+        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):
+        """
+        处理玩家开垦土地的请求
+        
+        参数:
+            client_id (str): 客户端ID
+            message (dict): 消息内容
+        """
+        # 检查用户是否已登录
+        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", [])):
+            self.log('WARNING', f"玩家 {username} 请求开垦无效地块 {lot_index}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "dig_ground",
+                "success": False,
+                "message": "无效的地块索引"
+            })
+        
+        # 获取地块数据
+        lot = player_data["farm_lots"][lot_index]
+        
+        # 检查地块是否已开垦
+        if lot.get("is_diged", False):
+            self.log('WARNING', f"玩家 {username} 尝试开垦已开垦的地块 {lot_index}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "dig_ground",
+                "success": False,
+                "message": "此地块已经开垦过了"
+            })
+        
+        # 计算开垦费用 - 基于已开垦地块数量
+        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:
+            self.log('WARNING', f"玩家 {username} 金钱不足，无法开垦地块 {lot_index}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "action_response",
+                "action_type": "dig_ground",
+                "success": False,
+                "message": 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_get_play_time(self, client_id):
+        """
+        处理玩家获取游玩时间的请求
+        
+        参数:
+            client_id (str): 客户端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):
+        """
+        处理玩家手动更新游玩时间的请求
+        用于客户端不关闭而希望更新游玩时间的情况
+        
+        参数:
+            client_id (str): 客户端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)
+        
+        # 解析现有的总游玩时间
+        import re
+        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):
+        """
+        处理获取玩家排行榜的请求
+        返回所有玩家的数据（按等级排序）
+        
+        参数:
+            client_id (str): 客户端ID
+        """
+        import os
+        import glob
+        import json
+        
+        # 检查用户是否已登录
+        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 = []
+        
+        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 = 0
+                    for item in player_data.get("player_bag", []):
+                        seed_count += item.get("count", 0)
+                    
+                    # 获取所需的玩家信息
+                    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),
+                        "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秒")
+                    }
+                    
+                    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)
+        
+        self.log('INFO', f"玩家 {self.user_data[client_id].get('username')} 请求玩家排行榜，返回 {len(players_data)} 个玩家数据", 'SERVER')
+        
+        # 返回排行榜数据
+        return self.send_data(client_id, {
+            "type": "player_rankings_response",
+            "success": True,
+            "players": players_data
+        })
+
+
+    #处理作物数据请求
+    def _handle_crop_data_request(self, client_id):
+        """
+        处理客户端请求作物数据
+        
+        参数:
+            client_id (str): 客户端ID
+        """
+        import json
+        
+        try:
+            # 读取服务器上的作物数据
+            with open("config/crop_data.json", 'r', encoding='utf-8') as file:
+                crop_data = json.load(file)
+            
+            self.log('INFO', f"向客户端 {client_id} 发送作物数据", 'SERVER')
+            
+            return self.send_data(client_id, {
+                "type": "crop_data_response",
+                "success": True,
+                "crop_data": crop_data
+            })
+        except Exception as e:
+            self.log('ERROR', f"读取作物数据时出错: {str(e)}", 'SERVER')
+            return self.send_data(client_id, {
+                "type": "crop_data_response",
+                "success": False,
+                "message": f"无法读取作物数据: {str(e)}"
+            })
+
+
+    #处理验证码请求
+    def _handle_verification_code_request(self, client_id, message):
+        """
+        处理验证码请求，向指定QQ号对应的邮箱发送验证码
+        
+        参数:
+            client_id (str): 客户端ID
+            message (dict): 消息内容
+        """
+        from QQEmailSend import EmailVerification
+        
+        # 获取QQ号
+        qq_number = message.get("qq_number", "")
+        
+        # 验证QQ号
+        import re
+        if not re.match(r'^\d{5,12}$', qq_number):
+            self.log('WARNING', f"验证码请求错误: QQ号 {qq_number} 格式无效", 'SERVER')
+            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):
+        """
+        处理验证码验证请求
+        
+        参数:
+            client_id (str): 客户端ID
+            message (dict): 消息内容
+        """
+        from QQEmailSend import EmailVerification
+        
+        # 获取QQ号和验证码
+        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
+            })
+
+
+    #处理访问玩家请求
+    def _handle_visit_player_request(self, client_id, message):
+        """
+        处理访问其他玩家农场的请求
+        
+        参数:
+            client_id (str): 客户端ID
+            message (dict): 消息内容
+        """
+        # 检查用户是否已登录
+        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:
+            self.log('WARNING', f"访问玩家请求缺少目标用户名", 'SERVER')
+            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:
+            self.log('WARNING', f"无法找到玩家 {target_username} 的数据", 'SERVER')
+            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),
+            "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秒")
+        }
+        
+        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):
+        """
+        处理玩家返回自己农场的请求
+        
+        参数:
+            client_id (str): 客户端ID
+            message (dict): 消息内容
+        """
+        # 检查用户是否已登录
+        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),
+                "farm_lots": player_data.get("farm_lots", []),
+                "player_bag": player_data.get("player_bag", [])
+            },
+            "is_visiting": False
+        })
+
+
+
+
+
+# 使用示例
+if __name__ == "__main__":
+    import threading
+    import sys
+    
+    try:
+        print(f"萌芽农场游戏服务器 v{server_version}")
+        print(f"服务器地址: {server_host}:{server_port}")
+        print("=" * 50)
+        
+        # 创建自定义服务器
+        server = TCPGameServer()
+        
+        # 以阻塞方式启动服务器
+        server_thread = threading.Thread(target=server.start)
+        server_thread.daemon = True
+        server_thread.start()
+        
+        print("服务器已启动，按 Ctrl+C 停止服务器")
+        
+        # 运行直到按Ctrl+C
+        while True:
+            time.sleep(1)
+            
+    except KeyboardInterrupt:
+        print("\n程序被用户中断")
+        if 'server' in locals():
+            server.stop()
+        sys.exit(0) 
\ No newline at end of file
diff --git a/Server/config/crop_data.json.backup b/Server/config/crop_data.json.backup
deleted file mode 100644
index f68165b..0000000
--- a/Server/config/crop_data.json.backup
+++ /dev/null
@@ -1,32 +0,0 @@
-{
-	
-	"测试作物": {"花费": 1, "生长时间": 3, "收益": 9999, "品质": "普通", "描述": "测试作物", "耐候性": 10, "等级": 1, "经验": 999},
-
-	"小麦": {"花费": 120, "生长时间": 120, "收益": 100, "品质": "普通", "描述": "基础作物，品质较低，适合新手种植", "耐候性": 10, "等级": 1, "经验": 10},
-	"稻谷": {"花费": 100, "生长时间": 240, "收益": 120, "品质": "普通", "描述": "适合大规模种植的基础作物", "耐候性": 10, "等级": 1, "经验": 10},
-	"玉米": {"花费": 70, "生长时间": 600, "收益": 90, "品质": "普通", "描述": "营养丰富的优良作物，适合稍有经验的玩家", "耐候性": 15, "等级": 2, "经验": 15},
-	"土豆": {"花费": 75, "生长时间": 360, "收益": 90, "品质": "普通", "描述": "容易种植的耐寒作物", "耐候性": 12, "等级": 1, "经验": 10},
-	"胡萝卜": {"花费": 60, "生长时间": 480, "收益": 80, "品质": "普通", "描述": "适合新手的健康作物", "耐候性": 12, "等级": 1, "经验": 10},
-
-	"草莓": {"花费": 120, "生长时间": 960, "收益": 150, "品质": "优良", "描述": "营养丰富的果实，收益不错", "耐候性": 14, "等级": 2, "经验": 20},
-	"番茄": {"花费": 100, "生长时间": 720, "收益": 130, "品质": "优良", "描述": "常见作物，适合小规模种植", "耐候性": 12, "等级": 2, "经验": 15},
-	"大豆": {"花费": 90, "生长时间": 840, "收益": 110, "品质": "优良", "描述": "富含蛋白质的基础作物", "耐候性": 11, "等级": 2, "经验": 12},
-
-	"蓝莓": {"花费": 150, "生长时间": 1200, "收益": 200, "品质": "稀有", "描述": "较为稀有的作物，市场价值较高", "耐候性": 18, "等级": 3, "经验": 25},
-	"洋葱": {"花费": 85, "生长时间": 600, "收益": 105, "品质": "稀有", "描述": "烹饪常用的作物，适合中级种植", "耐候性": 10, "等级": 2, "经验": 10},
-	"南瓜": {"花费": 180, "生长时间": 1440, "收益": 250, "品质": "稀有", "描述": "秋季收获的高收益作物", "耐候性": 20, "等级": 4, "经验": 30},
-	"葡萄": {"花费": 200, "生长时间": 1200, "收益": 300, "品质": "稀有", "描述": "需要特殊管理的高收益作物", "耐候性": 15, "等级": 4, "经验": 35},
-	"柿子": {"花费": 160, "生长时间": 1080, "收益": 240, "品质": "稀有", "描述": "富含营养的秋季作物", "耐候性": 18, "等级": 3, "经验": 28},
-	"花椰菜": {"花费": 130, "生长时间": 960, "收益": 170, "品质": "稀有", "描述": "耐寒的高品质作物，适合经验丰富的玩家", "耐候性": 17, "等级": 3, "经验": 22},
-	"芦笋": {"花费": 200, "生长时间": 1560, "收益": 280, "品质": "稀有", "描述": "市场需求量高的稀有作物", "耐候性": 15, "等级": 4, "经验": 30},
-
-	"香草": {"花费": 250, "生长时间": 1800, "收益": 400, "品质": "史诗", "描述": "非常稀有且收益极高的作物", "耐候性": 22, "等级": 5, "经验": 40},
-	"西瓜": {"花费": 240, "生长时间": 2400, "收益": 420, "品质": "史诗", "描述": "夏季丰产的高价值作物", "耐候性": 21, "等级": 5, "经验": 45},
-	"甜菜": {"花费": 220, "生长时间": 2160, "收益": 350, "品质": "史诗", "描述": "营养丰富的根茎作物，收益较高", "耐候性": 20, "等级": 5, "经验": 38},
-	"甘蔗": {"花费": 260, "生长时间": 3000, "收益": 450, "品质": "史诗", "描述": "需要充足水源的高价值作物", "耐候性": 18, "等级": 5, "经验": 50},
-
-	"龙果": {"花费": 400, "生长时间": 4800, "收益": 600, "品质": "传奇", "描述": "极为稀有的热带作物，产量和价值都极高", "耐候性": 25, "等级": 6, "经验": 60},
-	"松露": {"花费": 500, "生长时间": 7200, "收益": 700, "品质": "传奇", "描述": "极其珍贵的地下作物，市场价格极高", "耐候性": 23, "等级": 7, "经验": 80},
-	"人参": {"花费": 450, "生长时间": 6600, "收益": 650, "品质": "传奇", "描述": "需要耐心等待的珍贵药材", "耐候性": 22, "等级": 6, "经验": 75},
-	"金橘": {"花费": 420, "生长时间": 4800, "收益": 620, "品质": "传奇", "描述": "少见的耐寒果树，市场需求量极大", "耐候性": 26, "等级": 7, "经验": 70}
-} 
\ No newline at end of file
diff --git a/Server/config/initial_player_data_template.json b/Server/config/initial_player_data_template.json
index 3264e31..11233ca 100644
--- a/Server/config/initial_player_data_template.json
+++ b/Server/config/initial_player_data_template.json
@@ -1,64 +1,64 @@
 {
-    "experience": 0,
-    "level": 1,
-    "money": 1000,
-    "farm_name": "农场",
-    "user_name": "shumengya",
-    "player_name": "玩家昵称",
-    "user_password": "0123456789",
-    "last_login_time": "2025年12时09分35秒",
-    "total_login_time": "0时0分0秒",
-    "farm_lots": [
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": true, "is_planted": false, "max_grow_time": 3},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": true, "is_planted": false, "max_grow_time": 3},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": true, "is_planted": false, "max_grow_time": 3},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": true, "is_planted": false, "max_grow_time": 3},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": true, "is_planted": false, "max_grow_time": 3},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5},
-        {"crop_type": "", "grow_time": 0, "is_dead": false, "is_diged": false, "is_planted": false, "max_grow_time": 5}
+  "experience": 0,
+  "level": 1,
+  "money": 1000,
+  "farm_name": "农场",
+  "user_name": "shumengya",
+  "player_name": "玩家昵称",
+  "user_password": "0123456789",
+  "last_login_time": "2025年12时09分35秒",
+  "total_login_time": "0时0分0秒",
+  "farm_lots": [
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0}
     ],
-    "player_bag": []
+  "player_bag": []
 }
\ No newline at end of file
diff --git a/Server/game_saves/2143323382.json b/Server/game_saves/2143323382.json
index fab514a..deaaf04 100644
--- a/Server/game_saves/2143323382.json
+++ b/Server/game_saves/2143323382.json
@@ -9,406 +9,56 @@
   "last_login_time": "2025年05月25日16时43分38秒",
   "total_login_time": "0时0分29秒",
   "farm_lots": [
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    }
-  ],
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0}
+    ],
   "player_bag": []
 }
\ No newline at end of file
diff --git a/Server/game_saves/2143323382.json.backup b/Server/game_saves/2143323382.json.backup
new file mode 100644
index 0000000..fab514a
--- /dev/null
+++ b/Server/game_saves/2143323382.json.backup
@@ -0,0 +1,414 @@
+{
+  "experience": 0,
+  "level": 1,
+  "money": 1000,
+  "farm_name": "柚大青の小农场",
+  "player_name": "柚大青",
+  "user_name": "2143323382",
+  "user_password": "tyh@19900420",
+  "last_login_time": "2025年05月25日16时43分38秒",
+  "total_login_time": "0时0分29秒",
+  "farm_lots": [
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    }
+  ],
+  "player_bag": []
+}
\ No newline at end of file
diff --git a/Server/game_saves/2221023030.json b/Server/game_saves/2221023030.json
new file mode 100644
index 0000000..23a4017
--- /dev/null
+++ b/Server/game_saves/2221023030.json
@@ -0,0 +1,67 @@
+{
+  "experience": 1408,
+  "level": 29,
+  "money": 294776,
+  "farm_name": "虚空农场",
+  "user_name": "2221023030",
+  "player_name": "虚空领主",
+  "user_password": "wangpeng666",
+  "last_login_time": "2025年05月25日21时37分28秒",
+  "total_login_time": "0时13分51秒",
+  "farm_lots": [
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"测试作物","grow_time":3,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"测试作物","grow_time":3,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"土豆","grow_time":360,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":360,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0}
+    ],
+  "player_bag": [
+      {"name":"土豆","quality":"普通","count":7},
+      {"name":"测试作物","quality":"普通","count":30}
+    ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/2221023030.json.backup b/Server/game_saves/2221023030.json.backup
new file mode 100644
index 0000000..78ce98d
--- /dev/null
+++ b/Server/game_saves/2221023030.json.backup
@@ -0,0 +1,425 @@
+{
+  "experience": 1408,
+  "level": 29,
+  "money": 294776,
+  "farm_name": "虚空农场",
+  "user_name": "2221023030",
+  "player_name": "虚空领主",
+  "user_password": "wangpeng666",
+  "last_login_time": "2025年05月25日21时37分28秒",
+  "total_login_time": "0时13分51秒",
+  "farm_lots": [
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "测试作物",
+      "grow_time": 3,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "测试作物",
+      "grow_time": 3,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "土豆",
+      "grow_time": 360,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 360
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    }
+  ],
+  "player_bag": [
+    {
+      "name": "土豆",
+      "quality": "普通",
+      "count": 7
+    },
+    {
+      "name": "测试作物",
+      "quality": "普通",
+      "count": 30
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/2427948832.json b/Server/game_saves/2427948832.json
new file mode 100644
index 0000000..e7e7324
--- /dev/null
+++ b/Server/game_saves/2427948832.json
@@ -0,0 +1,68 @@
+{
+  "experience": 2235,
+  "level": 53,
+  "money": 1222211,
+  "farm_name": "神经病院",
+  "user_name": "2427948832",
+  "player_name": "唐大伟",
+  "user_password": "mylc205823",
+  "last_login_time": "2025年05月27日10时30分31秒",
+  "total_login_time": "0时34分45秒",
+  "farm_lots": [
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0}
+    ],
+  "player_bag": [
+      {"name":"洋葱","quality":"稀有","count":2},
+      {"name":"测试作物","quality":"普通","count":219},
+      {"name":"稻谷","quality":"普通","count":1}
+    ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/2427948832.json.backup b/Server/game_saves/2427948832.json.backup
new file mode 100644
index 0000000..33a6b4b
--- /dev/null
+++ b/Server/game_saves/2427948832.json.backup
@@ -0,0 +1,430 @@
+{
+  "experience": 2235,
+  "level": 53,
+  "money": 1222211,
+  "farm_name": "神经病院",
+  "user_name": "2427948832",
+  "player_name": "唐大伟",
+  "user_password": "mylc205823",
+  "last_login_time": "2025年05月27日10时30分31秒",
+  "total_login_time": "0时34分45秒",
+  "farm_lots": [
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    }
+  ],
+  "player_bag": [
+    {
+      "name": "洋葱",
+      "quality": "稀有",
+      "count": 2
+    },
+    {
+      "name": "测试作物",
+      "quality": "普通",
+      "count": 219
+    },
+    {
+      "name": "稻谷",
+      "quality": "普通",
+      "count": 1
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/2634726358.json b/Server/game_saves/2634726358.json
new file mode 100644
index 0000000..f307a52
--- /dev/null
+++ b/Server/game_saves/2634726358.json
@@ -0,0 +1,67 @@
+{
+  "experience": 1485,
+  "level": 17,
+  "money": 106782,
+  "farm_name": "嘻嘻",
+  "user_name": "2634726358",
+  "player_name": "哈哈",
+  "user_password": "wxt20050712",
+  "last_login_time": "2025年05月25日19时22分59秒",
+  "total_login_time": "0时8分43秒",
+  "farm_lots": [
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":240,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":240,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":240,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0}
+    ],
+  "player_bag": [
+      {"name":"番茄","quality":"优良","count":4},
+      {"name":"测试作物","quality":"普通","count":3}
+    ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/2634726358.json.backup b/Server/game_saves/2634726358.json.backup
new file mode 100644
index 0000000..65cb84e
--- /dev/null
+++ b/Server/game_saves/2634726358.json.backup
@@ -0,0 +1,425 @@
+{
+  "experience": 1485,
+  "level": 17,
+  "money": 106782,
+  "farm_name": "嘻嘻",
+  "user_name": "2634726358",
+  "player_name": "哈哈",
+  "user_password": "wxt20050712",
+  "last_login_time": "2025年05月25日19时22分59秒",
+  "total_login_time": "0时8分43秒",
+  "farm_lots": [
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 240
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 240
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 240
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    }
+  ],
+  "player_bag": [
+    {
+      "name": "番茄",
+      "quality": "优良",
+      "count": 4
+    },
+    {
+      "name": "测试作物",
+      "quality": "普通",
+      "count": 3
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/2671387804.json b/Server/game_saves/2671387804.json
new file mode 100644
index 0000000..c3272dc
--- /dev/null
+++ b/Server/game_saves/2671387804.json
@@ -0,0 +1,69 @@
+{
+  "experience": 1678,
+  "level": 38,
+  "money": 537188,
+  "farm_name": "杨亮的家",
+  "user_name": "2671387804",
+  "player_name": "杨亮的主人",
+  "user_password": "woshiyangliang",
+  "last_login_time": "2025年05月25日21时45分45秒",
+  "total_login_time": "0时16分13秒",
+  "farm_lots": [
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"小麦","grow_time":120,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":120,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"测试作物","grow_time":3,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"测试作物","grow_time":3,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"测试作物","grow_time":3,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"测试作物","grow_time":3,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"测试作物","grow_time":3,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0}
+    ],
+  "player_bag": [
+      {"name":"胡萝卜","quality":"普通","count":5},
+      {"name":"土豆","quality":"普通","count":2},
+      {"name":"稻谷","quality":"普通","count":1},
+      {"name":"测试作物","quality":"普通","count":105}
+    ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/2671387804.json.backup b/Server/game_saves/2671387804.json.backup
new file mode 100644
index 0000000..f0a4ed1
--- /dev/null
+++ b/Server/game_saves/2671387804.json.backup
@@ -0,0 +1,435 @@
+{
+  "experience": 1678,
+  "level": 38,
+  "money": 537188,
+  "farm_name": "杨亮的家",
+  "user_name": "2671387804",
+  "player_name": "杨亮的主人",
+  "user_password": "woshiyangliang",
+  "last_login_time": "2025年05月25日21时45分45秒",
+  "total_login_time": "0时16分13秒",
+  "farm_lots": [
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "测试作物",
+      "grow_time": 3,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "测试作物",
+      "grow_time": 3,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "测试作物",
+      "grow_time": 3,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "测试作物",
+      "grow_time": 3,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "测试作物",
+      "grow_time": 3,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    }
+  ],
+  "player_bag": [
+    {
+      "name": "胡萝卜",
+      "quality": "普通",
+      "count": 5
+    },
+    {
+      "name": "土豆",
+      "quality": "普通",
+      "count": 2
+    },
+    {
+      "name": "稻谷",
+      "quality": "普通",
+      "count": 1
+    },
+    {
+      "name": "测试作物",
+      "quality": "普通",
+      "count": 105
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/2809548669.json b/Server/game_saves/2809548669.json
new file mode 100644
index 0000000..d4b06f8
--- /dev/null
+++ b/Server/game_saves/2809548669.json
@@ -0,0 +1,64 @@
+{
+  "experience": 0,
+  "level": 1,
+  "money": 1000,
+  "farm_name": "丿Dream丨天辰",
+  "user_name": "2809548669",
+  "player_name": "丿Dream丨天辰",
+  "user_password": "asd123456",
+  "last_login_time": "2025年05月25日22时06分21秒",
+  "total_login_time": "0时0分15秒",
+  "farm_lots": [
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":3,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0}
+    ],
+  "player_bag": []
+}
\ No newline at end of file
diff --git a/Server/game_saves/2809548669.json.backup b/Server/game_saves/2809548669.json.backup
new file mode 100644
index 0000000..b20b19a
--- /dev/null
+++ b/Server/game_saves/2809548669.json.backup
@@ -0,0 +1,414 @@
+{
+  "experience": 0,
+  "level": 1,
+  "money": 1000,
+  "farm_name": "丿Dream丨天辰",
+  "user_name": "2809548669",
+  "player_name": "丿Dream丨天辰",
+  "user_password": "asd123456",
+  "last_login_time": "2025年05月25日22时06分21秒",
+  "total_login_time": "0时0分15秒",
+  "farm_lots": [
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 3
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    }
+  ],
+  "player_bag": []
+}
\ No newline at end of file
diff --git a/Server/game_saves/2973419538.json b/Server/game_saves/2973419538.json
new file mode 100644
index 0000000..1998eb1
--- /dev/null
+++ b/Server/game_saves/2973419538.json
@@ -0,0 +1,68 @@
+{
+  "experience": 899,
+  "level": 2,
+  "money": 5026,
+  "farm_name": "niuma",
+  "user_name": "2973419538",
+  "player_name": "niuma",
+  "user_password": "247896",
+  "last_login_time": "2025年05月27日15时45分58秒",
+  "total_login_time": "0时2分5秒",
+  "farm_lots": [
+      {"crop_type":"小麦","grow_time":120,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":120,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"胡萝卜","grow_time":480,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":480,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"小麦","grow_time":120,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":120,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"土豆","grow_time":360,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":360,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"稻谷","grow_time":240,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":240,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"小麦","grow_time":120,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":120,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0}
+    ],
+  "player_bag": [
+      {"name":"测试作物","quality":"普通","count":3},
+      {"name":"稻谷","quality":"普通","count":3},
+      {"name":"土豆","quality":"普通","count":1}
+    ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/2973419538.json.backup b/Server/game_saves/2973419538.json.backup
new file mode 100644
index 0000000..0c35edc
--- /dev/null
+++ b/Server/game_saves/2973419538.json.backup
@@ -0,0 +1,430 @@
+{
+  "experience": 899,
+  "level": 2,
+  "money": 5026,
+  "farm_name": "niuma",
+  "user_name": "2973419538",
+  "player_name": "niuma",
+  "user_password": "247896",
+  "last_login_time": "2025年05月27日15时45分58秒",
+  "total_login_time": "0时2分5秒",
+  "farm_lots": [
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "土豆",
+      "grow_time": 360,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 360
+    },
+    {
+      "crop_type": "稻谷",
+      "grow_time": 240,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 240
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    }
+  ],
+  "player_bag": [
+    {
+      "name": "测试作物",
+      "quality": "普通",
+      "count": 3
+    },
+    {
+      "name": "稻谷",
+      "quality": "普通",
+      "count": 3
+    },
+    {
+      "name": "土豆",
+      "quality": "普通",
+      "count": 1
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/3205788256.json.backup b/Server/game_saves/3205788256.json.backup
index f0aa874..83b4ddb 100644
--- a/Server/game_saves/3205788256.json.backup
+++ b/Server/game_saves/3205788256.json.backup
@@ -1,21 +1,20 @@
 {
-  "experience": 508,
   "farm_lots": [
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "小麦",
+      "grow_time": 120,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
+      "is_planted": true,
+      "max_grow_time": 120
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
+      "is_planted": true,
+      "max_grow_time": 480
     },
     {
       "crop_type": "花椰菜",
@@ -26,116 +25,556 @@
       "max_grow_time": 960
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "金橘",
+      "grow_time": 4800,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
+      "is_planted": true,
       "max_grow_time": 4800
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "松露",
+      "grow_time": 7200,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 1200
+      "is_planted": true,
+      "max_grow_time": 7200
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "人参",
+      "grow_time": 6600,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 5
+      "is_planted": true,
+      "max_grow_time": 6600
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "草莓",
+      "grow_time": 960,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "松露",
+      "grow_time": 4295,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 7200
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "龙果",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
       "max_grow_time": 4800
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "小麦",
+      "grow_time": 120,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 4891,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "香草",
+      "grow_time": 1800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1800
+    },
+    {
+      "crop_type": "芦荟",
+      "grow_time": 301,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "番茄",
+      "grow_time": 297,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 720
+    },
+    {
+      "crop_type": "香草",
+      "grow_time": 295,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1800
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 294,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560
+    },
+    {
+      "crop_type": "甜菜",
+      "grow_time": 292,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 2160
+    },
+    {
+      "crop_type": "松露",
+      "grow_time": 7200,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 7200
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "草莓",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "松露",
+      "grow_time": 7200,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 7200
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "草莓",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 4307,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "龙果",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 4299,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 4891,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "香草",
+      "grow_time": 1800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1800
+    },
+    {
+      "crop_type": "稻谷",
+      "grow_time": 240,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 240
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "西瓜",
+      "grow_time": 2400,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
       "max_grow_time": 2400
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
+      "is_planted": true,
+      "max_grow_time": 480
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "花椰菜",
+      "grow_time": 960,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "松露",
+      "grow_time": 7200,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 7200
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "草莓",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "甜菜",
+      "grow_time": 2160,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 2160
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
     },
     {
       "crop_type": "",
@@ -146,101 +585,141 @@
       "max_grow_time": 120
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "芦笋",
+      "grow_time": 1560,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 720
+      "is_planted": true,
+      "max_grow_time": 1560
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "芦笋",
+      "grow_time": 1560,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 2400
+      "is_planted": true,
+      "max_grow_time": 1560
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "人参",
+      "grow_time": 6600,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 5
+      "is_planted": true,
+      "max_grow_time": 6600
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 1200
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 1800
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 600
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
+      "is_planted": true,
       "max_grow_time": 480
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
       "max_grow_time": 960
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "龙果",
+      "grow_time": 4800,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "香草",
+      "grow_time": 1800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1800
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 4891,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "香草",
+      "grow_time": 1800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1800
+    },
+    {
+      "crop_type": "稻谷",
+      "grow_time": 240,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 240
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480
+    },
+    {
+      "crop_type": "草莓",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
       "max_grow_time": 960
     },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600
+    },
     {
       "crop_type": "",
       "grow_time": 0,
@@ -258,113 +737,194 @@
       "max_grow_time": 5
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 5
+      "is_planted": true,
+      "max_grow_time": 480
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "甜菜",
+      "grow_time": 2160,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 5
+      "is_planted": true,
+      "max_grow_time": 2160
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "西瓜",
+      "grow_time": 2400,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
+      "is_planted": true,
       "max_grow_time": 2400
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "人参",
+      "grow_time": 6600,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
+      "is_planted": true,
+      "max_grow_time": 6600
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "芦笋",
+      "grow_time": 1560,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
+      "is_planted": true,
+      "max_grow_time": 1560
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "花椰菜",
+      "grow_time": 960,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
+      "is_planted": true,
       "max_grow_time": 960
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "花椰菜",
+      "grow_time": 960,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
+      "is_planted": true,
+      "max_grow_time": 960
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
       "max_grow_time": 960
     }
   ],
   "player_bag": [
     {
-      "count": 18,
-      "name": "测试作物",
-      "quality": "普通"
-    },
-    {
-      "count": 253,
+      "count": 272,
       "name": "金橘",
       "quality": "传奇"
     },
     {
       "name": "胡萝卜",
       "quality": "普通",
-      "count": 17
+      "count": 9
     },
     {
-      "name": "花椰菜",
-      "quality": "稀有",
-      "count": 11
-    },
-    {
-      "name": "芦笋",
-      "quality": "稀有",
+      "name": "人参",
+      "quality": "传奇",
       "count": 8
     },
     {
-      "name": "草莓",
+      "name": "松露",
+      "quality": "传奇",
+      "count": 8
+    },
+    {
+      "name": "富贵竹",
+      "quality": "传奇",
+      "count": 17
+    },
+    {
+      "name": "芦荟",
+      "quality": "传奇",
+      "count": 15
+    },
+    {
+      "name": "稻谷",
+      "quality": "普通",
+      "count": 15
+    },
+    {
+      "name": "小麦",
+      "quality": "普通",
+      "count": 3
+    },
+    {
+      "name": "测试作物",
+      "quality": "普通",
+      "count": 8
+    },
+    {
+      "name": "番茄",
       "quality": "优良",
-      "count": 4
+      "count": 16
     },
     {
       "name": "香草",
       "quality": "史诗",
-      "count": 3
+      "count": 10
+    },
+    {
+      "name": "龙果",
+      "quality": "传奇",
+      "count": 6
+    },
+    {
+      "name": "甘蔗",
+      "quality": "史诗",
+      "count": 2
+    },
+    {
+      "name": "甜菜",
+      "quality": "史诗",
+      "count": 2
+    },
+    {
+      "name": "西瓜",
+      "quality": "史诗",
+      "count": 1
+    },
+    {
+      "name": "葡萄",
+      "quality": "稀有",
+      "count": 2
+    },
+    {
+      "name": "南瓜",
+      "quality": "稀有",
+      "count": 2
+    },
+    {
+      "name": "玉米",
+      "quality": "普通",
+      "count": 1
+    },
+    {
+      "name": "土豆",
+      "quality": "普通",
+      "count": 1
+    },
+    {
+      "name": "草莓",
+      "quality": "优良",
+      "count": 1
+    },
+    {
+      "name": "大豆",
+      "quality": "优良",
+      "count": 1
+    },
+    {
+      "name": "蓝莓",
+      "quality": "稀有",
+      "count": 1
+    },
+    {
+      "name": "洋葱",
+      "quality": "稀有",
+      "count": 2
     }
   ],
+  "experience": 737,
   "farm_name": "树萌芽の大农场",
   "player_name": "树萌芽",
-  "level": 36,
-  "money": 40013,
-  "last_login_time": "2025年05月24日11时51分35秒",
-  "total_login_time": "100时33分38秒",
+  "level": 41,
+  "money": 5720,
+  "last_login_time": "2025年05月27日18时32分31秒",
+  "total_login_time": "104时17分5秒",
   "user_name": "3205788256",
   "user_password": "tyh@19900420"
 }
\ No newline at end of file
diff --git a/Server/game_saves/3346964708.json b/Server/game_saves/3346964708.json
new file mode 100644
index 0000000..070f7d0
--- /dev/null
+++ b/Server/game_saves/3346964708.json
@@ -0,0 +1,91 @@
+{
+  "experience": 4193,
+  "level": 8,
+  "money": 28470,
+  "farm_name": "困困的鼠鼠",
+  "user_name": "3346964708",
+  "player_name": "OVO",
+  "user_password": "123456",
+  "last_login_time": "2025年05月26日23时53分53秒",
+  "total_login_time": "0时7分6秒",
+  "farm_lots": [
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"金橘","grow_time":4800,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":4800,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"小麦","grow_time":120,"is_dead":false,"is_diged":true,"is_planted":true,"max_grow_time":120,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":true,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0},
+      {"crop_type":"","grow_time":0,"is_dead":false,"is_diged":false,"is_planted":false,"max_grow_time":5,"已浇水":false,"已施肥":false,"土地等级":0}
+    ],
+  "player_bag": [
+      {"name":"测试作物","quality":"普通","count":3},
+      {"name":"小麦","quality":"普通","count":3},
+      {"name":"稻谷","quality":"普通","count":1},
+      {"name":"玉米","quality":"普通","count":1},
+      {"name":"土豆","quality":"普通","count":1},
+      {"name":"胡萝卜","quality":"普通","count":1},
+      {"name":"草莓","quality":"优良","count":1},
+      {"name":"番茄","quality":"优良","count":1},
+      {"name":"大豆","quality":"优良","count":1},
+      {"name":"蓝莓","quality":"稀有","count":1},
+      {"name":"洋葱","quality":"稀有","count":1},
+      {"name":"南瓜","quality":"稀有","count":1},
+      {"name":"葡萄","quality":"稀有","count":1},
+      {"name":"柿子","quality":"稀有","count":1},
+      {"name":"芦笋","quality":"稀有","count":1},
+      {"name":"花椰菜","quality":"稀有","count":1},
+      {"name":"香草","quality":"史诗","count":1},
+      {"name":"西瓜","quality":"史诗","count":1},
+      {"name":"甜菜","quality":"史诗","count":1},
+      {"name":"甘蔗","quality":"史诗","count":1},
+      {"name":"龙果","quality":"传奇","count":1},
+      {"name":"松露","quality":"传奇","count":1},
+      {"name":"人参","quality":"传奇","count":1},
+      {"name":"富贵竹","quality":"传奇","count":1},
+      {"name":"芦荟","quality":"传奇","count":1},
+      {"name":"金橘","quality":"传奇","count":1}
+    ]
+}
\ No newline at end of file
diff --git a/Server/game_saves/3346964708.json.backup b/Server/game_saves/3346964708.json.backup
new file mode 100644
index 0000000..7fd01d5
--- /dev/null
+++ b/Server/game_saves/3346964708.json.backup
@@ -0,0 +1,545 @@
+{
+  "experience": 4193,
+  "level": 8,
+  "money": 28470,
+  "farm_name": "困困的鼠鼠",
+  "user_name": "3346964708",
+  "player_name": "OVO",
+  "user_password": "123456",
+  "last_login_time": "2025年05月26日23时53分53秒",
+  "total_login_time": "0时7分6秒",
+  "farm_lots": [
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5
+    }
+  ],
+  "player_bag": [
+    {
+      "name": "测试作物",
+      "quality": "普通",
+      "count": 3
+    },
+    {
+      "name": "小麦",
+      "quality": "普通",
+      "count": 3
+    },
+    {
+      "name": "稻谷",
+      "quality": "普通",
+      "count": 1
+    },
+    {
+      "name": "玉米",
+      "quality": "普通",
+      "count": 1
+    },
+    {
+      "name": "土豆",
+      "quality": "普通",
+      "count": 1
+    },
+    {
+      "name": "胡萝卜",
+      "quality": "普通",
+      "count": 1
+    },
+    {
+      "name": "草莓",
+      "quality": "优良",
+      "count": 1
+    },
+    {
+      "name": "番茄",
+      "quality": "优良",
+      "count": 1
+    },
+    {
+      "name": "大豆",
+      "quality": "优良",
+      "count": 1
+    },
+    {
+      "name": "蓝莓",
+      "quality": "稀有",
+      "count": 1
+    },
+    {
+      "name": "洋葱",
+      "quality": "稀有",
+      "count": 1
+    },
+    {
+      "name": "南瓜",
+      "quality": "稀有",
+      "count": 1
+    },
+    {
+      "name": "葡萄",
+      "quality": "稀有",
+      "count": 1
+    },
+    {
+      "name": "柿子",
+      "quality": "稀有",
+      "count": 1
+    },
+    {
+      "name": "芦笋",
+      "quality": "稀有",
+      "count": 1
+    },
+    {
+      "name": "花椰菜",
+      "quality": "稀有",
+      "count": 1
+    },
+    {
+      "name": "香草",
+      "quality": "史诗",
+      "count": 1
+    },
+    {
+      "name": "西瓜",
+      "quality": "史诗",
+      "count": 1
+    },
+    {
+      "name": "甜菜",
+      "quality": "史诗",
+      "count": 1
+    },
+    {
+      "name": "甘蔗",
+      "quality": "史诗",
+      "count": 1
+    },
+    {
+      "name": "龙果",
+      "quality": "传奇",
+      "count": 1
+    },
+    {
+      "name": "松露",
+      "quality": "传奇",
+      "count": 1
+    },
+    {
+      "name": "人参",
+      "quality": "传奇",
+      "count": 1
+    },
+    {
+      "name": "富贵竹",
+      "quality": "传奇",
+      "count": 1
+    },
+    {
+      "name": "芦荟",
+      "quality": "传奇",
+      "count": 1
+    },
+    {
+      "name": "金橘",
+      "quality": "传奇",
+      "count": 1
+    }
+  ]
+}
\ No newline at end of file
diff --git a/components/ToastShow.gd b/components/ToastShow.gd
index db877e3..35ba943 100644
--- a/components/ToastShow.gd
+++ b/components/ToastShow.gd
@@ -15,7 +15,7 @@ func setup(text: String, color: Color, duration: float, fade: float):
 	display_time = duration
 	fade_duration = fade
 	# 确保添加到场景树
-	Engine.get_main_loop().root.add_child(self)
+	Engine.get_main_loop().root.get_node("main/UI").add_child(self)
 	Toast(text, color)
 
 func Toast(text: String, text_color: Color = Color.WHITE):
diff --git a/project.godot b/project.godot
index 73e21b1..4f13a2d 100644
--- a/project.godot
+++ b/project.godot
@@ -26,6 +26,7 @@ GlobalVariables="*res://GlobalScript/GlobalVariables.gd"
 
 window/size/viewport_width=1400
 window/size/viewport_height=720
+window/size/resizable=false
 window/stretch/mode="viewport"
 window/per_pixel_transparency/allowed=true
 window/vsync/vsync_mode=0
diff --git a/server/game_saves/3205788256.json b/server/game_saves/3205788256.json
index 0a8e8e4..4ad8280 100644
--- a/server/game_saves/3205788256.json
+++ b/server/game_saves/3205788256.json
@@ -1,45 +1,59 @@
 {
-  "experience": 6,
   "farm_lots": [
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "小麦",
+      "grow_time": 120,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
+      "is_planted": true,
+      "max_grow_time": 120,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 3
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "花椰菜",
+      "grow_time": 960,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 960
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "金橘",
-      "grow_time": 647,
+      "grow_time": 4800,
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 4800
+      "max_grow_time": 4800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "松露",
-      "grow_time": 659,
+      "grow_time": 7200,
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 7200
+      "max_grow_time": 7200,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "人参",
@@ -47,7 +61,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 6600
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "草莓",
@@ -55,7 +72,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 960
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "芦笋",
@@ -63,7 +83,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 1560
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "花椰菜",
@@ -71,7 +94,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 960
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "花椰菜",
@@ -79,47 +105,66 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 960
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "松露",
+      "grow_time": 6675,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 5
+      "is_planted": true,
+      "max_grow_time": 7200,
+      "已浇水": true,
+      "已施肥": true,
+      "土地等级": 1,
+      "施肥时间": 1748345974.8872685
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 4800
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "小麦",
+      "grow_time": 120,
       "is_dead": false,
       "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 1800
+      "is_planted": true,
+      "max_grow_time": 120,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "芦笋",
-      "grow_time": 661,
+      "grow_time": 1560,
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 1560
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "人参",
@@ -127,7 +172,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 6600
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "胡萝卜",
@@ -135,7 +183,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 480
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "胡萝卜",
@@ -143,7 +194,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 480
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "花椰菜",
@@ -151,7 +205,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 960
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "龙果",
@@ -159,23 +216,33 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 4800
+      "max_grow_time": 4800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "小麦",
+      "grow_time": 120,
       "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
+      "crop_type": "人参",
+      "grow_time": 6070,
       "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": true,
+      "已施肥": true,
+      "土地等级": 1,
+      "施肥时间": 1748345990.2872767
     },
     {
       "crop_type": "",
@@ -183,7 +250,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": false,
-      "max_grow_time": 960
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "",
@@ -191,47 +261,88 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": false,
-      "max_grow_time": 1560
+      "max_grow_time": 1800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 1
     },
     {
-      "crop_type": "稻谷",
-      "grow_time": 240,
+      "crop_type": "芦荟",
+      "grow_time": 1449,
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 240
+      "max_grow_time": 6600,
+      "已浇水": true,
+      "已施肥": true,
+      "土地等级": 1,
+      "施肥时间": 1748346006.4554875
     },
     {
-      "crop_type": "富贵竹",
-      "grow_time": 5952,
+      "crop_type": "小麦",
+      "grow_time": 120,
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 6600
+      "max_grow_time": 120,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 1
     },
     {
-      "crop_type": "金橘",
-      "grow_time": 4800,
+      "crop_type": "番茄",
+      "grow_time": 720,
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 4800
+      "max_grow_time": 720,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
-      "crop_type": "胡萝卜",
-      "grow_time": 480,
+      "crop_type": "香草",
+      "grow_time": 1175,
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 480
+      "max_grow_time": 1800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
-      "crop_type": "草莓",
-      "grow_time": 960,
+      "crop_type": "芦笋",
+      "grow_time": 1174,
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 960
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "甜菜",
+      "grow_time": 1172,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 2160,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "松露",
+      "grow_time": 7200,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 7200,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "人参",
@@ -239,55 +350,21 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 6600
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": false,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "",
-      "grow_time": 0,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": false,
-      "max_grow_time": 5
-    },
-    {
-      "crop_type": "胡萝卜",
-      "grow_time": 480,
+      "crop_type": "草莓",
+      "grow_time": 960,
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 480
-    },
-    {
-      "crop_type": "富贵竹",
-      "grow_time": 5968,
-      "is_dead": false,
-      "is_diged": true,
-      "is_planted": true,
-      "max_grow_time": 6600
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "芦笋",
@@ -295,7 +372,10 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 1560
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "花椰菜",
@@ -303,7 +383,32 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 960
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "花椰菜",
@@ -311,7 +416,65 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 960
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "松露",
+      "grow_time": 7200,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 7200,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "草莓",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     },
     {
       "crop_type": "花椰菜",
@@ -319,34 +482,638 @@
       "is_dead": false,
       "is_diged": true,
       "is_planted": true,
-      "max_grow_time": 960
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 5253,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": true,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "小麦",
+      "grow_time": 120,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 120,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "龙果",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 5179,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 5771,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "香草",
+      "grow_time": 1800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "稻谷",
+      "grow_time": 240,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 240,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "西瓜",
+      "grow_time": 2400,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 2400,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "松露",
+      "grow_time": 7200,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 7200,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "草莓",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "甜菜",
+      "grow_time": 2160,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 2160,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 906,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": true,
+      "已施肥": false,
+      "土地等级": 1
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "龙果",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "香草",
+      "grow_time": 1800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 5771,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "香草",
+      "grow_time": 1800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "稻谷",
+      "grow_time": 240,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 240,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "富贵竹",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "金橘",
+      "grow_time": 4800,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 4800,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "草莓",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "",
+      "grow_time": 0,
+      "is_dead": false,
+      "is_diged": false,
+      "is_planted": false,
+      "max_grow_time": 5,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "胡萝卜",
+      "grow_time": 480,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 480,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "甜菜",
+      "grow_time": 2160,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 2160,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "西瓜",
+      "grow_time": 2400,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 2400,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "人参",
+      "grow_time": 6600,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 6600,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "芦笋",
+      "grow_time": 1560,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 1560,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
+    },
+    {
+      "crop_type": "花椰菜",
+      "grow_time": 960,
+      "is_dead": false,
+      "is_diged": true,
+      "is_planted": true,
+      "max_grow_time": 960,
+      "已浇水": false,
+      "已施肥": false,
+      "土地等级": 0
     }
   ],
   "player_bag": [
     {
-      "count": 16,
-      "name": "测试作物",
-      "quality": "普通"
-    },
-    {
-      "count": 260,
+      "count": 272,
       "name": "金橘",
       "quality": "传奇"
     },
     {
       "name": "胡萝卜",
       "quality": "普通",
-      "count": 11
-    },
-    {
-      "name": "花椰菜",
-      "quality": "稀有",
-      "count": 1
-    },
-    {
-      "name": "芦笋",
-      "quality": "稀有",
-      "count": 1
+      "count": 9
     },
     {
       "name": "人参",
@@ -356,25 +1123,112 @@
     {
       "name": "松露",
       "quality": "传奇",
-      "count": 7
+      "count": 8
     },
     {
       "name": "富贵竹",
       "quality": "传奇",
-      "count": 9
+      "count": 16
     },
     {
       "name": "芦荟",
       "quality": "传奇",
+      "count": 15
+    },
+    {
+      "name": "稻谷",
+      "quality": "普通",
+      "count": 15
+    },
+    {
+      "name": "小麦",
+      "quality": "普通",
+      "count": 3
+    },
+    {
+      "name": "测试作物",
+      "quality": "普通",
+      "count": 8
+    },
+    {
+      "name": "番茄",
+      "quality": "优良",
+      "count": 16
+    },
+    {
+      "name": "香草",
+      "quality": "史诗",
+      "count": 10
+    },
+    {
+      "name": "龙果",
+      "quality": "传奇",
       "count": 6
+    },
+    {
+      "name": "甘蔗",
+      "quality": "史诗",
+      "count": 2
+    },
+    {
+      "name": "甜菜",
+      "quality": "史诗",
+      "count": 2
+    },
+    {
+      "name": "西瓜",
+      "quality": "史诗",
+      "count": 1
+    },
+    {
+      "name": "葡萄",
+      "quality": "稀有",
+      "count": 2
+    },
+    {
+      "name": "南瓜",
+      "quality": "稀有",
+      "count": 2
+    },
+    {
+      "name": "玉米",
+      "quality": "普通",
+      "count": 1
+    },
+    {
+      "name": "土豆",
+      "quality": "普通",
+      "count": 1
+    },
+    {
+      "name": "草莓",
+      "quality": "优良",
+      "count": 1
+    },
+    {
+      "name": "大豆",
+      "quality": "优良",
+      "count": 1
+    },
+    {
+      "name": "蓝莓",
+      "quality": "稀有",
+      "count": 1
+    },
+    {
+      "name": "洋葱",
+      "quality": "稀有",
+      "count": 2
     }
   ],
+  "experience": 852,
   "farm_name": "树萌芽の大农场",
   "player_name": "树萌芽",
-  "level": 37,
-  "money": 18663,
-  "last_login_time": "2025年05月25日18时37分14秒",
-  "total_login_time": "102时27分46秒",
+  "level": 41,
+  "money": 320,
+  "last_login_time": "2025年05月27日19时44分30秒",
+  "total_login_time": "104时25分34秒",
   "user_name": "3205788256",
-  "user_password": "tyh@19900420"
+  "user_password": "tyh@19900420",
+  "last_water_reset_date": "2025-05-27"
 }
\ No newline at end of file
diff --git a/test_version_validation.md b/test_version_validation.md
new file mode 100644
index 0000000..cf9c7ed
--- /dev/null
+++ b/test_version_validation.md
@@ -0,0 +1,100 @@
+# 版本号验证功能测试指南
+
+## 功能概述
+实现了客户端和服务端的版本号验证机制，确保只有版本匹配的客户端才能登录或注册游戏。
+
+## 实现的功能
+
+### 1. 客户端修改
+- 在 `MainGame.gd` 中定义了客户端版本号：`const client_version :String = "1.0.1"`
+- 在 `TCPNetworkManager.gd` 中修改了登录和注册请求，添加了版本号字段
+- 在 `login_panel.gd` 中添加了版本号显示功能
+
+### 2. 服务端修改
+- 在 `TCPGameServer.py` 中定义了服务端版本号：`server_version: str = "1.0.1"`
+- 添加了版本号验证函数 `_check_client_version()`
+- 在登录和注册处理中添加了版本号验证逻辑
+- 在服务器启动时显示版本信息
+
+## 测试步骤
+
+### 测试1：版本匹配（正常情况）
+1. 确保客户端和服务端版本号都是 "1.0.1"
+2. 启动服务器，应该看到：
+   ```
+   萌芽农场游戏服务器 v1.0.1
+   服务器地址: 0.0.0.0:4040
+   ==================================================
+   ```
+3. 启动客户端，应该看到：
+   ```
+   萌芽农场客户端 v1.0.1 启动
+   ```
+4. 在登录界面应该显示：`萌芽农场 v1.0.1 - 欢迎使用`
+5. 尝试登录或注册，应该正常工作
+
+### 测试2：版本不匹配（客户端版本较低）
+1. 修改客户端版本号为 "0.9.0"：
+   ```gdscript
+   const client_version :String = "0.9.0"
+   ```
+2. 保持服务端版本为 "1.0.0"
+3. 重新启动客户端
+4. 尝试登录，应该收到错误消息：
+   ```
+   版本不匹配！客户端版本: 0.9.0, 服务端版本: 1.0.1，请更新客户端
+   ```
+5. 尝试注册，应该收到相同的错误消息
+
+### 测试3：版本不匹配（客户端版本较高）
+1. 修改客户端版本号为 "1.1.0"：
+   ```gdscript
+   const client_version :String = "1.1.0"
+   ```
+2. 保持服务端版本为 "1.0.1"
+3. 重新启动客户端
+4. 尝试登录或注册，应该收到版本不匹配的错误消息
+
+### 测试4：空版本号处理
+1. 修改客户端代码，发送空的版本号
+2. 尝试登录或注册，应该被拒绝
+
+## 预期结果
+
+### 成功情况
+- 版本匹配时，登录和注册功能正常工作
+- 客户端和服务端都显示正确的版本信息
+
+### 失败情况
+- 版本不匹配时，登录和注册被拒绝
+- 显示清晰的错误消息，指出版本不匹配的具体信息
+- 服务端记录相应的警告日志
+
+## 日志示例
+
+### 服务端日志（版本匹配）
+```
+[INFO] [SERVER] TCP游戏服务器初始化 - 版本: 1.0.1
+[INFO] [SERVER] 用户 12345 登录成功
+```
+
+### 服务端日志（版本不匹配）
+```
+[WARNING] [SERVER] 用户 12345 登录失败: 版本不匹配 (客户端: 0.9.0, 服务端: 1.0.1)
+```
+
+## 注意事项
+
+1. **版本号格式**：建议使用语义化版本号格式（如 1.0.0）
+2. **向后兼容性**：如果需要支持多个版本，可以修改验证逻辑
+3. **版本更新策略**：
+   - 主版本号变更：不兼容的重大更新
+   - 次版本号变更：向后兼容的功能更新
+   - 修订版本号变更：向后兼容的问题修复
+
+## 扩展功能建议
+
+1. **版本兼容性矩阵**：支持多个兼容版本
+2. **自动更新提示**：客户端检测到版本不匹配时提供更新链接
+3. **最低版本要求**：设置服务端支持的最低客户端版本
+4. **版本信息API**：提供接口查询当前服务端版本和兼容的客户端版本列表 
\ No newline at end of file