669 lines
20 KiB
GDScript
669 lines
20 KiB
GDScript
extends Node
|
||
class_name UserBehaviorAnalytics
|
||
## 用户行为分析系统
|
||
## 收集、分析和报告用户在游戏中的行为数据
|
||
|
||
# 行为事件类型枚举
|
||
enum EventType {
|
||
LOGIN, # 登录
|
||
LOGOUT, # 登出
|
||
CHARACTER_CREATED, # 角色创建
|
||
MOVEMENT, # 移动
|
||
DIALOGUE_STARTED, # 开始对话
|
||
DIALOGUE_ENDED, # 结束对话
|
||
MESSAGE_SENT, # 发送消息
|
||
FRIEND_REQUEST, # 好友请求
|
||
EVENT_JOINED, # 参加活动
|
||
INTERACTION, # 交互行为
|
||
UI_ACTION, # UI操作
|
||
ERROR_OCCURRED, # 错误发生
|
||
PERFORMANCE_METRIC # 性能指标
|
||
}
|
||
|
||
# 行为数据结构
|
||
class BehaviorEvent:
|
||
var event_id: String
|
||
var event_type: EventType
|
||
var user_id: String
|
||
var timestamp: float
|
||
var session_id: String
|
||
var data: Dictionary = {}
|
||
var context: Dictionary = {}
|
||
|
||
func _init(type: EventType, uid: String, sid: String, event_data: Dictionary = {}):
|
||
event_id = generate_event_id()
|
||
event_type = type
|
||
user_id = uid
|
||
session_id = sid
|
||
timestamp = Time.get_unix_time_from_system()
|
||
data = event_data.duplicate()
|
||
context = _get_context_data()
|
||
|
||
func generate_event_id() -> String:
|
||
return "evt_%d_%d" % [Time.get_unix_time_from_system(), randi()]
|
||
|
||
func _get_context_data() -> Dictionary:
|
||
return {
|
||
"platform": OS.get_name(),
|
||
"viewport_size": get_viewport().get_visible_rect().size if get_viewport() else Vector2.ZERO,
|
||
"fps": Engine.get_frames_per_second()
|
||
}
|
||
|
||
# 数据存储和管理
|
||
var behavior_events: Array[BehaviorEvent] = []
|
||
var current_session_id: String = ""
|
||
var current_user_id: String = "player"
|
||
var session_start_time: float = 0.0
|
||
var max_events_in_memory: int = 1000
|
||
var analytics_enabled: bool = true
|
||
|
||
# 数据持久化
|
||
var analytics_file_path: String = "user://user_analytics.json"
|
||
var session_file_path: String = "user://session_data.json"
|
||
|
||
# 统计数据缓存
|
||
var cached_statistics: Dictionary = {}
|
||
var statistics_cache_time: float = 0.0
|
||
var cache_duration: float = 300.0 # 5分钟缓存
|
||
|
||
# 信号
|
||
signal behavior_recorded(event_type: EventType, data: Dictionary)
|
||
signal session_started(session_id: String)
|
||
signal session_ended(session_id: String, duration: float)
|
||
signal analytics_report_generated(report: Dictionary)
|
||
|
||
func _ready():
|
||
"""初始化用户行为分析系统"""
|
||
_start_new_session()
|
||
_load_analytics_data()
|
||
|
||
# 设置定时保存
|
||
var save_timer = Timer.new()
|
||
save_timer.wait_time = 60.0 # 每分钟保存一次
|
||
save_timer.timeout.connect(_save_analytics_data)
|
||
save_timer.autostart = true
|
||
add_child(save_timer)
|
||
|
||
print("UserBehaviorAnalytics initialized")
|
||
|
||
## 开始新会话
|
||
func _start_new_session() -> void:
|
||
"""开始新的用户会话"""
|
||
current_session_id = _generate_session_id()
|
||
session_start_time = Time.get_unix_time_from_system()
|
||
|
||
# 记录会话开始事件
|
||
record_event(EventType.LOGIN, {"session_start": true})
|
||
|
||
session_started.emit(current_session_id)
|
||
print("New session started: ", current_session_id)
|
||
|
||
## 结束当前会话
|
||
func end_current_session() -> void:
|
||
"""结束当前用户会话"""
|
||
if current_session_id.is_empty():
|
||
return
|
||
|
||
var session_duration = Time.get_unix_time_from_system() - session_start_time
|
||
|
||
# 记录会话结束事件
|
||
record_event(EventType.LOGOUT, {
|
||
"session_duration": session_duration,
|
||
"events_count": behavior_events.size()
|
||
})
|
||
|
||
session_ended.emit(current_session_id, session_duration)
|
||
|
||
# 保存数据
|
||
_save_analytics_data()
|
||
|
||
print("Session ended: ", current_session_id, " Duration: ", session_duration, "s")
|
||
|
||
## 记录行为事件
|
||
func record_event(event_type: EventType, event_data: Dictionary = {}) -> void:
|
||
"""
|
||
记录用户行为事件
|
||
@param event_type: 事件类型
|
||
@param event_data: 事件数据
|
||
"""
|
||
if not analytics_enabled:
|
||
return
|
||
|
||
var event = BehaviorEvent.new(event_type, current_user_id, current_session_id, event_data)
|
||
behavior_events.append(event)
|
||
|
||
# 限制内存中的事件数量
|
||
if behavior_events.size() > max_events_in_memory:
|
||
behavior_events.pop_front()
|
||
|
||
# 清除统计缓存
|
||
_clear_statistics_cache()
|
||
|
||
# 发射信号
|
||
behavior_recorded.emit(event_type, event_data)
|
||
|
||
# 调试输出（仅在开发模式）
|
||
if OS.is_debug_build():
|
||
print("Behavior recorded: ", EventType.keys()[event_type], " - ", event_data)
|
||
|
||
## 记录移动行为
|
||
func record_movement(from_position: Vector2, to_position: Vector2, duration: float) -> void:
|
||
"""
|
||
记录角色移动行为
|
||
@param from_position: 起始位置
|
||
@param to_position: 目标位置
|
||
@param duration: 移动时长
|
||
"""
|
||
var distance = from_position.distance_to(to_position)
|
||
record_event(EventType.MOVEMENT, {
|
||
"from": {"x": from_position.x, "y": from_position.y},
|
||
"to": {"x": to_position.x, "y": to_position.y},
|
||
"distance": distance,
|
||
"duration": duration,
|
||
"speed": distance / max(duration, 0.1)
|
||
})
|
||
|
||
## 记录对话行为
|
||
func record_dialogue_interaction(target_character: String, message_count: int, duration: float) -> void:
|
||
"""
|
||
记录对话交互行为
|
||
@param target_character: 对话目标角色
|
||
@param message_count: 消息数量
|
||
@param duration: 对话时长
|
||
"""
|
||
record_event(EventType.DIALOGUE_STARTED, {
|
||
"target": target_character,
|
||
"message_count": message_count,
|
||
"duration": duration
|
||
})
|
||
|
||
## 记录UI操作
|
||
func record_ui_action(action_type: String, ui_element: String, additional_data: Dictionary = {}) -> void:
|
||
"""
|
||
记录UI操作行为
|
||
@param action_type: 操作类型（click, hover, input等）
|
||
@param ui_element: UI元素标识
|
||
@param additional_data: 额外数据
|
||
"""
|
||
var ui_data = {
|
||
"action": action_type,
|
||
"element": ui_element
|
||
}
|
||
ui_data.merge(additional_data)
|
||
|
||
record_event(EventType.UI_ACTION, ui_data)
|
||
|
||
## 记录性能指标
|
||
func record_performance_metric(metric_name: String, value: float, unit: String = "") -> void:
|
||
"""
|
||
记录性能指标
|
||
@param metric_name: 指标名称
|
||
@param value: 指标值
|
||
@param unit: 单位
|
||
"""
|
||
record_event(EventType.PERFORMANCE_METRIC, {
|
||
"metric": metric_name,
|
||
"value": value,
|
||
"unit": unit,
|
||
"fps": Engine.get_frames_per_second(),
|
||
"memory_usage": OS.get_static_memory_usage_by_type()
|
||
})
|
||
|
||
## 记录错误事件
|
||
func record_error(error_type: String, error_message: String, context_data: Dictionary = {}) -> void:
|
||
"""
|
||
记录错误事件
|
||
@param error_type: 错误类型
|
||
@param error_message: 错误消息
|
||
@param context_data: 上下文数据
|
||
"""
|
||
var error_data = {
|
||
"error_type": error_type,
|
||
"message": error_message,
|
||
"stack_trace": get_stack() if OS.is_debug_build() else []
|
||
}
|
||
error_data.merge(context_data)
|
||
|
||
record_event(EventType.ERROR_OCCURRED, error_data)
|
||
|
||
## 生成会话ID
|
||
func _generate_session_id() -> String:
|
||
"""生成唯一的会话ID"""
|
||
var timestamp = Time.get_unix_time_from_system()
|
||
var random = randi()
|
||
return "session_%d_%d" % [timestamp, random]
|
||
|
||
## 清除统计缓存
|
||
func _clear_statistics_cache() -> void:
|
||
"""清除统计数据缓存"""
|
||
cached_statistics.clear()
|
||
statistics_cache_time = 0.0## 获
|
||
取基础统计信息
|
||
func get_basic_statistics() -> Dictionary:
|
||
"""
|
||
获取基础统计信息
|
||
@return: 统计数据字典
|
||
"""
|
||
# 检查缓存
|
||
var current_time = Time.get_unix_time_from_system()
|
||
if not cached_statistics.is_empty() and (current_time - statistics_cache_time) < cache_duration:
|
||
return cached_statistics
|
||
|
||
var stats = {}
|
||
|
||
# 事件总数统计
|
||
stats["total_events"] = behavior_events.size()
|
||
stats["current_session_events"] = _count_session_events(current_session_id)
|
||
stats["session_duration"] = current_time - session_start_time
|
||
|
||
# 事件类型分布
|
||
var event_type_counts = {}
|
||
for event in behavior_events:
|
||
var type_name = EventType.keys()[event.event_type]
|
||
event_type_counts[type_name] = event_type_counts.get(type_name, 0) + 1
|
||
stats["event_types"] = event_type_counts
|
||
|
||
# 活跃度分析
|
||
stats["activity_metrics"] = _calculate_activity_metrics()
|
||
|
||
# 性能统计
|
||
stats["performance_metrics"] = _calculate_performance_metrics()
|
||
|
||
# 错误统计
|
||
stats["error_metrics"] = _calculate_error_metrics()
|
||
|
||
# 缓存结果
|
||
cached_statistics = stats
|
||
statistics_cache_time = current_time
|
||
|
||
return stats
|
||
|
||
## 计算活跃度指标
|
||
func _calculate_activity_metrics() -> Dictionary:
|
||
"""计算用户活跃度指标"""
|
||
var metrics = {}
|
||
var current_time = Time.get_unix_time_from_system()
|
||
|
||
# 最近1小时的活动
|
||
var recent_events = _get_events_in_timeframe(current_time - 3600)
|
||
metrics["events_last_hour"] = recent_events.size()
|
||
|
||
# 移动活跃度
|
||
var movement_events = _get_events_by_type(EventType.MOVEMENT)
|
||
metrics["total_movements"] = movement_events.size()
|
||
|
||
if movement_events.size() > 0:
|
||
var total_distance = 0.0
|
||
for event in movement_events:
|
||
total_distance += event.data.get("distance", 0.0)
|
||
metrics["total_distance_moved"] = total_distance
|
||
metrics["average_movement_distance"] = total_distance / movement_events.size()
|
||
|
||
# 社交活跃度
|
||
var dialogue_events = _get_events_by_type(EventType.DIALOGUE_STARTED)
|
||
metrics["dialogue_sessions"] = dialogue_events.size()
|
||
|
||
var message_events = _get_events_by_type(EventType.MESSAGE_SENT)
|
||
metrics["messages_sent"] = message_events.size()
|
||
|
||
# UI交互频率
|
||
var ui_events = _get_events_by_type(EventType.UI_ACTION)
|
||
metrics["ui_interactions"] = ui_events.size()
|
||
|
||
return metrics
|
||
|
||
## 计算性能指标
|
||
func _calculate_performance_metrics() -> Dictionary:
|
||
"""计算性能相关指标"""
|
||
var metrics = {}
|
||
var performance_events = _get_events_by_type(EventType.PERFORMANCE_METRIC)
|
||
|
||
if performance_events.size() > 0:
|
||
var fps_values = []
|
||
var memory_values = []
|
||
|
||
for event in performance_events:
|
||
if event.context.has("fps"):
|
||
fps_values.append(event.context.fps)
|
||
if event.data.has("memory_usage"):
|
||
memory_values.append(event.data.memory_usage)
|
||
|
||
if fps_values.size() > 0:
|
||
metrics["average_fps"] = _calculate_average(fps_values)
|
||
metrics["min_fps"] = fps_values.min()
|
||
metrics["max_fps"] = fps_values.max()
|
||
|
||
if memory_values.size() > 0:
|
||
metrics["average_memory"] = _calculate_average(memory_values)
|
||
metrics["peak_memory"] = memory_values.max()
|
||
|
||
# 当前性能状态
|
||
metrics["current_fps"] = Engine.get_frames_per_second()
|
||
metrics["current_memory"] = OS.get_static_memory_usage_by_type()
|
||
|
||
return metrics
|
||
|
||
## 计算错误指标
|
||
func _calculate_error_metrics() -> Dictionary:
|
||
"""计算错误相关指标"""
|
||
var metrics = {}
|
||
var error_events = _get_events_by_type(EventType.ERROR_OCCURRED)
|
||
|
||
metrics["total_errors"] = error_events.size()
|
||
|
||
# 错误类型分布
|
||
var error_types = {}
|
||
for event in error_events:
|
||
var error_type = event.data.get("error_type", "unknown")
|
||
error_types[error_type] = error_types.get(error_type, 0) + 1
|
||
|
||
metrics["error_types"] = error_types
|
||
|
||
# 最近错误
|
||
if error_events.size() > 0:
|
||
var latest_error = error_events[-1]
|
||
metrics["latest_error"] = {
|
||
"type": latest_error.data.get("error_type", "unknown"),
|
||
"message": latest_error.data.get("message", ""),
|
||
"timestamp": latest_error.timestamp
|
||
}
|
||
|
||
return metrics
|
||
|
||
## 生成用户行为报告
|
||
func generate_behavior_report(timeframe_hours: float = 24.0) -> Dictionary:
|
||
"""
|
||
生成用户行为分析报告
|
||
@param timeframe_hours: 分析时间范围（小时）
|
||
@return: 行为报告
|
||
"""
|
||
var current_time = Time.get_unix_time_from_system()
|
||
var start_time = current_time - (timeframe_hours * 3600)
|
||
|
||
var report = {}
|
||
report["report_generated_at"] = current_time
|
||
report["timeframe_hours"] = timeframe_hours
|
||
report["user_id"] = current_user_id
|
||
report["session_id"] = current_session_id
|
||
|
||
# 获取时间范围内的事件
|
||
var timeframe_events = _get_events_in_timeframe(start_time)
|
||
report["events_in_timeframe"] = timeframe_events.size()
|
||
|
||
# 活动模式分析
|
||
report["activity_patterns"] = _analyze_activity_patterns(timeframe_events)
|
||
|
||
# 用户偏好分析
|
||
report["user_preferences"] = _analyze_user_preferences(timeframe_events)
|
||
|
||
# 会话质量分析
|
||
report["session_quality"] = _analyze_session_quality(timeframe_events)
|
||
|
||
# 发射报告生成信号
|
||
analytics_report_generated.emit(report)
|
||
|
||
return report
|
||
|
||
## 分析活动模式
|
||
func _analyze_activity_patterns(events: Array[BehaviorEvent]) -> Dictionary:
|
||
"""分析用户活动模式"""
|
||
var patterns = {}
|
||
|
||
# 按小时分组活动
|
||
var hourly_activity = {}
|
||
for event in events:
|
||
var hour = Time.get_datetime_dict_from_unix_time(event.timestamp).hour
|
||
hourly_activity[hour] = hourly_activity.get(hour, 0) + 1
|
||
|
||
patterns["hourly_distribution"] = hourly_activity
|
||
|
||
# 最活跃时段
|
||
var max_activity = 0
|
||
var peak_hour = 0
|
||
for hour in hourly_activity:
|
||
if hourly_activity[hour] > max_activity:
|
||
max_activity = hourly_activity[hour]
|
||
peak_hour = hour
|
||
|
||
patterns["peak_activity_hour"] = peak_hour
|
||
patterns["peak_activity_count"] = max_activity
|
||
|
||
# 活动类型偏好
|
||
var type_preferences = {}
|
||
for event in events:
|
||
var type_name = EventType.keys()[event.event_type]
|
||
type_preferences[type_name] = type_preferences.get(type_name, 0) + 1
|
||
|
||
patterns["activity_type_preferences"] = type_preferences
|
||
|
||
return patterns
|
||
|
||
## 分析用户偏好
|
||
func _analyze_user_preferences(events: Array[BehaviorEvent]) -> Dictionary:
|
||
"""分析用户偏好和兴趣"""
|
||
var preferences = {}
|
||
|
||
# 对话偏好
|
||
var dialogue_targets = {}
|
||
var dialogue_events = events.filter(func(e): return e.event_type == EventType.DIALOGUE_STARTED)
|
||
|
||
for event in dialogue_events:
|
||
var target = event.data.get("target", "unknown")
|
||
dialogue_targets[target] = dialogue_targets.get(target, 0) + 1
|
||
|
||
preferences["preferred_dialogue_targets"] = dialogue_targets
|
||
|
||
# UI使用偏好
|
||
var ui_preferences = {}
|
||
var ui_events = events.filter(func(e): return e.event_type == EventType.UI_ACTION)
|
||
|
||
for event in ui_events:
|
||
var element = event.data.get("element", "unknown")
|
||
ui_preferences[element] = ui_preferences.get(element, 0) + 1
|
||
|
||
preferences["ui_usage_patterns"] = ui_preferences
|
||
|
||
# 移动模式偏好
|
||
var movement_events = events.filter(func(e): return e.event_type == EventType.MOVEMENT)
|
||
if movement_events.size() > 0:
|
||
var distances = movement_events.map(func(e): return e.data.get("distance", 0.0))
|
||
preferences["average_movement_distance"] = _calculate_average(distances)
|
||
preferences["movement_frequency"] = movement_events.size()
|
||
|
||
return preferences
|
||
|
||
## 分析会话质量
|
||
func _analyze_session_quality(events: Array[BehaviorEvent]) -> Dictionary:
|
||
"""分析会话质量指标"""
|
||
var quality = {}
|
||
|
||
# 错误率
|
||
var error_events = events.filter(func(e): return e.event_type == EventType.ERROR_OCCURRED)
|
||
quality["error_rate"] = float(error_events.size()) / max(events.size(), 1)
|
||
|
||
# 参与度（基于事件多样性）
|
||
var unique_event_types = {}
|
||
for event in events:
|
||
unique_event_types[event.event_type] = true
|
||
|
||
quality["engagement_score"] = float(unique_event_types.size()) / EventType.size()
|
||
|
||
# 会话连续性（事件间隔分析）
|
||
if events.size() > 1:
|
||
var intervals = []
|
||
for i in range(1, events.size()):
|
||
intervals.append(events[i].timestamp - events[i-1].timestamp)
|
||
|
||
quality["average_event_interval"] = _calculate_average(intervals)
|
||
quality["session_continuity"] = 1.0 / (1.0 + _calculate_average(intervals))
|
||
|
||
return quality
|
||
|
||
## 辅助函数：计算平均值
|
||
func _calculate_average(values: Array) -> float:
|
||
"""计算数组平均值"""
|
||
if values.is_empty():
|
||
return 0.0
|
||
|
||
var sum = 0.0
|
||
for value in values:
|
||
sum += float(value)
|
||
|
||
return sum / values.size()
|
||
|
||
## 辅助函数：按类型获取事件
|
||
func _get_events_by_type(event_type: EventType) -> Array[BehaviorEvent]:
|
||
"""获取指定类型的事件"""
|
||
return behavior_events.filter(func(event): return event.event_type == event_type)
|
||
|
||
## 辅助函数：获取时间范围内的事件
|
||
func _get_events_in_timeframe(start_time: float) -> Array[BehaviorEvent]:
|
||
"""获取指定时间范围内的事件"""
|
||
return behavior_events.filter(func(event): return event.timestamp >= start_time)
|
||
|
||
## 辅助函数：统计会话事件数
|
||
func _count_session_events(session_id: String) -> int:
|
||
"""统计指定会话的事件数量"""
|
||
return behavior_events.filter(func(event): return event.session_id == session_id).size()
|
||
|
||
## 保存分析数据
|
||
func _save_analytics_data() -> void:
|
||
"""保存分析数据到本地文件"""
|
||
var data = {
|
||
"events": [],
|
||
"session_id": current_session_id,
|
||
"session_start_time": session_start_time,
|
||
"user_id": current_user_id,
|
||
"saved_at": Time.get_unix_time_from_system()
|
||
}
|
||
|
||
# 序列化事件数据（只保存最近的事件）
|
||
var events_to_save = behavior_events.slice(max(0, behavior_events.size() - 500), behavior_events.size())
|
||
|
||
for event in events_to_save:
|
||
data.events.append({
|
||
"event_id": event.event_id,
|
||
"event_type": event.event_type,
|
||
"user_id": event.user_id,
|
||
"session_id": event.session_id,
|
||
"timestamp": event.timestamp,
|
||
"data": event.data,
|
||
"context": event.context
|
||
})
|
||
|
||
var file = FileAccess.open(analytics_file_path, FileAccess.WRITE)
|
||
if file:
|
||
var json_string = JSON.stringify(data)
|
||
file.store_string(json_string)
|
||
file.close()
|
||
print("Analytics data saved: ", events_to_save.size(), " events")
|
||
else:
|
||
print("Failed to save analytics data")
|
||
|
||
## 加载分析数据
|
||
func _load_analytics_data() -> void:
|
||
"""从本地文件加载分析数据"""
|
||
if not FileAccess.file_exists(analytics_file_path):
|
||
print("No analytics data file found, starting fresh")
|
||
return
|
||
|
||
var file = FileAccess.open(analytics_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("events"):
|
||
for event_data in data.events:
|
||
var event = BehaviorEvent.new(
|
||
event_data.get("event_type", EventType.UI_ACTION),
|
||
event_data.get("user_id", ""),
|
||
event_data.get("session_id", "")
|
||
)
|
||
event.event_id = event_data.get("event_id", "")
|
||
event.timestamp = event_data.get("timestamp", 0.0)
|
||
event.data = event_data.get("data", {})
|
||
event.context = event_data.get("context", {})
|
||
behavior_events.append(event)
|
||
|
||
print("Analytics data loaded: ", behavior_events.size(), " events")
|
||
else:
|
||
print("Failed to parse analytics data JSON")
|
||
else:
|
||
print("Failed to open analytics data file")
|
||
|
||
## 导出分析报告
|
||
func export_analytics_report(export_path: String, timeframe_hours: float = 24.0) -> bool:
|
||
"""
|
||
导出分析报告到文件
|
||
@param export_path: 导出文件路径
|
||
@param timeframe_hours: 分析时间范围
|
||
@return: 是否成功导出
|
||
"""
|
||
var report = generate_behavior_report(timeframe_hours)
|
||
|
||
var file = FileAccess.open(export_path, FileAccess.WRITE)
|
||
if file:
|
||
var json_string = JSON.stringify(report)
|
||
file.store_string(json_string)
|
||
file.close()
|
||
print("Analytics report exported to: ", export_path)
|
||
return true
|
||
else:
|
||
print("Failed to export analytics report to: ", export_path)
|
||
return false
|
||
|
||
## 清理旧数据
|
||
func cleanup_old_data(days_to_keep: int = 7) -> void:
|
||
"""
|
||
清理旧的分析数据
|
||
@param days_to_keep: 保留天数
|
||
"""
|
||
var cutoff_time = Time.get_unix_time_from_system() - (days_to_keep * 86400)
|
||
var original_count = behavior_events.size()
|
||
|
||
behavior_events = behavior_events.filter(func(event): return event.timestamp >= cutoff_time)
|
||
|
||
var removed_count = original_count - behavior_events.size()
|
||
if removed_count > 0:
|
||
print("Cleaned up ", removed_count, " old analytics events")
|
||
_save_analytics_data()
|
||
|
||
## 获取实时统计
|
||
func get_realtime_statistics() -> Dictionary:
|
||
"""获取实时统计信息（不使用缓存）"""
|
||
var stats = {}
|
||
|
||
stats["current_session_duration"] = Time.get_unix_time_from_system() - session_start_time
|
||
stats["events_this_session"] = _count_session_events(current_session_id)
|
||
stats["current_fps"] = Engine.get_frames_per_second()
|
||
stats["memory_usage"] = OS.get_static_memory_usage_by_type()
|
||
|
||
# 最近5分钟的活动
|
||
var recent_time = Time.get_unix_time_from_system() - 300
|
||
var recent_events = _get_events_in_timeframe(recent_time)
|
||
stats["recent_activity"] = recent_events.size()
|
||
|
||
return stats
|
||
|
||
## 设置分析配置
|
||
func set_analytics_config(enabled: bool, max_events: int = 1000) -> void:
|
||
"""
|
||
设置分析系统配置
|
||
@param enabled: 是否启用分析
|
||
@param max_events: 最大事件数量
|
||
"""
|
||
analytics_enabled = enabled
|
||
max_events_in_memory = max_events
|
||
|
||
print("Analytics config updated - Enabled: ", enabled, " Max events: ", max_events)
|
||
|
||
func _exit_tree():
|
||
"""节点退出时保存数据"""
|
||
end_current_session() |