extends Node # ============================================================================ # ChatManager.gd - 聊天系统业务逻辑核心 # ============================================================================ # 管理聊天功能的核心业务逻辑 # # 核心职责: # - 聊天消息发送/接收协调 # - 客户端频率限制（10条/分钟） # - 消息历史管理（最多100条） # - Signal Up: 通过信号和 EventSystem 向上通知 # - 整合 AuthManager 获取 token # # 使用方式: # ChatManager.connect_to_chat_server() # ChatManager.send_chat_message("Hello", "global") # ChatManager.chat_message_received.connect(_on_message_received) # # 注意事项: # - 作为自动加载单例，全局可访问 # - 遵循 "Signal Up, Call Down" 架构 # - 所有聊天事件通过 EventSystem 广播 # ============================================================================ # ============================================================================ # 信号定义 (Signal Up) # ============================================================================ # 聊天消息已发送信号 # 参数: # message_id: String - 消息 ID # timestamp: float - 时间戳 signal chat_message_sent(message_id: String, timestamp: float) # 聊天消息已接收信号 # 参数: # from_user: String - 发送者用户名 # content: String - 消息内容 # show_bubble: bool - 是否显示气泡 # timestamp: float - 时间戳 signal chat_message_received(from_user: String, content: String, show_bubble: bool, timestamp: float) # 聊天错误发生信号 # 参数: # error_code: String - 错误代码 # message: String - 错误消息 signal chat_error_occurred(error_code: String, message: String) # 聊天连接状态变化信号 # 参数: # state: int - 连接状态（0=DISCONNECTED, 1=CONNECTING, 2=CONNECTED, 3=RECONNECTING, 4=ERROR） signal chat_connection_state_changed(state: int) # 位置更新成功信号 # 参数: # stream: String - Stream 名称 # topic: String - Topic 名称 signal chat_position_updated(stream: String, topic: String) # ============================================================================ # 常量定义 # ============================================================================ const CHAT_WEBSOCKET_MANAGER_SCRIPT: Script = preload("res://_Core/managers/WebSocketManager.gd") const NetworkConfig = preload("res://_Core/utils/NetworkConfig.gd") # WebSocket 服务器 URL（原生 WebSocket） const WEBSOCKET_URL: String = "wss://whaletownend.xinghangee.icu/game" # 重连配置 const RECONNECT_MAX_ATTEMPTS: int = 5 const RECONNECT_BASE_DELAY: float = 3.0 # 频率限制配置 const RATE_LIMIT_MESSAGES: int = 10 const RATE_LIMIT_WINDOW: float = 60.0 # 秒 # 消息限制 const MAX_MESSAGE_LENGTH: int = 1000 # 当前会话消息限制（当前游戏会话，超过后删除最旧的） const MAX_SESSION_MESSAGES: int = 100 # 历史消息分页大小（从 Zulip 后端每次加载的数量） const HISTORY_PAGE_SIZE: int = 100 const GAME_TOKEN_ENV_KEY: String = "WHALETOWN_GAME_TOKEN" const MAX_QUEUED_MESSAGES: int = 10 const MAX_RECOVERABLE_MESSAGES: int = 5 # 错误消息映射 const CHAT_ERROR_MESSAGES: Dictionary = { "AUTH_FAILED": "请先登录后再使用聊天", "RATE_LIMIT": "消息发送过于频繁，请稍后再试", "CONTENT_FILTERED": "消息内容包含违规内容", "CONTENT_TOO_LONG": "消息内容过长（最大1000字符）", "PERMISSION_DENIED": "您没有权限发送消息", "SESSION_EXPIRED": "会话已过期，请重新连接", "ZULIP_ERROR": "消息服务暂时不可用", "INTERNAL_ERROR": "服务器内部错误" } # ============================================================================ # 成员变量 # ============================================================================ # WebSocket 管理器 var _websocket_manager: Node var _history_request: HTTPRequest # 是否已登录 var _is_logged_in: bool = false # 消息历史记录（当前会话，最多100条，超过后删除最旧的） var _message_history: Array[Dictionary] = [] # 历史消息加载状态 var _history_loading: bool = false var _has_more_history: bool = true var _oldest_message_timestamp: float = 0.0 # 消息发送时间戳（用于频率限制） var _message_timestamps: Array[float] = [] # 当前用户信息 var _current_username: String = "" var _current_map: String = "" var _world_ready_map: String = "" # 游戏 token var _game_token: String = "" # 连接/登录完成前暂存用户已经提交的消息，避免刚进游戏时第一条消息被丢掉。 var _queued_messages: Array[Dictionary] = [] var _recoverable_messages: Array[Dictionary] = [] # 发送后本地回显去重（避免服务端也回发导致重复显示） const SELF_ECHO_DEDUPE_WINDOW: float = 10.0 var _pending_self_messages: Array[Dictionary] = [] # 好友列表缓存 var _friends: Array[Dictionary] = [] var _friend_protocol_supported: bool = true # 空消息类型告警限频（避免日志刷屏） const EMPTY_MESSAGE_TYPE_WARNING_INTERVAL: float = 10.0 var _last_empty_message_type_warning_at: float = -1000.0 var _refreshing_auth_session: bool = false var _chat_login_refresh_attempted: bool = false # ============================================================================ # 生命周期方法 # ============================================================================ # 初始化 func _ready() -> void: _load_token_from_environment() # 创建 WebSocket 管理器 _websocket_manager = CHAT_WEBSOCKET_MANAGER_SCRIPT.new() add_child(_websocket_manager) _history_request = HTTPRequest.new() _history_request.timeout = 12.0 _history_request.request_completed.connect(_on_history_request_completed) add_child(_history_request) # 连接信号 _connect_signals() var authManager := get_node_or_null("/root/AuthManager") if authManager != null and authManager.has_signal("profile_update_succeeded"): authManager.connect("profile_update_succeeded", _on_account_profile_updated) if authManager != null and authManager.has_signal("auth_state_changed"): authManager.connect("auth_state_changed", _on_auth_state_changed) # 清理 func _exit_tree() -> void: if is_instance_valid(_websocket_manager): _websocket_manager.queue_free() func _get_event_system() -> Node: return get_node_or_null("/root/EventSystem") func _emit_event(event_name: String, data: Variant = null) -> void: var eventSystem: Node = _get_event_system() if eventSystem == null: return eventSystem.call("emit_event", event_name, data) # ============================================================================ # 公共 API - Token 管理 # ============================================================================ # 设置游戏 token # # 参数: # token: String - 游戏认证 token # # 使用示例: # ChatManager.set_game_token("your_game_token") func set_game_token(token: String) -> void: var normalizedToken := token.strip_edges() if normalizedToken != _game_token: _chat_login_refresh_attempted = false _game_token = normalizedToken if _game_token.strip_edges().is_empty(): _is_logged_in = false _queued_messages.clear() _recoverable_messages.clear() _world_ready_map = "" func is_logged_in() -> bool: return _is_logged_in func mark_world_ready(mapId: String, position: Vector2) -> void: var normalizedMapId := mapId.strip_edges() if not _is_logged_in or normalizedMapId.is_empty() or _world_ready_map == normalizedMapId: return var payload := { "type": "world_ready", "mapId": normalizedMapId, "x": position.x, "y": position.y, } if _websocket_manager.send_message(JSON.stringify(payload)) == OK: _world_ready_map = normalizedMapId func leave_world(sceneId: String = "private_space") -> void: if not _is_logged_in or _world_ready_map.is_empty(): return var normalizedSceneId := sceneId.strip_edges() if normalizedSceneId.is_empty(): normalizedSceneId = "private_space" var payload := { "type": "leave_world", "sceneId": normalizedSceneId, } if _websocket_manager.send_message(JSON.stringify(payload)) == OK: _world_ready_map = "" func notify_appearance_changed() -> void: if not _is_logged_in or _world_ready_map.is_empty(): return _websocket_manager.send_message(JSON.stringify({"type": "appearance_changed"})) # 获取游戏 token # # 返回值: # String - 当前游戏 token func get_game_token() -> String: return _game_token # ============================================================================ # 公共 API - 连接管理 # ============================================================================ # 连接到聊天服务器 func connect_to_chat_server() -> void: if _websocket_manager.is_websocket_connected(): push_warning("聊天服务器已连接") return var connection_state: int = _websocket_manager.call("get_connection_state") if connection_state == 1 or connection_state == 3: push_warning("聊天服务器正在连接") return if _game_token.strip_edges().is_empty(): var authToken := _get_auth_manager_token() if not authToken.is_empty(): _game_token = authToken if _game_token.strip_edges().is_empty(): _handle_error("AUTH_FAILED", "请先登录后再使用聊天") return _websocket_manager.connect_to_game_server() # 断开聊天服务器 func disconnect_from_chat_server() -> void: _queued_messages.clear() _recoverable_messages.clear() # 发送登出消息 if _is_logged_in: var logout_data := {"type": "logout"} _websocket_manager.send_message(JSON.stringify(logout_data)) _is_logged_in = false # 断开连接 _websocket_manager.disconnect_websocket() # 检查是否已连接 # # 返回值: # bool - 是否已连接 func is_chat_connected() -> bool: return _websocket_manager.is_websocket_connected() func is_chat_logged_in() -> bool: return _is_logged_in func can_attempt_chat_connection() -> bool: if not _game_token.strip_edges().is_empty(): return true if not _get_auth_manager_token().is_empty(): return true return false # ============================================================================ # 公共 API - 聊天操作 # ============================================================================ # 发送聊天消息 # # 参数: # content: String - 消息内容 # scope: String - 消息范围（"local" / "global"） # show_bubble: bool - 是否同步显示角色气泡 # # 使用示例: # ChatManager.send_chat_message("Hello, world!", "global") func send_chat_message(content: String, scope: String = "local", show_bubble: bool = false) -> bool: return _send_chat_payload(content, scope, {"bubble": show_bubble and _settings_bool("show_chat_bubbles", true)}) func send_private_message(content: String, target_user_id: String, target_username: String = "", private_context: String = "") -> bool: if not _settings_bool("allow_nearby_private", true) and private_context.strip_edges() == "whisper": _handle_error("PRIVATE_DISABLED", "附近私聊已在设置中关闭") return false var normalized_target_user_id := target_user_id.strip_edges() if normalized_target_user_id.is_empty(): _handle_error("PRIVATE_TARGET_REQUIRED", "请选择悄悄话对象") return false return _send_chat_payload(content, "private", { "targetUserId": normalized_target_user_id, "targetUsername": target_username.strip_edges(), "privateContext": private_context.strip_edges() }) func request_friend_list() -> bool: if not _friend_protocol_supported: _emit_friend_protocol_status("当前聊天后端暂不支持好友功能") return false return _send_friend_command({"type": "friend_list"}) func add_friend(friend_user_id: String, friend_username: String = "") -> bool: if not _friend_protocol_supported: _emit_friend_protocol_status("当前聊天后端暂不支持好友功能") return false var normalized_friend_user_id := friend_user_id.strip_edges() if normalized_friend_user_id.is_empty(): _handle_error("FRIEND_TARGET_REQUIRED", "请选择好友") return false return _send_friend_command({ "type": "friend_add", "friendUserId": normalized_friend_user_id, "friendUsername": friend_username.strip_edges() }) func request_friend(friend_user_id: String, friend_username: String = "") -> bool: if not _settings_bool("allow_nearby_friend_requests", true): _handle_error("FRIEND_REQUEST_DISABLED", "好友申请已在设置中关闭") return false if not _friend_protocol_supported: _emit_friend_protocol_status("当前聊天后端暂不支持好友功能") return false var normalized_friend_user_id := friend_user_id.strip_edges() if normalized_friend_user_id.is_empty(): _handle_error("FRIEND_TARGET_REQUIRED", "请选择好友") return false return _send_friend_command({ "type": "friend_request", "friendUserId": normalized_friend_user_id, "friendUsername": friend_username.strip_edges() }) func accept_friend_request(friend_user_id: String, friend_username: String = "") -> bool: if not _friend_protocol_supported: _emit_friend_protocol_status("当前聊天后端暂不支持好友功能") return false var normalized_friend_user_id := friend_user_id.strip_edges() if normalized_friend_user_id.is_empty(): _handle_error("FRIEND_TARGET_REQUIRED", "请选择好友请求") return false return _send_friend_command({ "type": "friend_accept", "friendUserId": normalized_friend_user_id, "friendUsername": friend_username.strip_edges() }) func reject_friend_request(friend_user_id: String, friend_username: String = "") -> bool: if not _friend_protocol_supported: _emit_friend_protocol_status("当前聊天后端暂不支持好友功能") return false var normalized_friend_user_id := friend_user_id.strip_edges() if normalized_friend_user_id.is_empty(): _handle_error("FRIEND_TARGET_REQUIRED", "请选择好友请求") return false return _send_friend_command({ "type": "friend_reject", "friendUserId": normalized_friend_user_id, "friendUsername": friend_username.strip_edges() }) func remove_friend(friend_user_id: String) -> bool: var normalized_friend_user_id := friend_user_id.strip_edges() if normalized_friend_user_id.is_empty(): return false return _send_friend_command({ "type": "friend_remove", "friendUserId": normalized_friend_user_id }) func get_friends() -> Array[Dictionary]: return _friends.duplicate(true) func _send_friend_command(message_data: Dictionary) -> bool: if not _websocket_manager.is_websocket_connected(): connect_to_chat_server() return false if not _is_logged_in: _handle_error("NOT_LOGGED_IN", "聊天尚未登录") return false var send_err: Error = _websocket_manager.send_message(JSON.stringify(message_data)) if send_err != OK: _handle_error("SEND_FAILED", "WebSocket send failed: %s" % error_string(send_err)) return false return true func _send_chat_payload(content: String, scope: String = "local", extra_data: Dictionary = {}) -> bool: var normalized_content := content.strip_edges() if normalized_content.is_empty(): return false var show_bubble: bool = bool(extra_data.get("bubble", extra_data.get("showBubble", extra_data.get("show_bubble", false)))) and _settings_bool("show_chat_bubbles", true) var suppress_local_echo := bool(extra_data.get("_suppressLocalEcho", false)) var is_recovery_retry := bool(extra_data.get("_isRecoveryRetry", false)) var recoverable_extra_data := extra_data.duplicate(true) recoverable_extra_data.erase("_suppressLocalEcho") # 检查消息长度 if normalized_content.length() > MAX_MESSAGE_LENGTH: _handle_error("CONTENT_TOO_LONG", "消息内容过长") return false # 检查频率限制 if not is_recovery_retry and not can_send_message(): var wait_time := get_time_until_next_message() _handle_error("RATE_LIMIT", "请等待 %.1f 秒后再试" % wait_time) return false # 检查连接状态 if not _websocket_manager.is_websocket_connected(): if _game_token.strip_edges().is_empty(): var authToken := _get_auth_manager_token() if not authToken.is_empty(): _game_token = authToken if _game_token.strip_edges().is_empty(): _handle_error("AUTH_FAILED", "请先登录后再使用聊天") return false if not _queue_message_until_ready(normalized_content, scope, extra_data): return false connect_to_chat_server() return true # 检查登录状态 if not _is_logged_in: return _queue_message_until_ready(normalized_content, scope, extra_data) # 构建消息数据 var message_data := { "type": "chat", "content": normalized_content, "scope": scope, "bubble": show_bubble } for key in extra_data.keys(): if str(key).begins_with("_"): continue message_data[key] = extra_data[key] # 发送消息（JSON 字符串） var json_string := JSON.stringify(message_data) var send_err: Error = _websocket_manager.send_message(json_string) if send_err != OK: _handle_error("SEND_FAILED", "WebSocket send failed: %s" % error_string(send_err)) return false _track_recoverable_message({ "content": normalized_content, "scope": scope, "extra_data": recoverable_extra_data }) # 记录发送时间 if not is_recovery_retry: _record_message_timestamp() var now_timestamp: float = Time.get_unix_time_from_system() if not suppress_local_echo: # 添加到历史 _add_message_to_history({ "from_user": _current_username, "content": normalized_content, "timestamp": now_timestamp, "is_self": true, "show_bubble": show_bubble, "scope": scope, "to_user_id": str(extra_data.get("targetUserId", "")), "to_username": str(extra_data.get("targetUsername", "")), "private_context": str(extra_data.get("privateContext", "")), "is_private": scope == "private" }) # 记录待去重的“自己消息”（如果服务端也回发 chat_render，则避免重复显示） _pending_self_messages.append({ "content": normalized_content, "scope": scope, "targetUserId": str(extra_data.get("targetUserId", "")), "privateContext": str(extra_data.get("privateContext", "")), "expires_at": now_timestamp + SELF_ECHO_DEDUPE_WINDOW }) # 本地回显：UI 目前只订阅 CHAT_MESSAGE_RECEIVED，所以这里也发一次 received chat_message_received.emit(_current_username, normalized_content, show_bubble, now_timestamp) _emit_event(EventNames.CHAT_MESSAGE_RECEIVED, { "from_user": _current_username, "content": normalized_content, "show_bubble": show_bubble, "timestamp": now_timestamp, "is_self": true, "scope": scope, "to_user_id": str(extra_data.get("targetUserId", "")), "to_username": str(extra_data.get("targetUsername", "")), "private_context": str(extra_data.get("privateContext", "")), "is_private": scope == "private" }) return true # 消息发送完成回调 func _on_chat_message_sent(_request_id: String, success: bool, data: Dictionary, error_info: Dictionary) -> void: if success: var message_id: String = str(data.get("data", {}).get("id", "")) var timestamp: float = Time.get_unix_time_from_system() chat_message_sent.emit(message_id, timestamp) _emit_event(EventNames.CHAT_MESSAGE_SENT, { "message_id": message_id, "timestamp": timestamp }) else: _handle_error("SEND_FAILED", error_info.get("message", "发送失败")) # 更新玩家位置 # # 参数: # x: float - X 坐标 # y: float - Y 坐标 # map_id: String - 地图 ID # # 使用示例: # ChatManager.update_player_position(150.0, 200.0, "novice_village") func update_player_position(x: float, y: float, map_id: String) -> void: update_player_position_with_appearance(x, y, map_id, {}) func update_player_position_with_appearance(x: float, y: float, map_id: String, _appearance: Dictionary = {}) -> void: if not _websocket_manager.is_websocket_connected(): connect_to_chat_server() return if not _is_logged_in: return var position_data := { "type": "position", "x": x, "y": y, "mapId": map_id } # 发送消息（JSON 字符串） var json_string := JSON.stringify(position_data) _websocket_manager.send_message(json_string) # ============================================================================ # 公共 API - 频率限制 # ============================================================================ # 检查是否可以发送消息 # # 返回值: # bool - 是否可以发送 func can_send_message() -> bool: var current_time := Time.get_unix_time_from_system() # 清理过期的时间戳 var filter_func := func(timestamp: float) -> bool: return current_time - timestamp < RATE_LIMIT_WINDOW _message_timestamps = _message_timestamps.filter(filter_func) # 检查数量 return _message_timestamps.size() < RATE_LIMIT_MESSAGES # 获取距离下次可发送消息的时间 # # 返回值: # float - 等待时间（秒） func get_time_until_next_message() -> float: if _message_timestamps.is_empty(): return 0.0 if _message_timestamps.size() < RATE_LIMIT_MESSAGES: return 0.0 # 找到最早的时间戳 var earliest_timestamp: float = _message_timestamps[0] var current_time := Time.get_unix_time_from_system() var elapsed := current_time - earliest_timestamp if elapsed >= RATE_LIMIT_WINDOW: return 0.0 return RATE_LIMIT_WINDOW - elapsed # ============================================================================ # 公共 API - 消息历史 # ============================================================================ # 获取消息历史 # # 返回值: # Array[Dictionary] - 消息历史数组 func get_message_history() -> Array[Dictionary]: return _message_history.duplicate() # 清空消息历史 func clear_message_history() -> void: _message_history.clear() # 重置当前会话（每次登录/重连时调用） # # 功能: # - 清空当前会话消息缓存 # - 重置历史消息加载状态 # - 不影响 Zulip 后端的历史消息 # # 使用场景: # - 用户登录成功后 # - 重新连接到聊天服务器后 func reset_session() -> void: _message_history.clear() _history_loading = false _has_more_history = true _oldest_message_timestamp = 0.0 # 加载历史消息（按需从 Zulip 后端获取） # # 参数: # count: int - 要加载的消息数量（默认 HISTORY_PAGE_SIZE） # # 功能: # - 从 Zulip 后端获取历史消息 # - 添加到当前会话历史开头 # - 触发 CHAT_MESSAGE_RECEIVED 事件显示消息 # # 使用场景: # - 用户滚动到聊天窗口顶部 # - 用户主动点击"加载历史"按钮 # func load_history(count: int = HISTORY_PAGE_SIZE) -> void: if _history_loading: return if not _has_more_history: return _history_loading = true var token := _get_auth_manager_token() if token.is_empty(): _history_loading = false return var mapId := _current_map.strip_edges() if mapId.is_empty(): mapId = "whale_port" var url := "%s/chat/history?mapId=%s&limit=%d&offset=%d" % [ NetworkConfig.get_api_base_url(), mapId.uri_encode(), max(1, count), _message_history.size(), ] var err := _history_request.request(url, PackedStringArray([ "Accept: application/json", "Authorization: Bearer %s" % token, ]), HTTPClient.METHOD_GET) if err != OK: _history_loading = false _handle_error("INTERNAL_ERROR", "聊天历史请求发送失败") func _on_history_request_completed(result: int, responseCode: int, _headers: PackedStringArray, body: PackedByteArray) -> void: if result != HTTPRequest.RESULT_SUCCESS or responseCode < 200 or responseCode >= 300: _history_loading = false _handle_error("INTERNAL_ERROR", "聊天历史读取失败") return var json := JSON.new() if json.parse(body.get_string_from_utf8()) != OK or not (json.data is Dictionary): _history_loading = false _handle_error("INTERNAL_ERROR", "聊天历史响应解析失败") return var response: Dictionary = json.data var messagesVariant: Variant = response.get("messages", []) var dataVariant: Variant = response.get("data", {}) if messagesVariant is Array and (messagesVariant as Array).is_empty() and dataVariant is Dictionary: messagesVariant = (dataVariant as Dictionary).get("messages", []) if messagesVariant is Array: _on_history_loaded(_normalize_history_messages(messagesVariant as Array)) return _history_loading = false _has_more_history = false func _normalize_history_messages(messages: Array) -> Array: var normalized: Array = [] for messageVariant in messages: if not (messageVariant is Dictionary): continue var message: Dictionary = messageVariant normalized.append({ "from_user": str(message.get("sender", message.get("from_user", ""))), "from_user_id": str(message.get("fromUserId", message.get("from_user_id", ""))), "content": str(message.get("content", "")), "timestamp": _parse_chat_timestamp_to_unix(message.get("timestamp", 0.0)), "is_self": str(message.get("sender", "")) == _current_username, "scope": str(message.get("scope", "local")), "show_bubble": bool(message.get("bubble", false)), "is_history": true, }) return normalized # 历史消息加载完成回调 func _on_history_loaded(messages: Array) -> void: _history_loading = false if messages.is_empty(): _has_more_history = false return # 将历史消息插入到当前会话历史开头 for i in range(messages.size() - 1, -1, -1): var message: Dictionary = messages[i] _message_history.push_front(message) # 触发事件显示消息（Signal Up） _emit_event(EventNames.CHAT_MESSAGE_RECEIVED, { "from_user": message.get("from_user", ""), "content": message.get("content", ""), "show_bubble": false, "timestamp": message.get("timestamp", 0.0), "is_self": (not _current_username.is_empty() and message.get("from_user", "") == _current_username), "is_history": true # 标记为历史消息 }) # 更新最旧消息时间戳 var oldest: Dictionary = messages.back() if oldest.has("timestamp"): _oldest_message_timestamp = oldest.timestamp # 检查是否还有更多历史 if messages.size() < HISTORY_PAGE_SIZE: _has_more_history = false # ============================================================================ # 内部方法 - 信号连接 # ============================================================================ # 连接信号 func _connect_signals() -> void: # WebSocket 管理器信号 _websocket_manager.connection_state_changed.connect(_on_connection_state_changed) _websocket_manager.data_received.connect(_on_data_received) _websocket_manager.connection_lost.connect(_on_connection_lost) func _on_connection_lost() -> void: _is_logged_in = false _world_ready_map = "" _restore_recoverable_messages_to_queue() func _load_token_from_environment() -> void: var env_token: String = OS.get_environment(GAME_TOKEN_ENV_KEY).strip_edges() if not env_token.is_empty(): _game_token = env_token func _is_headless_run() -> bool: if OS.has_feature("headless"): return true return DisplayServer.get_name() == "headless" func _get_auth_manager_token() -> String: var authManager := get_node_or_null("/root/AuthManager") if authManager == null or not authManager.has_method("get_access_token"): return "" return str(authManager.call("get_access_token")).strip_edges() func _queue_message_until_ready(content: String, scope: String, extra_data: Dictionary = {}) -> bool: if _queued_messages.size() >= MAX_QUEUED_MESSAGES: _handle_error("RATE_LIMIT", "聊天正在连接，请稍后再试") return false _queued_messages.append({ "content": content, "scope": scope, "extra_data": extra_data.duplicate(true) }) return true func _track_recoverable_message(message: Dictionary) -> void: _recoverable_messages.append(message.duplicate(true)) if _recoverable_messages.size() > MAX_RECOVERABLE_MESSAGES: _recoverable_messages.pop_front() func _restore_recoverable_messages_to_queue() -> void: if _recoverable_messages.is_empty(): return var messages := _recoverable_messages.duplicate(true) _recoverable_messages.clear() for message_variant in messages: if not (message_variant is Dictionary): continue if _queued_messages.size() >= MAX_QUEUED_MESSAGES: break var message: Dictionary = message_variant var extra_data: Dictionary = {} var extra_variant: Variant = message.get("extra_data", {}) if extra_variant is Dictionary: extra_data = (extra_variant as Dictionary).duplicate(true) extra_data["_suppressLocalEcho"] = true extra_data["_isRecoveryRetry"] = true _queued_messages.append({ "content": str(message.get("content", "")), "scope": str(message.get("scope", "local")), "extra_data": extra_data }) func _flush_queued_messages() -> void: if _queued_messages.is_empty(): return var queued_messages := _queued_messages.duplicate() _queued_messages.clear() for queued_message in queued_messages: var queued_content: String = str(queued_message.get("content", "")) var queued_scope: String = str(queued_message.get("scope", "local")) var queued_extra_data: Dictionary = {} var extra_variant: Variant = queued_message.get("extra_data", {}) if extra_variant is Dictionary: queued_extra_data = extra_variant _send_chat_payload(queued_content, queued_scope, queued_extra_data) func _http_request_result_to_string(result: int) -> String: match result: HTTPRequest.RESULT_SUCCESS: return "SUCCESS" HTTPRequest.RESULT_CHUNKED_BODY_SIZE_MISMATCH: return "CHUNKED_BODY_SIZE_MISMATCH" HTTPRequest.RESULT_CANT_CONNECT: return "CANT_CONNECT" HTTPRequest.RESULT_CANT_RESOLVE: return "CANT_RESOLVE" HTTPRequest.RESULT_CONNECTION_ERROR: return "CONNECTION_ERROR" HTTPRequest.RESULT_TLS_HANDSHAKE_ERROR: return "TLS_HANDSHAKE_ERROR" HTTPRequest.RESULT_NO_RESPONSE: return "NO_RESPONSE" HTTPRequest.RESULT_BODY_SIZE_LIMIT_EXCEEDED: return "BODY_SIZE_LIMIT_EXCEEDED" HTTPRequest.RESULT_BODY_DECOMPRESS_FAILED: return "BODY_DECOMPRESS_FAILED" HTTPRequest.RESULT_REQUEST_FAILED: return "REQUEST_FAILED" HTTPRequest.RESULT_DOWNLOAD_FILE_CANT_OPEN: return "DOWNLOAD_FILE_CANT_OPEN" HTTPRequest.RESULT_DOWNLOAD_FILE_WRITE_ERROR: return "DOWNLOAD_FILE_WRITE_ERROR" HTTPRequest.RESULT_REDIRECT_LIMIT_REACHED: return "REDIRECT_LIMIT_REACHED" HTTPRequest.RESULT_TIMEOUT: return "TIMEOUT" _: return "UNKNOWN_%d" % result func _preview_text(text: String) -> String: var preview := text.strip_edges() if preview.length() > 180: return preview.substr(0, 180) + "..." return preview # 发送登录消息 func _send_login_message() -> void: if _game_token.strip_edges().is_empty(): _handle_error("AUTH_FAILED", "缺少聊天认证 token") return var login_data := { "type": "login", "token": _game_token } var json_string := JSON.stringify(login_data) _websocket_manager.send_message(json_string) # 连接状态变化 func _on_connection_state_changed(state: int) -> void: # 发射信号 chat_connection_state_changed.emit(state) # 通过 EventSystem 广播（Signal Up） _emit_event(EventNames.CHAT_CONNECTION_STATE_CHANGED, { "state": state }) # 如果连接成功，发送登录消息 if state == 2: # CONNECTED _send_login_message() # ============================================================================ # 内部方法 - 消息处理 # ============================================================================ # WebSocket 数据接收 func _on_data_received(message: String) -> void: # 解析 JSON 消息 var json := JSON.new() var parse_result := json.parse(message) if parse_result != OK: push_error("ChatManager: JSON 解析失败") return var data_variant: Variant = json.data if not (data_variant is Dictionary): push_warning("ChatManager: 收到非对象消息，已忽略") return var data: Dictionary = data_variant # 兼容不同后端字段命名：t / type var message_type: String = str(data.get("t", data.get("type", ""))).strip_edges() if message_type.is_empty(): _warn_empty_message_type_limited(data) return match message_type: "connected": pass "login_success": _handle_login_success(data) "login_error": _handle_login_error(data) "chat": _handle_chat_render(data) "chat_sent": _handle_chat_sent(data) "chat_error": _handle_chat_error(data) "chat_render": _handle_chat_render(data) "friend_list": _handle_friend_list(data) "friend_added": _handle_friend_added(data) "friend_request_received": _handle_friend_request_received(data) "friend_request_sent": _handle_friend_request_sent(data) "friend_request_accepted": _handle_friend_request_accepted(data) "friend_request_rejected": _handle_friend_request_rejected(data) "friend_removed": _handle_friend_removed(data) "friend_error": _handle_friend_error(data) "map_players_snapshot": _handle_map_players_snapshot(data) "system_presence": _handle_system_presence(data) "position_update": _handle_position_update(data) "player_joined": _handle_player_joined(data) "appearance_changed": _handle_player_joined(data) "world_ready_success": pass "world_left": _world_ready_map = "" "player_left": _handle_player_left(data) "position_updated": _handle_position_updated(data) "error": _handle_error_response(data) _: push_warning("ChatManager: 未处理的消息类型 %s" % message_type) func _warn_empty_message_type_limited(data: Dictionary) -> void: var now: float = Time.get_unix_time_from_system() if now - _last_empty_message_type_warning_at < EMPTY_MESSAGE_TYPE_WARNING_INTERVAL: return _last_empty_message_type_warning_at = now var payload_preview: String = JSON.stringify(data) if payload_preview.length() > 180: payload_preview = payload_preview.substr(0, 180) + "..." push_warning("ChatManager: 收到未带消息类型的消息，已忽略 payload=%s" % payload_preview) # 处理登录成功 func _handle_login_success(data: Dictionary) -> void: _is_logged_in = true _refreshing_auth_session = false _chat_login_refresh_attempted = false _friend_protocol_supported = true _current_username = data.get("username", "") _current_map = data.get("currentMap", "") _world_ready_map = "" # 重置当前会话缓存（每次登录/重连都清空，重新开始接收消息） reset_session() # 通过 EventSystem 广播（Signal Up） _emit_event(EventNames.CHAT_LOGIN_SUCCESS, { "username": _current_username, "current_map": _current_map }) _flush_queued_messages() request_friend_list() func _handle_system_presence(data: Dictionary) -> void: var content := str(data.get("content", "")).strip_edges() if content.is_empty(): return var timestamp := _parse_chat_timestamp_to_unix(data.get("timestamp", 0.0)) var message := { "from_user": "系统", "from_user_id": "", "content": content, "timestamp": timestamp, "is_self": false, "scope": "global", "show_bubble": false, "system_presence": true, } _add_message_to_history(message) chat_message_received.emit("系统", content, false, timestamp) _emit_event(EventNames.CHAT_MESSAGE_RECEIVED, message) func _on_account_profile_updated(_profile: Dictionary) -> void: notify_appearance_changed() func _on_auth_state_changed(isAuthenticated: bool, _user: Dictionary) -> void: if not isAuthenticated: _refreshing_auth_session = false _game_token = "" disconnect_from_chat_server() return var refreshedToken := _get_auth_manager_token() if refreshedToken.is_empty(): return _game_token = refreshedToken if not _refreshing_auth_session: return _refreshing_auth_session = false if _websocket_manager.is_websocket_connected(): _send_login_message() else: connect_to_chat_server() # 处理登录失败 func _handle_login_error(data: Dictionary) -> void: var error_message: String = data.get("message", "登录失败") _is_logged_in = false if _request_auth_session_refresh(): return _queued_messages.clear() # 通过 EventSystem 广播错误（Signal Up） _emit_event(EventNames.CHAT_LOGIN_FAILED, { "error_code": "LOGIN_FAILED", "message": error_message }) # 处理聊天消息发送成功 func _handle_chat_sent(data: Dictionary) -> void: var message_id: String = str(data.get("messageId", "")) var timestamp: float = data.get("timestamp", 0.0) # 发射信号 chat_message_sent.emit(message_id, timestamp) # 通过 EventSystem 广播（Signal Up） _emit_event(EventNames.CHAT_MESSAGE_SENT, { "message_id": message_id, "timestamp": timestamp }) if not _recoverable_messages.is_empty(): _recoverable_messages.pop_front() # 处理聊天消息发送失败 func _handle_chat_error(data: Dictionary) -> void: var error_message: String = data.get("message", "消息发送失败") var error_code: String = str(data.get("code", data.get("error_code", "CHAT_SEND_FAILED"))).strip_edges() if error_code == "SESSION_EXPIRED": _handle_session_expired(error_message) return # 通过 EventSystem 广播错误（Signal Up） _emit_event(EventNames.CHAT_ERROR_OCCURRED, { "error_code": error_code if not error_code.is_empty() else "CHAT_SEND_FAILED", "message": error_message }) func _handle_friend_list(data: Dictionary) -> void: _friends.clear() var friends_variant: Variant = data.get("friends", []) if friends_variant is Array: for friend_variant in friends_variant: if friend_variant is Dictionary: var friend: Dictionary = friend_variant _friends.append({ "user_id": str(friend.get("userId", friend.get("user_id", ""))).strip_edges(), "username": str(friend.get("username", "")), "online": bool(friend.get("online", false)) }) _emit_event(EventNames.CHAT_FRIENDS_UPDATED, { "friends": _friends.duplicate(true), "requests": _normalize_friend_requests(data.get("requests", [])), "supported": true, "status": "" }) func _handle_friend_added(data: Dictionary) -> void: var friend_variant: Variant = data.get("friend", {}) if friend_variant is Dictionary: var friend: Dictionary = friend_variant var friend_user_id := str(friend.get("userId", friend.get("user_id", ""))).strip_edges() if not friend_user_id.is_empty(): _upsert_friend({ "user_id": friend_user_id, "username": str(friend.get("username", "")), "online": bool(friend.get("online", false)) }) request_friend_list() func _handle_friend_request_received(data: Dictionary) -> void: _emit_event(EventNames.CHAT_FRIENDS_UPDATED, { "friends": _friends.duplicate(true), "requests": _normalize_friend_requests([data.get("request", {})]) }) request_friend_list() func _handle_friend_request_sent(_data: Dictionary) -> void: _emit_event(EventNames.CHAT_ERROR_OCCURRED, { "error_code": "FRIEND_REQUEST_SENT", "message": "好友请求已发送" }) func _handle_friend_request_accepted(_data: Dictionary) -> void: request_friend_list() func _handle_friend_request_rejected(data: Dictionary) -> void: var username := str(data.get("username", "")).strip_edges() var message := "好友请求已被拒绝" if not username.is_empty(): message = "%s 拒绝了好友请求" % username _emit_event(EventNames.CHAT_ERROR_OCCURRED, { "error_code": "FRIEND_REQUEST_REJECTED", "message": message }) func _handle_friend_removed(data: Dictionary) -> void: var friend_user_id := str(data.get("friendUserId", data.get("friend_user_id", ""))).strip_edges() if friend_user_id.is_empty(): return for i in range(_friends.size() - 1, -1, -1): if str(_friends[i].get("user_id", "")) == friend_user_id: _friends.remove_at(i) _emit_event(EventNames.CHAT_FRIENDS_UPDATED, { "friends": _friends.duplicate(true), "requests": _normalize_friend_requests(data.get("requests", [])), "supported": true, "status": "" }) func _handle_friend_error(data: Dictionary) -> void: var error_code := str(data.get("code", data.get("error_code", "FRIEND_ERROR"))).strip_edges() var error_message := str(data.get("message", "好友操作失败")) if error_code == "SESSION_EXPIRED": _handle_session_expired(error_message) return _handle_error(error_code if not error_code.is_empty() else "FRIEND_ERROR", error_message) func _upsert_friend(friend: Dictionary) -> void: var friend_user_id := str(friend.get("user_id", "")).strip_edges() if friend_user_id.is_empty(): return for i in range(_friends.size()): if str(_friends[i].get("user_id", "")) == friend_user_id: _friends[i] = friend _emit_event(EventNames.CHAT_FRIENDS_UPDATED, { "friends": _friends.duplicate(true), "requests": [] }) return _friends.append(friend) _emit_event(EventNames.CHAT_FRIENDS_UPDATED, { "friends": _friends.duplicate(true), "requests": [] }) # 处理接收到的聊天消息 func _handle_chat_render(data: Dictionary) -> void: # 兼容不同后端字段命名： # - chat_render: {from, txt, bubble, timestamp} # - chat: {content, scope, (可选 from/username/timestamp)} var from_user: String = data.get("from", data.get("from_user", data.get("username", ""))) var content: String = data.get("txt", data.get("content", "")) var show_bubble: bool = bool(data.get("bubble", data.get("show_bubble", false))) var scope: String = str(data.get("scope", "local")).strip_edges().to_lower() if scope.is_empty(): scope = "local" var from_user_id: String = str(data.get("fromUserId", data.get("from_user_id", data.get("userId", data.get("user_id", ""))))).strip_edges() var to_user_id: String = str(data.get("toUserId", data.get("to_user_id", data.get("targetUserId", data.get("target_user_id", ""))))).strip_edges() var to_username: String = str(data.get("toUsername", data.get("to_username", data.get("targetUsername", data.get("target_username", ""))))).strip_edges() var private_context: String = str(data.get("privateContext", data.get("private_context", ""))).strip_edges() var is_private: bool = scope == "private" var timestamp: float = _parse_chat_timestamp_to_unix(data.get("timestamp", 0.0)) var is_self: bool = (not _current_username.is_empty() and from_user == _current_username) if is_self and _consume_pending_self_message(content, scope, to_user_id): # 已经本地回显过，避免重复显示 return # 如果服务端没带发送者信息，但内容匹配最近自己发送的消息，则认为是自己消息 if from_user.is_empty() and _consume_pending_self_message(content, scope, to_user_id): from_user = _current_username is_self = true # 添加到历史 _add_message_to_history({ "from_user": from_user, "from_user_id": from_user_id, "content": content, "timestamp": timestamp, "is_self": is_self, "scope": scope, "to_user_id": to_user_id, "to_username": to_username, "private_context": private_context, "is_private": is_private }) # 发射信号 chat_message_received.emit(from_user, content, show_bubble, timestamp) # 通过 EventSystem 广播（Signal Up） _emit_event(EventNames.CHAT_MESSAGE_RECEIVED, { "from_user": from_user, "from_user_id": from_user_id, "content": content, "show_bubble": show_bubble, "timestamp": timestamp, "is_self": is_self, "scope": scope, "to_user_id": to_user_id, "to_username": to_username, "private_context": private_context, "is_private": is_private }) # 解析聊天消息时间戳（兼容 unix 秒 / ISO 8601 字符串） func _parse_chat_timestamp_to_unix(timestamp_raw: Variant) -> float: if typeof(timestamp_raw) == TYPE_INT or typeof(timestamp_raw) == TYPE_FLOAT: var ts := float(timestamp_raw) return ts if ts > 0.0 else Time.get_unix_time_from_system() var ts_str := str(timestamp_raw) if ts_str.strip_edges().is_empty(): return Time.get_unix_time_from_system() # 纯数字字符串（必须整串都是数字/小数点，避免把 ISO 字符串前缀 "2026" 误判成时间戳） var numeric_regex := RegEx.new() numeric_regex.compile("^\\s*-?\\d+(?:\\.\\d+)?\\s*$") if numeric_regex.search(ts_str) != null: var ts_num := float(ts_str) return ts_num if ts_num > 0.0 else Time.get_unix_time_from_system() # ISO 8601: 2026-01-19T15:15:43.930Z var regex := RegEx.new() regex.compile("(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})") var result := regex.search(ts_str) if result == null: return Time.get_unix_time_from_system() var utc_dict := { "year": int(result.get_string(1)), "month": int(result.get_string(2)), "day": int(result.get_string(3)), "hour": int(result.get_string(4)), "minute": int(result.get_string(5)), "second": int(result.get_string(6)) } return Time.get_unix_time_from_datetime_dict(utc_dict) # 处理位置更新成功 func _handle_position_updated(data: Dictionary) -> void: var stream: String = data.get("stream", "") var topic: String = data.get("topic", "") # 发射信号 chat_position_updated.emit(stream, topic) # 通过 EventSystem 广播（Signal Up） _emit_event(EventNames.CHAT_POSITION_UPDATED, { "stream": stream, "topic": topic }) func _handle_position_update(data: Dictionary) -> void: var user_id := str(data.get("userId", data.get("user_id", ""))).strip_edges() if user_id.is_empty(): return var appearance := _normalize_player_appearance(data) _emit_event(EventNames.REMOTE_PLAYER_POSITION_UPDATED, { "userId": user_id, "username": str(data.get("username", "")), "position": Vector2(float(data.get("x", 0.0)), float(data.get("y", 0.0))), "mapId": str(data.get("mapId", data.get("map_id", ""))), "skin_id": str(appearance.get("skin_id", "")), "avatar_id": str(appearance.get("avatar_id", "")), "skin_asset": appearance.get("skin_asset", {}), "cafe_companion": _normalize_cafe_companion(data.get("cafeCompanion", data.get("cafe_companion", null))), "movement_locked": bool(data.get("movementLocked", data.get("movement_locked", false))) }) func _handle_map_players_snapshot(data: Dictionary) -> void: var players: Array[Dictionary] = [] var players_variant: Variant = data.get("players", []) if players_variant is Array: for player_variant in players_variant: if not (player_variant is Dictionary): continue var player: Dictionary = player_variant var user_id := str(player.get("userId", player.get("user_id", ""))).strip_edges() if user_id.is_empty(): continue var appearance := _normalize_player_appearance(player) players.append({ "userId": user_id, "username": str(player.get("username", "")), "position": Vector2(float(player.get("x", 0.0)), float(player.get("y", 0.0))), "mapId": str(player.get("mapId", player.get("map_id", data.get("mapId", data.get("map_id", ""))))), "skin_id": str(appearance.get("skin_id", "")), "avatar_id": str(appearance.get("avatar_id", "")), "skin_asset": appearance.get("skin_asset", {}), "cafe_companion": _normalize_cafe_companion(player.get("cafeCompanion", player.get("cafe_companion", null))), "movement_locked": bool(player.get("movementLocked", player.get("movement_locked", false))) }) _emit_event(EventNames.REMOTE_PLAYERS_SNAPSHOT_READY, { "mapId": str(data.get("mapId", data.get("map_id", ""))), "players": players }) func _handle_player_joined(data: Dictionary) -> void: var user_id := str(data.get("userId", data.get("user_id", ""))).strip_edges() if user_id.is_empty(): return var appearance := _normalize_player_appearance(data) _emit_event(EventNames.REMOTE_PLAYER_JOINED, { "userId": user_id, "username": str(data.get("username", "")), "position": Vector2(float(data.get("x", 0.0)), float(data.get("y", 0.0))), "mapId": str(data.get("mapId", data.get("map_id", ""))), "skin_id": str(appearance.get("skin_id", "")), "avatar_id": str(appearance.get("avatar_id", "")), "skin_asset": appearance.get("skin_asset", {}), "cafe_companion": _normalize_cafe_companion(data.get("cafeCompanion", data.get("cafe_companion", null))), "movement_locked": bool(data.get("movementLocked", data.get("movement_locked", false))) }) func _normalize_player_appearance(data: Dictionary) -> Dictionary: var appearanceVariant: Variant = data.get("appearance", {}) var appearance: Dictionary = appearanceVariant if appearanceVariant is Dictionary else {} return { "skin_id": str(data.get("skinId", data.get("skin_id", appearance.get("skinId", appearance.get("skin_id", ""))))), "avatar_id": str(data.get("avatarId", data.get("avatar_id", appearance.get("avatarId", appearance.get("avatar_id", ""))))), "skin_asset": data.get("skinAsset", data.get("skin_asset", appearance.get("skinAsset", appearance.get("skin_asset", {})))), } func _normalize_cafe_companion(value: Variant) -> Dictionary: if not (value is Dictionary): return {} var raw: Dictionary = value var servicePointId := str(raw.get("servicePointId", raw.get("service_point_id", ""))).strip_edges() var companionId := str(raw.get("companionId", raw.get("companion_id", ""))).strip_edges() var personaName := str(raw.get("personaName", raw.get("persona_name", ""))).strip_edges() if servicePointId.is_empty() or companionId.is_empty() or personaName.is_empty(): return {} return { "cafe_id": str(raw.get("cafeId", raw.get("cafe_id", "whale_cafe"))).strip_edges(), "service_point_id": servicePointId, "companion_id": companionId, "companion_type": str(raw.get("companionType", raw.get("companion_type", "hired_player"))).strip_edges(), "persona_name": personaName, "employment_ends_at": str(raw.get("employmentEndsAt", raw.get("employment_ends_at", ""))).strip_edges(), "owner_user_id": str(raw.get("ownerUserId", raw.get("owner_user_id", ""))).strip_edges(), } func _handle_player_left(data: Dictionary) -> void: var user_id := str(data.get("userId", data.get("user_id", ""))).strip_edges() if user_id.is_empty(): return _emit_event(EventNames.REMOTE_PLAYER_LEFT, { "userId": user_id, "username": str(data.get("username", "")), "mapId": str(data.get("mapId", data.get("map_id", ""))) }) # 处理错误响应（如果需要） func _handle_error_response(data: Dictionary) -> void: var error_code: String = str(data.get("code", "")) var error_message: String = str(data.get("message", "")) var unknown_message_type := _extract_unknown_message_type(error_message) if _is_friend_protocol_message_type(unknown_message_type): _handle_friend_protocol_unsupported(unknown_message_type) return if error_code == "SESSION_EXPIRED": _handle_session_expired(error_message) return _handle_error(error_code, error_message) func _handle_session_expired(error_message: String = "") -> void: push_warning("ChatManager: [SESSION_EXPIRED] %s" % error_message) _is_logged_in = false _restore_recoverable_messages_to_queue() _chat_login_refresh_attempted = false if _request_auth_session_refresh(): return _game_token = _get_auth_manager_token() if _game_token.is_empty(): _handle_error("AUTH_FAILED", "请先登录后再使用聊天") return if _websocket_manager.is_websocket_connected(): _send_login_message() else: connect_to_chat_server() func _request_auth_session_refresh() -> bool: if _refreshing_auth_session or _chat_login_refresh_attempted: return false var authManager := get_node_or_null("/root/AuthManager") if authManager == null or not authManager.has_method("refresh_session") or not authManager.has_method("get_refresh_token"): return false if str(authManager.call("get_refresh_token")).strip_edges().is_empty(): return false _chat_login_refresh_attempted = true _refreshing_auth_session = true authManager.call("refresh_session") return true # 处理 Socket 错误（如果需要） func _on_socket_error(error: String) -> void: _handle_error("SOCKET_ERROR", error) func _normalize_friend_requests(requests_variant: Variant) -> Array[Dictionary]: var requests: Array[Dictionary] = [] if not (requests_variant is Array): return requests for request_variant in requests_variant: if not (request_variant is Dictionary): continue var request: Dictionary = request_variant var user_id := str(request.get("userId", request.get("user_id", ""))).strip_edges() if user_id.is_empty(): continue requests.append({ "user_id": user_id, "username": str(request.get("username", "玩家")).strip_edges(), "created_at": str(request.get("createdAt", request.get("created_at", ""))).strip_edges() }) return requests func _extract_unknown_message_type(error_message: String) -> String: var normalized_message := error_message.strip_edges() for marker in ["未知消息类型:", "未知消息类型：", "Unknown message type:", "Unknown message type："]: var index := normalized_message.find(marker) if index >= 0: return normalized_message.substr(index + marker.length()).strip_edges() return "" func _is_friend_protocol_message_type(message_type: String) -> bool: match message_type.strip_edges(): "friend_list", "friend_add", "friend_remove", "friend_request", "friend_accept", "friend_reject": return true _: return false func _handle_friend_protocol_unsupported(message_type: String) -> void: _friend_protocol_supported = false push_warning("ChatManager: 当前聊天后端暂不支持好友协议: %s" % message_type) _emit_friend_protocol_status("当前聊天后端暂不支持好友功能") func _emit_friend_protocol_status(status_message: String) -> void: _emit_event(EventNames.CHAT_FRIENDS_UPDATED, { "friends": _friends.duplicate(true), "requests": [], "supported": false, "status": status_message }) # ============================================================================ # 内部方法 - 工具函数 # ============================================================================ # 处理错误 func _handle_error(error_code: String, error_message: String) -> void: if error_code == "NOT_CONNECTED" or error_code == "NOT_LOGGED_IN": push_warning("ChatManager: [%s] %s" % [error_code, error_message]) else: push_error("ChatManager: [%s] %s" % [error_code, error_message]) # 获取用户友好的错误消息 var user_message: String = CHAT_ERROR_MESSAGES.get(error_code, error_message) as String # 发射信号 chat_error_occurred.emit(error_code, user_message) # 通过 EventSystem 广播（Signal Up） _emit_event(EventNames.CHAT_ERROR_OCCURRED, { "error_code": error_code, "message": user_message }) # 特殊处理认证失败 if error_code == "AUTH_FAILED" or error_code == "SESSION_EXPIRED": _is_logged_in = false _emit_event(EventNames.CHAT_LOGIN_FAILED, { "error_code": error_code }) # 记录消息发送时间戳 func _record_message_timestamp() -> void: var current_time := Time.get_unix_time_from_system() _message_timestamps.append(current_time) # 消费一个待去重的“自己消息”（允许相同内容多次发送：每次消费一个） func _consume_pending_self_message(content: String, scope: String = "", target_user_id: String = "") -> bool: var now := Time.get_unix_time_from_system() # 先清理过期项 for i in range(_pending_self_messages.size() - 1, -1, -1): var item: Dictionary = _pending_self_messages[i] if float(item.get("expires_at", 0.0)) < now: _pending_self_messages.remove_at(i) # 再匹配内容 for i in range(_pending_self_messages.size() - 1, -1, -1): var item: Dictionary = _pending_self_messages[i] var same_content := str(item.get("content", "")) == content var same_scope := scope.is_empty() or str(item.get("scope", "")).is_empty() or str(item.get("scope", "")) == scope var same_target := target_user_id.is_empty() or str(item.get("targetUserId", "")) == target_user_id if same_content and same_scope and same_target: _pending_self_messages.remove_at(i) return true return false # 添加消息到当前会话历史 func _add_message_to_history(message: Dictionary) -> void: _message_history.append(message) # 更新最旧消息时间戳（用于历史消息加载） if _oldest_message_timestamp == 0.0 or message.timestamp < _oldest_message_timestamp: _oldest_message_timestamp = message.timestamp # 限制当前会话消息数量（超过后删除最旧的） if _message_history.size() > MAX_SESSION_MESSAGES: _message_history.pop_front() func _settings_bool(key: String, defaultValue: bool) -> bool: var settingsManager := get_node_or_null("/root/SettingsManager") if settingsManager != null and settingsManager.has_method("get_bool"): return bool(settingsManager.call("get_bool", key)) return defaultValue