forked from xiangwang25/whale-town-front-v2
215 lines
8.5 KiB
GDScript
215 lines
8.5 KiB
GDScript
extends Node
|
|
|
|
# ============================================================================
|
|
# CafeCompanionManager.gd - 咖啡店陪伴机器人网络管理器
|
|
# ============================================================================
|
|
# 负责咖啡店陪伴机器人服务点、付费聊天时长和 Agent
|
|
# 聊天代理的前端协议。客户端不保存模型 URL/token。
|
|
# ============================================================================
|
|
|
|
signal cafe_companion_products_ready(data: Dictionary)
|
|
signal cafe_companion_service_points_ready(data: Dictionary)
|
|
signal cafe_companion_chat_time_purchased(data: Dictionary)
|
|
signal cafe_companion_message_received(message: Dictionary)
|
|
signal cafe_companion_error_occurred(message: String)
|
|
signal cafe_companion_agent_registered(data: Dictionary)
|
|
signal cafe_companion_employment_resigned(data: Dictionary)
|
|
signal cafe_companion_models_ready(data: Dictionary)
|
|
|
|
const REQUEST_TIMEOUT: float = 24.0
|
|
|
|
var _cachedProducts: Array = []
|
|
var _cachedServicePoints: Array = []
|
|
var _accountGeneration: int = -1
|
|
|
|
func _ready() -> void:
|
|
_accountGeneration = _current_account_generation()
|
|
var authManager := get_node_or_null("/root/AuthManager")
|
|
if authManager != null and authManager.has_signal("auth_state_changed"):
|
|
authManager.auth_state_changed.connect(_on_auth_state_changed)
|
|
|
|
func get_chat_time_products(forceRefresh: bool = false) -> void:
|
|
if not forceRefresh and not _cachedProducts.is_empty():
|
|
var cachedData := {"products": _cachedProducts}
|
|
cafe_companion_products_ready.emit(cachedData)
|
|
_emit_event(EventNames.CAFE_COMPANION_PRODUCTS_READY, cachedData)
|
|
return
|
|
if not _has_auth_token():
|
|
_emit_chat_error("请先登录后再查看咖啡店陪聊时长")
|
|
return
|
|
|
|
_request_json("/cafe-companion/chat-time-products", {}, _on_chat_time_products_response, HTTPClient.METHOD_GET)
|
|
|
|
func get_service_points(forceRefresh: bool = false) -> void:
|
|
if not forceRefresh and not _cachedServicePoints.is_empty():
|
|
var cachedData := {"service_points": _cachedServicePoints}
|
|
cafe_companion_service_points_ready.emit(cachedData)
|
|
_emit_event(EventNames.CAFE_COMPANION_SERVICE_POINTS_READY, cachedData)
|
|
return
|
|
if not _has_auth_token():
|
|
_emit_chat_error("请先登录后再查看咖啡店陪伴位")
|
|
return
|
|
|
|
_request_json("/cafe-companion/service-points", {}, _on_service_points_response, HTTPClient.METHOD_GET)
|
|
|
|
func purchase_chat_time(targetData: Dictionary, minutes: int) -> void:
|
|
if not _has_auth_token():
|
|
_emit_chat_error("请先登录后再购买咖啡店陪聊时长")
|
|
return
|
|
|
|
var payload := {
|
|
"service_point_id": str(targetData.get("service_point_id", "")),
|
|
"minutes": minutes,
|
|
}
|
|
var companionId := str(targetData.get("companion_id", "")).strip_edges()
|
|
if not companionId.is_empty():
|
|
payload["companion_id"] = companionId
|
|
|
|
_request_json("/cafe-companion/chat-time/purchase", payload, _on_purchase_chat_time_response)
|
|
|
|
func send_chat_message(sessionId: String, content: String) -> void:
|
|
var normalizedContent := content.strip_edges()
|
|
if sessionId.strip_edges().is_empty():
|
|
_emit_chat_error("咖啡店陪聊会话还没有准备好")
|
|
return
|
|
if normalizedContent.is_empty():
|
|
return
|
|
if not _has_auth_token():
|
|
_emit_chat_error("请先登录后再发送咖啡店陪聊消息")
|
|
return
|
|
|
|
_request_json("/cafe-companion/chat/messages", {
|
|
"session_id": sessionId,
|
|
"content": normalizedContent,
|
|
}, _on_send_chat_message_response)
|
|
|
|
func register_employment_agent(payload: Dictionary) -> void:
|
|
if not _has_auth_token():
|
|
_emit_chat_error("请先登录后再登记咖啡店陪伴机器人")
|
|
return
|
|
_request_json("/cafe-companion/employment/agents", payload, _on_register_employment_agent_response)
|
|
|
|
func resign_employment(servicePointId: String) -> void:
|
|
if not _has_auth_token():
|
|
_emit_chat_error("请先登录后再结束咖啡店雇佣")
|
|
return
|
|
_request_json("/cafe-companion/employment/resign", {
|
|
"service_point_id": servicePointId,
|
|
}, _on_resign_employment_response)
|
|
|
|
func get_employment_models(protocol: String, baseUrl: String, token: String) -> void:
|
|
if not _has_auth_token():
|
|
_emit_chat_error("请先登录后再获取咖啡店雇佣模型")
|
|
return
|
|
_request_json("/cafe-companion/employment/models", {
|
|
"protocol": protocol,
|
|
"base_url": baseUrl,
|
|
"token": token,
|
|
}, _on_employment_models_response)
|
|
|
|
func _request_json(endpoint: String, payload: Dictionary, callback: Callable, method: int = HTTPClient.METHOD_POST) -> void:
|
|
var request_generation := _current_account_generation()
|
|
ApiClient.request_json(endpoint, payload, func(success: bool, response: Dictionary, error_info: Dictionary) -> void:
|
|
if request_generation != _current_account_generation():
|
|
return
|
|
if not success:
|
|
_emit_chat_error(str(error_info.get("message", "咖啡店陪聊请求失败")))
|
|
return
|
|
callback.call(response)
|
|
, method, true, REQUEST_TIMEOUT)
|
|
|
|
func _on_chat_time_products_response(response: Dictionary) -> void:
|
|
var data := _response_data(response)
|
|
var productsVariant: Variant = data.get("products", [])
|
|
_cachedProducts = productsVariant if productsVariant is Array else []
|
|
cafe_companion_products_ready.emit(data)
|
|
_emit_event(EventNames.CAFE_COMPANION_PRODUCTS_READY, data)
|
|
|
|
func _on_service_points_response(response: Dictionary) -> void:
|
|
var data := _response_data(response)
|
|
var servicePointsVariant: Variant = data.get("service_points", [])
|
|
_cachedServicePoints = servicePointsVariant if servicePointsVariant is Array else []
|
|
cafe_companion_service_points_ready.emit(data)
|
|
_emit_event(EventNames.CAFE_COMPANION_SERVICE_POINTS_READY, data)
|
|
|
|
func _on_purchase_chat_time_response(response: Dictionary) -> void:
|
|
var data := _response_data(response)
|
|
_apply_wallet_from_payload(data)
|
|
cafe_companion_chat_time_purchased.emit(data)
|
|
_emit_event(EventNames.CAFE_COMPANION_CHAT_TIME_PURCHASED, data)
|
|
|
|
func _on_send_chat_message_response(response: Dictionary) -> void:
|
|
var data := _response_data(response)
|
|
cafe_companion_message_received.emit(data)
|
|
_emit_event(EventNames.CAFE_COMPANION_MESSAGE_RECEIVED, data)
|
|
|
|
func _on_register_employment_agent_response(response: Dictionary) -> void:
|
|
var data := _response_data(response)
|
|
cafe_companion_agent_registered.emit(data)
|
|
_cachedServicePoints.clear()
|
|
_emit_event(EventNames.CAFE_COMPANION_AGENT_REGISTERED, data)
|
|
|
|
func _on_resign_employment_response(response: Dictionary) -> void:
|
|
var data := _response_data(response)
|
|
var penaltyVariant: Variant = data.get("penalty", {})
|
|
if penaltyVariant is Dictionary:
|
|
_apply_wallet_from_payload(penaltyVariant as Dictionary)
|
|
cafe_companion_employment_resigned.emit(data)
|
|
_cachedServicePoints.clear()
|
|
_emit_event(EventNames.CAFE_COMPANION_EMPLOYMENT_RESIGNED, data)
|
|
|
|
func _on_employment_models_response(response: Dictionary) -> void:
|
|
var data := _response_data(response)
|
|
cafe_companion_models_ready.emit(data)
|
|
_emit_event(EventNames.CAFE_COMPANION_MODELS_READY, data)
|
|
|
|
func _response_data(response: Dictionary) -> Dictionary:
|
|
var dataVariant: Variant = response.get("data", {})
|
|
if dataVariant is Dictionary:
|
|
return dataVariant
|
|
return {}
|
|
|
|
func _apply_wallet_from_payload(data: Dictionary) -> void:
|
|
if not data.has("balance"):
|
|
return
|
|
var playerStateManager := get_node_or_null("/root/PlayerStateManager")
|
|
if playerStateManager != null and playerStateManager.has_method("apply_wallet"):
|
|
playerStateManager.call("apply_wallet", {
|
|
"balance": int(data.get("balance", 0)),
|
|
"currency": str(data.get("currency", "whale_coin")),
|
|
})
|
|
|
|
func _emit_chat_error(message: String) -> void:
|
|
cafe_companion_error_occurred.emit(message)
|
|
_emit_event(EventNames.CAFE_COMPANION_ERROR_OCCURRED, {
|
|
"message": message
|
|
})
|
|
|
|
func _emit_event(eventName: String, data: Dictionary) -> void:
|
|
var eventSystem := get_node_or_null("/root/EventSystem")
|
|
if eventSystem != null:
|
|
eventSystem.call("emit_event", eventName, data)
|
|
|
|
func _has_auth_token() -> bool:
|
|
return not _get_auth_token().is_empty()
|
|
|
|
func _get_auth_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 _current_account_generation() -> int:
|
|
var authManager := get_node_or_null("/root/AuthManager")
|
|
if authManager == null or not authManager.has_method("get_account_generation"):
|
|
return -1
|
|
return int(authManager.call("get_account_generation"))
|
|
|
|
func _on_auth_state_changed(_isAuthenticated: bool, _user: Dictionary) -> void:
|
|
var currentGeneration := _current_account_generation()
|
|
if currentGeneration == _accountGeneration:
|
|
return
|
|
_accountGeneration = currentGeneration
|
|
_cachedProducts.clear()
|
|
_cachedServicePoints.clear()
|