584 lines
16 KiB
GDScript
584 lines
16 KiB
GDScript
extends Node
|
|
class_name FriendSystem
|
|
## 好友系统
|
|
## 管理玩家之间的好友关系和社交功能
|
|
|
|
# 好友关系数据结构
|
|
class FriendRelationship:
|
|
var friend_id: String
|
|
var friend_name: String
|
|
var status: String # "pending", "accepted", "blocked"
|
|
var added_at: float
|
|
var last_interaction: float
|
|
var relationship_level: int = 1 # 关系等级 1-5
|
|
var interaction_count: int = 0
|
|
var shared_activities: Array[String] = []
|
|
|
|
func _init(id: String, name: String, relationship_status: String = "pending"):
|
|
friend_id = id
|
|
friend_name = name
|
|
status = relationship_status
|
|
added_at = Time.get_unix_time_from_system()
|
|
last_interaction = added_at
|
|
|
|
# 好友数据存储
|
|
var friends: Dictionary = {} # friend_id -> FriendRelationship
|
|
var friend_requests: Dictionary = {} # requester_id -> FriendRelationship
|
|
var blocked_users: Dictionary = {} # blocked_id -> timestamp
|
|
var max_friends: int = 100
|
|
var max_pending_requests: int = 20
|
|
|
|
# 数据持久化
|
|
var friends_file_path: String = "user://friends_data.json"
|
|
|
|
# 信号
|
|
signal friend_request_sent(friend_id: String, friend_name: String)
|
|
# signal friend_request_received(requester_id: String, requester_name: String) # 暂时未使用
|
|
signal friend_request_accepted(friend_id: String, friend_name: String)
|
|
signal friend_request_declined(requester_id: String)
|
|
signal friend_removed(friend_id: String, friend_name: String)
|
|
signal friend_blocked(friend_id: String, friend_name: String)
|
|
signal friend_unblocked(friend_id: String, friend_name: String)
|
|
signal friend_online(friend_id: String, friend_name: String)
|
|
signal friend_offline(friend_id: String, friend_name: String)
|
|
signal relationship_level_changed(friend_id: String, old_level: int, new_level: int)
|
|
|
|
func _ready():
|
|
"""初始化好友系统"""
|
|
load_friends_data()
|
|
print("FriendSystem initialized")
|
|
|
|
## 发送好友请求
|
|
func send_friend_request(target_id: String, target_name: String) -> bool:
|
|
"""
|
|
向指定玩家发送好友请求
|
|
@param target_id: 目标玩家ID
|
|
@param target_name: 目标玩家名称
|
|
@return: 是否成功发送
|
|
"""
|
|
# 验证输入
|
|
if target_id.is_empty() or target_name.is_empty():
|
|
print("Invalid target for friend request")
|
|
return false
|
|
|
|
# 检查是否已经是好友
|
|
if friends.has(target_id):
|
|
print("Already friends with: ", target_name)
|
|
return false
|
|
|
|
# 检查是否已发送过请求
|
|
if friend_requests.has(target_id):
|
|
print("Friend request already sent to: ", target_name)
|
|
return false
|
|
|
|
# 检查是否被屏蔽
|
|
if blocked_users.has(target_id):
|
|
print("Cannot send friend request to blocked user: ", target_name)
|
|
return false
|
|
|
|
# 检查好友数量限制
|
|
if friends.size() >= max_friends:
|
|
print("Friend list is full")
|
|
return false
|
|
|
|
# 检查待处理请求数量
|
|
if friend_requests.size() >= max_pending_requests:
|
|
print("Too many pending friend requests")
|
|
return false
|
|
|
|
# 创建好友请求
|
|
var relationship = FriendRelationship.new(target_id, target_name, "pending")
|
|
friend_requests[target_id] = relationship
|
|
|
|
# 保存数据
|
|
save_friends_data()
|
|
|
|
# 发射信号
|
|
friend_request_sent.emit(target_id, target_name)
|
|
|
|
print("Friend request sent to: ", target_name)
|
|
return true
|
|
|
|
## 接受好友请求
|
|
func accept_friend_request(requester_id: String) -> bool:
|
|
"""
|
|
接受好友请求
|
|
@param requester_id: 请求者ID
|
|
@return: 是否成功接受
|
|
"""
|
|
if not friend_requests.has(requester_id):
|
|
print("No friend request from: ", requester_id)
|
|
return false
|
|
|
|
var relationship = friend_requests[requester_id]
|
|
|
|
# 检查好友数量限制
|
|
if friends.size() >= max_friends:
|
|
print("Friend list is full, cannot accept request")
|
|
return false
|
|
|
|
# 移动到好友列表
|
|
relationship.status = "accepted"
|
|
friends[requester_id] = relationship
|
|
friend_requests.erase(requester_id)
|
|
|
|
# 保存数据
|
|
save_friends_data()
|
|
|
|
# 发射信号
|
|
friend_request_accepted.emit(requester_id, relationship.friend_name)
|
|
|
|
print("Friend request accepted from: ", relationship.friend_name)
|
|
return true
|
|
|
|
## 拒绝好友请求
|
|
func decline_friend_request(requester_id: String) -> bool:
|
|
"""
|
|
拒绝好友请求
|
|
@param requester_id: 请求者ID
|
|
@return: 是否成功拒绝
|
|
"""
|
|
if not friend_requests.has(requester_id):
|
|
print("No friend request from: ", requester_id)
|
|
return false
|
|
|
|
var relationship = friend_requests[requester_id]
|
|
friend_requests.erase(requester_id)
|
|
|
|
# 保存数据
|
|
save_friends_data()
|
|
|
|
# 发射信号
|
|
friend_request_declined.emit(requester_id)
|
|
|
|
print("Friend request declined from: ", relationship.friend_name)
|
|
return true
|
|
|
|
## 移除好友
|
|
func remove_friend(friend_id: String) -> bool:
|
|
"""
|
|
移除好友
|
|
@param friend_id: 好友ID
|
|
@return: 是否成功移除
|
|
"""
|
|
if not friends.has(friend_id):
|
|
print("Not friends with: ", friend_id)
|
|
return false
|
|
|
|
var relationship = friends[friend_id]
|
|
friends.erase(friend_id)
|
|
|
|
# 保存数据
|
|
save_friends_data()
|
|
|
|
# 发射信号
|
|
friend_removed.emit(friend_id, relationship.friend_name)
|
|
|
|
print("Friend removed: ", relationship.friend_name)
|
|
return true
|
|
|
|
## 屏蔽用户
|
|
func block_user(user_id: String, user_name: String) -> bool:
|
|
"""
|
|
屏蔽用户
|
|
@param user_id: 用户ID
|
|
@param user_name: 用户名称
|
|
@return: 是否成功屏蔽
|
|
"""
|
|
if blocked_users.has(user_id):
|
|
print("User already blocked: ", user_name)
|
|
return false
|
|
|
|
# 添加到屏蔽列表
|
|
blocked_users[user_id] = Time.get_unix_time_from_system()
|
|
|
|
# 如果是好友，移除好友关系
|
|
if friends.has(user_id):
|
|
remove_friend(user_id)
|
|
|
|
# 如果有待处理的好友请求，移除
|
|
if friend_requests.has(user_id):
|
|
friend_requests.erase(user_id)
|
|
|
|
# 保存数据
|
|
save_friends_data()
|
|
|
|
# 发射信号
|
|
friend_blocked.emit(user_id, user_name)
|
|
|
|
print("User blocked: ", user_name)
|
|
return true
|
|
|
|
## 解除屏蔽
|
|
func unblock_user(user_id: String, user_name: String) -> bool:
|
|
"""
|
|
解除用户屏蔽
|
|
@param user_id: 用户ID
|
|
@param user_name: 用户名称
|
|
@return: 是否成功解除屏蔽
|
|
"""
|
|
if not blocked_users.has(user_id):
|
|
print("User not blocked: ", user_name)
|
|
return false
|
|
|
|
blocked_users.erase(user_id)
|
|
|
|
# 保存数据
|
|
save_friends_data()
|
|
|
|
# 发射信号
|
|
friend_unblocked.emit(user_id, user_name)
|
|
|
|
print("User unblocked: ", user_name)
|
|
return true
|
|
|
|
## 记录互动
|
|
func record_interaction(friend_id: String, activity_type: String = "chat") -> void:
|
|
"""
|
|
记录与好友的互动
|
|
@param friend_id: 好友ID
|
|
@param activity_type: 活动类型
|
|
"""
|
|
if not friends.has(friend_id):
|
|
return
|
|
|
|
var relationship = friends[friend_id]
|
|
relationship.last_interaction = Time.get_unix_time_from_system()
|
|
relationship.interaction_count += 1
|
|
|
|
# 添加到共同活动
|
|
if not activity_type in relationship.shared_activities:
|
|
relationship.shared_activities.append(activity_type)
|
|
|
|
# 检查关系等级提升
|
|
_check_relationship_level_up(friend_id)
|
|
|
|
# 保存数据
|
|
save_friends_data()
|
|
|
|
## 检查关系等级提升
|
|
func _check_relationship_level_up(friend_id: String) -> void:
|
|
"""
|
|
检查并处理关系等级提升
|
|
@param friend_id: 好友ID
|
|
"""
|
|
if not friends.has(friend_id):
|
|
return
|
|
|
|
var relationship = friends[friend_id]
|
|
var old_level = relationship.relationship_level
|
|
var new_level = _calculate_relationship_level(relationship)
|
|
|
|
if new_level > old_level:
|
|
relationship.relationship_level = new_level
|
|
relationship_level_changed.emit(friend_id, old_level, new_level)
|
|
print("Relationship level increased with ", relationship.friend_name, ": ", old_level, " -> ", new_level)
|
|
|
|
## 计算关系等级
|
|
func _calculate_relationship_level(relationship: FriendRelationship) -> int:
|
|
"""
|
|
根据互动数据计算关系等级
|
|
@param relationship: 好友关系数据
|
|
@return: 关系等级 (1-5)
|
|
"""
|
|
var level = 1
|
|
|
|
# 基于互动次数
|
|
if relationship.interaction_count >= 10:
|
|
level = 2
|
|
if relationship.interaction_count >= 50:
|
|
level = 3
|
|
if relationship.interaction_count >= 100:
|
|
level = 4
|
|
if relationship.interaction_count >= 200:
|
|
level = 5
|
|
|
|
# 基于共同活动种类
|
|
var activity_bonus = min(relationship.shared_activities.size() / 3.0, 1)
|
|
level = min(level + activity_bonus, 5)
|
|
|
|
# 基于关系持续时间（天数）
|
|
var days_since_added = (Time.get_unix_time_from_system() - relationship.added_at) / 86400.0
|
|
if days_since_added >= 7: # 一周
|
|
level = min(level + 1, 5)
|
|
|
|
return level
|
|
|
|
## 获取好友列表
|
|
func get_friends_list() -> Array[Dictionary]:
|
|
"""
|
|
获取好友列表
|
|
@return: 好友信息数组
|
|
"""
|
|
var friends_list = []
|
|
|
|
for friend_id in friends:
|
|
var relationship = friends[friend_id]
|
|
friends_list.append({
|
|
"id": friend_id,
|
|
"name": relationship.friend_name,
|
|
"status": relationship.status,
|
|
"relationship_level": relationship.relationship_level,
|
|
"last_interaction": relationship.last_interaction,
|
|
"interaction_count": relationship.interaction_count,
|
|
"shared_activities": relationship.shared_activities.duplicate(),
|
|
"added_at": relationship.added_at
|
|
})
|
|
|
|
# 按关系等级和最后互动时间排序
|
|
friends_list.sort_custom(func(a, b):
|
|
if a.relationship_level != b.relationship_level:
|
|
return a.relationship_level > b.relationship_level
|
|
return a.last_interaction > b.last_interaction
|
|
)
|
|
|
|
return friends_list
|
|
|
|
## 获取好友请求列表
|
|
func get_friend_requests() -> Array[Dictionary]:
|
|
"""
|
|
获取待处理的好友请求列表
|
|
@return: 好友请求信息数组
|
|
"""
|
|
var requests = []
|
|
|
|
for requester_id in friend_requests:
|
|
var relationship = friend_requests[requester_id]
|
|
requests.append({
|
|
"id": requester_id,
|
|
"name": relationship.friend_name,
|
|
"requested_at": relationship.added_at
|
|
})
|
|
|
|
# 按请求时间排序（最新的在前）
|
|
requests.sort_custom(func(a, b): return a.requested_at > b.requested_at)
|
|
|
|
return requests
|
|
|
|
## 获取屏蔽列表
|
|
func get_blocked_users() -> Array[Dictionary]:
|
|
"""
|
|
获取屏蔽用户列表
|
|
@return: 屏蔽用户信息数组
|
|
"""
|
|
var blocked = []
|
|
|
|
for user_id in blocked_users:
|
|
blocked.append({
|
|
"id": user_id,
|
|
"blocked_at": blocked_users[user_id]
|
|
})
|
|
|
|
# 按屏蔽时间排序（最新的在前）
|
|
blocked.sort_custom(func(a, b): return a.blocked_at > b.blocked_at)
|
|
|
|
return blocked
|
|
|
|
## 检查是否为好友
|
|
func is_friend(user_id: String) -> bool:
|
|
"""
|
|
检查是否为好友
|
|
@param user_id: 用户ID
|
|
@return: 是否为好友
|
|
"""
|
|
return friends.has(user_id) and friends[user_id].status == "accepted"
|
|
|
|
## 检查是否被屏蔽
|
|
func is_blocked(user_id: String) -> bool:
|
|
"""
|
|
检查用户是否被屏蔽
|
|
@param user_id: 用户ID
|
|
@return: 是否被屏蔽
|
|
"""
|
|
return blocked_users.has(user_id)
|
|
|
|
## 获取好友信息
|
|
func get_friend_info(friend_id: String) -> Dictionary:
|
|
"""
|
|
获取好友详细信息
|
|
@param friend_id: 好友ID
|
|
@return: 好友信息字典
|
|
"""
|
|
if not friends.has(friend_id):
|
|
return {}
|
|
|
|
var relationship = friends[friend_id]
|
|
return {
|
|
"id": friend_id,
|
|
"name": relationship.friend_name,
|
|
"status": relationship.status,
|
|
"relationship_level": relationship.relationship_level,
|
|
"last_interaction": relationship.last_interaction,
|
|
"interaction_count": relationship.interaction_count,
|
|
"shared_activities": relationship.shared_activities.duplicate(),
|
|
"added_at": relationship.added_at,
|
|
"days_since_added": (Time.get_unix_time_from_system() - relationship.added_at) / 86400.0
|
|
}
|
|
|
|
## 搜索好友
|
|
func search_friends(query: String) -> Array[Dictionary]:
|
|
"""
|
|
搜索好友
|
|
@param query: 搜索关键词
|
|
@return: 匹配的好友信息数组
|
|
"""
|
|
var results = []
|
|
var search_query = query.to_lower()
|
|
|
|
for friend_id in friends:
|
|
var relationship = friends[friend_id]
|
|
if relationship.friend_name.to_lower().contains(search_query):
|
|
results.append(get_friend_info(friend_id))
|
|
|
|
return results
|
|
|
|
## 获取在线好友
|
|
func get_online_friends(online_characters: Array[String]) -> Array[Dictionary]:
|
|
"""
|
|
获取当前在线的好友列表
|
|
@param online_characters: 在线角色ID数组
|
|
@return: 在线好友信息数组
|
|
"""
|
|
var online_friends = []
|
|
|
|
for friend_id in friends:
|
|
if friend_id in online_characters:
|
|
online_friends.append(get_friend_info(friend_id))
|
|
|
|
return online_friends
|
|
|
|
## 处理好友上线
|
|
func handle_friend_online(friend_id: String) -> void:
|
|
"""
|
|
处理好友上线事件
|
|
@param friend_id: 好友ID
|
|
"""
|
|
if friends.has(friend_id):
|
|
var relationship = friends[friend_id]
|
|
friend_online.emit(friend_id, relationship.friend_name)
|
|
print("Friend came online: ", relationship.friend_name)
|
|
|
|
## 处理好友下线
|
|
func handle_friend_offline(friend_id: String) -> void:
|
|
"""
|
|
处理好友下线事件
|
|
@param friend_id: 好友ID
|
|
"""
|
|
if friends.has(friend_id):
|
|
var relationship = friends[friend_id]
|
|
friend_offline.emit(friend_id, relationship.friend_name)
|
|
print("Friend went offline: ", relationship.friend_name)
|
|
|
|
## 保存好友数据
|
|
func save_friends_data() -> void:
|
|
"""保存好友数据到本地文件"""
|
|
var data = {
|
|
"friends": {},
|
|
"friend_requests": {},
|
|
"blocked_users": blocked_users
|
|
}
|
|
|
|
# 序列化好友数据
|
|
for friend_id in friends:
|
|
var relationship = friends[friend_id]
|
|
data.friends[friend_id] = {
|
|
"friend_name": relationship.friend_name,
|
|
"status": relationship.status,
|
|
"added_at": relationship.added_at,
|
|
"last_interaction": relationship.last_interaction,
|
|
"relationship_level": relationship.relationship_level,
|
|
"interaction_count": relationship.interaction_count,
|
|
"shared_activities": relationship.shared_activities
|
|
}
|
|
|
|
# 序列化好友请求数据
|
|
for requester_id in friend_requests:
|
|
var relationship = friend_requests[requester_id]
|
|
data.friend_requests[requester_id] = {
|
|
"friend_name": relationship.friend_name,
|
|
"status": relationship.status,
|
|
"added_at": relationship.added_at
|
|
}
|
|
|
|
var file = FileAccess.open(friends_file_path, FileAccess.WRITE)
|
|
if file:
|
|
var json_string = JSON.stringify(data)
|
|
file.store_string(json_string)
|
|
file.close()
|
|
print("Friends data saved")
|
|
else:
|
|
print("Failed to save friends data")
|
|
|
|
## 加载好友数据
|
|
func load_friends_data() -> void:
|
|
"""从本地文件加载好友数据"""
|
|
if not FileAccess.file_exists(friends_file_path):
|
|
print("No friends data file found, starting fresh")
|
|
return
|
|
|
|
var file = FileAccess.open(friends_file_path, FileAccess.READ)
|
|
if file:
|
|
var json_string = file.get_as_text()
|
|
file.close()
|
|
|
|
var json = JSON.new()
|
|
var parse_result = json.parse(json_string)
|
|
|
|
if parse_result == OK:
|
|
var data = json.data
|
|
|
|
# 加载好友数据
|
|
if data.has("friends"):
|
|
for friend_id in data.friends:
|
|
var friend_data = data.friends[friend_id]
|
|
var relationship = FriendRelationship.new(friend_id, friend_data.friend_name, friend_data.status)
|
|
relationship.added_at = friend_data.get("added_at", Time.get_unix_time_from_system())
|
|
relationship.last_interaction = friend_data.get("last_interaction", relationship.added_at)
|
|
relationship.relationship_level = friend_data.get("relationship_level", 1)
|
|
relationship.interaction_count = friend_data.get("interaction_count", 0)
|
|
relationship.shared_activities = friend_data.get("shared_activities", [])
|
|
friends[friend_id] = relationship
|
|
|
|
# 加载好友请求数据
|
|
if data.has("friend_requests"):
|
|
for requester_id in data.friend_requests:
|
|
var request_data = data.friend_requests[requester_id]
|
|
var relationship = FriendRelationship.new(requester_id, request_data.friend_name, request_data.status)
|
|
relationship.added_at = request_data.get("added_at", Time.get_unix_time_from_system())
|
|
friend_requests[requester_id] = relationship
|
|
|
|
# 加载屏蔽数据
|
|
if data.has("blocked_users"):
|
|
blocked_users = data.blocked_users
|
|
|
|
print("Friends data loaded: ", friends.size(), " friends, ", friend_requests.size(), " requests, ", blocked_users.size(), " blocked")
|
|
else:
|
|
print("Failed to parse friends data JSON")
|
|
else:
|
|
print("Failed to open friends data file")
|
|
|
|
## 获取统计信息
|
|
func get_statistics() -> Dictionary:
|
|
"""
|
|
获取好友系统统计信息
|
|
@return: 统计信息字典
|
|
"""
|
|
var level_counts = {}
|
|
var total_interactions = 0
|
|
|
|
for friend_id in friends:
|
|
var relationship = friends[friend_id]
|
|
var level = relationship.relationship_level
|
|
level_counts[level] = level_counts.get(level, 0) + 1
|
|
total_interactions += relationship.interaction_count
|
|
|
|
return {
|
|
"total_friends": friends.size(),
|
|
"pending_requests": friend_requests.size(),
|
|
"blocked_users": blocked_users.size(),
|
|
"total_interactions": total_interactions,
|
|
"level_distribution": level_counts,
|
|
"max_friends": max_friends,
|
|
"max_pending_requests": max_pending_requests
|
|
}
|