CocosPlugin/esengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

项目统一改用Logger控制管理

Browse Source 
拆分pool类和FluentAPI
This commit is contained in:
YHH
2025-08-08 11:16:00 +08:00
parent 2d389308ea
commit 87dd564a12
51 changed files with 1813 additions and 1491 deletions
Download Patch File Download Diff File Expand all files Collapse all files

246
packages/network/src/Core/Logger.ts
View File

@@ -1,246 +0,0 @@
/**
* 日志级别
*/
export enum LogLevel {
Debug = 0,
Info = 1,
Warn = 2,
Error = 3,
Fatal = 4,
None = 5
}
/**
* 日志接口
*/
export interface ILogger {
debug(message: string, ...args: unknown[]): void;
info(message: string, ...args: unknown[]): void;
warn(message: string, ...args: unknown[]): void;
error(message: string, ...args: unknown[]): void;
fatal(message: string, ...args: unknown[]): void;
}
/**
* 日志配置
*/
export interface LoggerConfig {
/** 日志级别 */
level: LogLevel;
/** 是否启用时间戳 */
enableTimestamp: boolean;
/** 是否启用颜色 */
enableColors: boolean;
/** 日志前缀 */
prefix?: string;
/** 自定义输出函数 */
output?: (level: LogLevel, message: string) => void;
}
/**
* 默认控制台日志实现
*/
export class ConsoleLogger implements ILogger {
private config: LoggerConfig;
constructor(config: Partial<LoggerConfig> = {}) {
this.config = {
level: LogLevel.Info,
enableTimestamp: true,
enableColors: typeof window === 'undefined', // Node.js环境默认启用颜色
...config
};
}
public debug(message: string, ...args: unknown[]): void {
this.log(LogLevel.Debug, message, ...args);
}
public info(message: string, ...args: unknown[]): void {
this.log(LogLevel.Info, message, ...args);
}
public warn(message: string, ...args: unknown[]): void {
this.log(LogLevel.Warn, message, ...args);
}
public error(message: string, ...args: unknown[]): void {
this.log(LogLevel.Error, message, ...args);
}
public fatal(message: string, ...args: unknown[]): void {
this.log(LogLevel.Fatal, message, ...args);
}
private log(level: LogLevel, message: string, ...args: unknown[]): void {
if (level < this.config.level) {
return;
}
let formattedMessage = message;
// 添加时间戳
if (this.config.enableTimestamp) {
const timestamp = new Date().toISOString();
formattedMessage = `[${timestamp}] ${formattedMessage}`;
}
// 添加前缀
if (this.config.prefix) {
formattedMessage = `[${this.config.prefix}] ${formattedMessage}`;
}
// 添加日志级别
const levelName = LogLevel[level].toUpperCase();
formattedMessage = `[${levelName}] ${formattedMessage}`;
// 使用自定义输出或默认控制台输出
if (this.config.output) {
this.config.output(level, formattedMessage);
} else {
this.outputToConsole(level, formattedMessage, ...args);
}
}
private outputToConsole(level: LogLevel, message: string, ...args: unknown[]): void {
const colors = this.config.enableColors ? this.getColors() : null;
switch (level) {
case LogLevel.Debug:
if (colors) {
console.debug(`${colors.gray}${message}${colors.reset}`, ...args);
} else {
console.debug(message, ...args);
}
break;
case LogLevel.Info:
if (colors) {
console.info(`${colors.blue}${message}${colors.reset}`, ...args);
} else {
console.info(message, ...args);
}
break;
case LogLevel.Warn:
if (colors) {
console.warn(`${colors.yellow}${message}${colors.reset}`, ...args);
} else {
console.warn(message, ...args);
}
break;
case LogLevel.Error:
case LogLevel.Fatal:
if (colors) {
console.error(`${colors.red}${message}${colors.reset}`, ...args);
} else {
console.error(message, ...args);
}
break;
}
}
private getColors() {
return {
reset: '\x1b[0m',
red: '\x1b[31m',
yellow: '\x1b[33m',
blue: '\x1b[34m',
gray: '\x1b[90m'
};
}
public setLevel(level: LogLevel): void {
this.config.level = level;
}
public setPrefix(prefix: string): void {
this.config.prefix = prefix;
}
}
/**
* 日志管理器
*/
export class LoggerManager {
private static _instance: LoggerManager;
private _loggers = new Map<string, ILogger>();
private _defaultLogger: ILogger;
private constructor() {
this._defaultLogger = new ConsoleLogger();
}
public static getInstance(): LoggerManager {
if (!LoggerManager._instance) {
LoggerManager._instance = new LoggerManager();
}
return LoggerManager._instance;
}
/**
* 获取或创建日志器
*/
public getLogger(name?: string): ILogger {
if (!name) {
return this._defaultLogger;
}
if (!this._loggers.has(name)) {
const logger = new ConsoleLogger({
prefix: name,
level: LogLevel.Info
});
this._loggers.set(name, logger);
}
return this._loggers.get(name)!;
}
/**
* 设置日志器
*/
public setLogger(name: string, logger: ILogger): void {
this._loggers.set(name, logger);
}
/**
* 设置全局日志级别
*/
public setGlobalLevel(level: LogLevel): void {
if (this._defaultLogger instanceof ConsoleLogger) {
this._defaultLogger.setLevel(level);
}
for (const logger of this._loggers.values()) {
if (logger instanceof ConsoleLogger) {
logger.setLevel(level);
}
}
}
/**
* 创建子日志器
*/
public createChildLogger(parentName: string, childName: string): ILogger {
const fullName = `${parentName}.${childName}`;
return this.getLogger(fullName);
}
}
/**
* 默认日志器实例
*/
export const Logger = LoggerManager.getInstance().getLogger();
/**
* 创建命名日志器
*/
export function createLogger(name: string): ILogger {
return LoggerManager.getInstance().getLogger(name);
}
/**
* 设置全局日志级别
*/
export function setGlobalLogLevel(level: LogLevel): void {
LoggerManager.getInstance().setGlobalLevel(level);
}

22
packages/network/src/Core/NetworkClient.ts
View File

@@ -4,6 +4,7 @@ import { SyncVarUpdateMessage } from '../Messaging/MessageTypes';
import { SyncVarMessageHandler } from '../SyncVar/SyncVarMessageHandler';
import { MessageHandler } from '../Messaging/MessageHandler';
import { NetworkPerformanceMonitor } from './NetworkPerformanceMonitor';
import { createLogger } from '@esengine/ecs-framework';
/**
* 客户端事件接口
@@ -24,6 +25,7 @@ export interface NetworkClientEvents {
* 提供消息发送和接收功能
*/
export class NetworkClient {
private static readonly logger = createLogger('NetworkClient');
private _connection: NetworkConnection | null = null;
private _url: string = '';
private _isConnected: boolean = false;
@@ -129,7 +131,7 @@ export class NetworkClient {
// 设置连接事件监听
this._connection.on('connected', () => {
console.log(`[NetworkClient] 连接成功: ${this._url}`);
NetworkClient.logger.info(`连接成功: ${this._url}`);
this.emit('connected');
// 如果这是重连，触发重连成功事件
@@ -139,7 +141,7 @@ export class NetworkClient {
});
this._connection.on('disconnected', (reason) => {
console.log(`[NetworkClient] 连接断开: ${reason}`);
NetworkClient.logger.info(`连接断开: ${reason}`);
this.handleDisconnection(reason);
});
@@ -153,7 +155,7 @@ export class NetworkClient {
});
this._connection.on('error', (error) => {
console.error('[NetworkClient] 连接错误:', error);
NetworkClient.logger.error('连接错误:', error);
this.emit('error', error);
});
@@ -214,7 +216,7 @@ export class NetworkClient {
this._maxReconnectDelay
);
console.log(`[NetworkClient] ${delay}ms后尝试重连 (${this._reconnectAttempts}/${this._maxReconnectAttempts})`);
NetworkClient.logger.info(`${delay}ms后尝试重连 (${this._reconnectAttempts}/${this._maxReconnectAttempts})`);
this.emit('reconnecting', this._reconnectAttempts);
this._reconnectTimer = setTimeout(async () => {
@@ -266,7 +268,7 @@ export class NetworkClient {
*/
public send(data: Uint8Array): boolean {
if (!this._connection || !this._isConnected) {
console.warn('[NetworkClient] 未连接，无法发送数据');
NetworkClient.logger.warn('未连接，无法发送数据');
return false;
}
@@ -364,7 +366,7 @@ export class NetworkClient {
try {
handler(...args);
} catch (error) {
console.error(`[NetworkClient] 事件处理器错误 (${event}):`, error);
NetworkClient.logger.error(`事件处理器错误 (${event}):`, error);
}
});
}
@@ -449,14 +451,14 @@ export class NetworkClient {
const success = this.send(serializedMessage);
if (success) {
console.log(`[NetworkClient] 发送SyncVar消息: ${message.networkId}.${message.componentType}`);
NetworkClient.logger.debug(`发送SyncVar消息: ${message.networkId}.${message.componentType}`);
} else {
console.warn(`[NetworkClient] SyncVar消息发送失败: ${message.networkId}.${message.componentType}`);
NetworkClient.logger.warn(`SyncVar消息发送失败: ${message.networkId}.${message.componentType}`);
}
return success;
} catch (error) {
console.error('[NetworkClient] 发送SyncVar消息失败:', error);
NetworkClient.logger.error('发送SyncVar消息失赅:', error);
return false;
}
}
@@ -476,7 +478,7 @@ export class NetworkClient {
}
}
console.log(`[NetworkClient] 批量发送SyncVar消息: ${successCount}/${messages.length} 成功`);
NetworkClient.logger.debug(`批量发送SyncVar消息: ${successCount}/${messages.length} 成功`);
return successCount;
}

16
packages/network/src/Core/NetworkConnection.ts
View File

@@ -1,4 +1,5 @@
import WebSocket from 'isomorphic-ws';
import { createLogger } from '@esengine/ecs-framework';
/**
* 网络连接状态
@@ -27,6 +28,7 @@ export interface NetworkConnectionEvents {
* 支持二进制消息传输，集成心跳检测
*/
export class NetworkConnection {
private static readonly logger = createLogger('NetworkConnection');
private _ws: WebSocket | null = null;
private _state: ConnectionState = ConnectionState.Disconnected;
private _connectionId: string = '';
@@ -96,13 +98,13 @@ export class NetworkConnection {
// 将字符串转换为Uint8Array
data = new TextEncoder().encode(event.data);
} else {
console.warn('[NetworkConnection] 收到未知类型的消息:', typeof event.data);
NetworkConnection.logger.warn(' 收到未知类型的消息:', typeof event.data);
return;
}
this.emit('message', data);
} catch (error) {
console.error('[NetworkConnection] 消息处理错误:', error);
NetworkConnection.logger.error(' 消息处理错误:', error);
}
};
}
@@ -136,7 +138,7 @@ export class NetworkConnection {
try {
this._ws.send('ping');
} catch (error) {
console.error('[NetworkConnection] 心跳发送失败:', error);
NetworkConnection.logger.error(' 心跳发送失败:', error);
}
}
}
@@ -149,7 +151,7 @@ export class NetworkConnection {
*/
public send(data: Uint8Array): boolean {
if (!this._ws || this._state !== ConnectionState.Connected) {
console.warn('[NetworkConnection] 连接未就绪，无法发送数据');
NetworkConnection.logger.warn(' 连接未就绪，无法发送数据');
return false;
}
@@ -157,7 +159,7 @@ export class NetworkConnection {
this._ws.send(data);
return true;
} catch (error) {
console.error('[NetworkConnection] 数据发送失败:', error);
NetworkConnection.logger.error(' 数据发送失败:', error);
return false;
}
}
@@ -179,7 +181,7 @@ export class NetworkConnection {
try {
this._ws.close(1000, reason);
} catch (error) {
console.error('[NetworkConnection] 连接关闭失败:', error);
NetworkConnection.logger.error(' 连接关闭失败:', error);
}
this._ws = null;
}
@@ -236,7 +238,7 @@ export class NetworkConnection {
try {
handler(...args);
} catch (error) {
console.error(`[NetworkConnection] 事件处理器错误 (${event}):`, error);
NetworkConnection.logger.error(`事件处理器错误 (${event}):`, error);
}
});
}

14
packages/network/src/Core/NetworkEnvironment.ts
View File

@@ -1,4 +1,5 @@
import { NetworkRole } from '../NetworkRole';
import { createLogger } from '@esengine/ecs-framework';
/**
* 网络环境状态
@@ -21,6 +22,7 @@ export enum NetworkEnvironmentState {
* 避免在构造函数中传递角色参数，保持与核心ECS框架的兼容性
*/
export class NetworkEnvironment {
private static readonly logger = createLogger('NetworkEnvironment');
private static _instance: NetworkEnvironment | null = null;
private _state: NetworkEnvironmentState = NetworkEnvironmentState.None;
private _serverStartTime: number = 0;
@@ -52,7 +54,7 @@ export class NetworkEnvironment {
}
instance._serverStartTime = Date.now();
console.log(`[NetworkEnvironment] 环境设置为: ${instance._state}`);
NetworkEnvironment.logger.info(`环境设置为: ${instance._state}`);
}
/**
@@ -69,7 +71,7 @@ export class NetworkEnvironment {
}
instance._clientConnectTime = Date.now();
console.log(`[NetworkEnvironment] 环境设置为: ${instance._state}`);
NetworkEnvironment.logger.info(`环境设置为: ${instance._state}`);
}
/**
@@ -85,7 +87,7 @@ export class NetworkEnvironment {
}
instance._serverStartTime = 0;
console.log(`[NetworkEnvironment] 服务端模式已清除，当前状态: ${instance._state}`);
NetworkEnvironment.logger.info(`服务端模式已清除，当前状态: ${instance._state}`);
}
/**
@@ -101,7 +103,7 @@ export class NetworkEnvironment {
}
instance._clientConnectTime = 0;
console.log(`[NetworkEnvironment] 客户端模式已清除，当前状态: ${instance._state}`);
NetworkEnvironment.logger.info(`客户端模式已清除，当前状态: ${instance._state}`);
}
/**
@@ -112,7 +114,7 @@ export class NetworkEnvironment {
instance._state = NetworkEnvironmentState.None;
instance._serverStartTime = 0;
instance._clientConnectTime = 0;
console.log('[NetworkEnvironment] 环境状态已重置');
NetworkEnvironment.logger.info('环境状态已重置');
}
/**
@@ -241,6 +243,6 @@ export class NetworkEnvironment {
instance._clientConnectTime = clientConnectTime;
}
console.log(`[NetworkEnvironment] 强制设置环境状态为: ${state}`);
NetworkEnvironment.logger.debug(`强制设置环境状态为: ${state}`);
}
}

27
packages/network/src/Core/NetworkIdentity.ts
View File

@@ -1,4 +1,4 @@
import { Component } from '@esengine/ecs-framework';
import { Component, createLogger } from '@esengine/ecs-framework';
import { v4 as uuidv4 } from 'uuid';
/**
@@ -8,6 +8,8 @@ import { v4 as uuidv4 } from 'uuid';
* 每个需要网络同步的实体都必须拥有此组件
*/
export class NetworkIdentity extends Component {
private static readonly logger = createLogger('NetworkIdentity');
/**
* 网络对象唯一ID
*/
@@ -74,7 +76,7 @@ export class NetworkIdentity extends Component {
// 自动注册到NetworkIdentityRegistry
NetworkIdentityRegistry.Instance.register(this);
console.log(`[NetworkIdentity] 创建网络对象: ${this.networkId}, 权威: ${hasAuthority}`);
NetworkIdentity.logger.debug(` 创建网络对象: ${this.networkId}, 权威: ${hasAuthority}`);
}
/**
@@ -86,7 +88,7 @@ export class NetworkIdentity extends Component {
const oldOwnerId = this.ownerId;
this.ownerId = ownerId;
console.log(`[NetworkIdentity] 对象 ${this.networkId} 拥有者变更: ${oldOwnerId} -> ${ownerId}`);
NetworkIdentity.logger.debug(` 对象 ${this.networkId} 拥有者变更: ${oldOwnerId} -> ${ownerId}`);
}
/**
@@ -97,7 +99,7 @@ export class NetworkIdentity extends Component {
public setAuthority(hasAuthority: boolean): void {
if (this.hasAuthority !== hasAuthority) {
this.hasAuthority = hasAuthority;
console.log(`[NetworkIdentity] 对象 ${this.networkId} 权威状态变更: ${hasAuthority}`);
NetworkIdentity.logger.debug(` 对象 ${this.networkId} 权威状态变更: ${hasAuthority}`);
}
}
@@ -107,7 +109,7 @@ export class NetworkIdentity extends Component {
public activate(): void {
if (!this.isNetworkActive) {
this.isNetworkActive = true;
console.log(`[NetworkIdentity] 激活网络对象: ${this.networkId}`);
NetworkIdentity.logger.debug(` 激活网络对象: ${this.networkId}`);
}
}
@@ -117,7 +119,7 @@ export class NetworkIdentity extends Component {
public deactivate(): void {
if (this.isNetworkActive) {
this.isNetworkActive = false;
console.log(`[NetworkIdentity] 停用网络对象: ${this.networkId}`);
NetworkIdentity.logger.debug(` 停用网络对象: ${this.networkId}`);
}
}
@@ -178,7 +180,7 @@ export class NetworkIdentity extends Component {
public cleanup(): void {
NetworkIdentityRegistry.Instance.unregister(this.networkId);
this.deactivate();
console.log(`[NetworkIdentity] 清理网络对象: ${this.networkId}`);
NetworkIdentity.logger.debug(` 清理网络对象: ${this.networkId}`);
}
}
@@ -188,6 +190,7 @@ export class NetworkIdentity extends Component {
* 管理所有网络对象的注册和查找
*/
export class NetworkIdentityRegistry {
private static readonly logger = createLogger('NetworkIdentityRegistry');
private static _instance: NetworkIdentityRegistry | null = null;
/**
@@ -226,7 +229,7 @@ export class NetworkIdentityRegistry {
*/
public register(identity: NetworkIdentity): void {
if (this._identities.has(identity.networkId)) {
console.warn(`[NetworkIdentityRegistry] 网络对象ID重复: ${identity.networkId}`);
NetworkIdentityRegistry.logger.warn(` 网络对象ID重复: ${identity.networkId}`);
return;
}
@@ -242,7 +245,7 @@ export class NetworkIdentityRegistry {
this._authorityObjects.add(identity);
}
console.log(`[NetworkIdentityRegistry] 注册网络对象: ${identity.networkId}`);
NetworkIdentityRegistry.logger.debug(` 注册网络对象: ${identity.networkId}`);
}
/**
@@ -266,7 +269,7 @@ export class NetworkIdentityRegistry {
// 从权威对象集合中移除
this._authorityObjects.delete(identity);
console.log(`[NetworkIdentityRegistry] 注销网络对象: ${networkId}`);
NetworkIdentityRegistry.logger.debug(` 注销网络对象: ${networkId}`);
return true;
}
@@ -386,7 +389,7 @@ export class NetworkIdentityRegistry {
identity.setAuthority(false);
}
console.log(`[NetworkIdentityRegistry] 清理断开连接客户端 ${disconnectedOwnerId} 的 ${ownerObjects.length} 个对象`);
NetworkIdentityRegistry.logger.debug(` 清理断开连接客户端 ${disconnectedOwnerId} 的 ${ownerObjects.length} 个对象`);
return ownerObjects;
}
@@ -473,6 +476,6 @@ export class NetworkIdentityRegistry {
this._identities.clear();
this._ownerObjects.clear();
this._authorityObjects.clear();
console.log('[NetworkIdentityRegistry] 已清空注册表');
NetworkIdentityRegistry.logger.info(' 已清空注册表');
}
}

18
packages/network/src/Core/NetworkManager.ts
View File

@@ -1,6 +1,7 @@
import { NetworkServer } from './NetworkServer';
import { NetworkClient } from './NetworkClient';
import { NetworkEnvironment } from './NetworkEnvironment';
import { createLogger } from '@esengine/ecs-framework';
/**
* 网络管理器 - 网络框架的核心入口
@@ -9,6 +10,7 @@ import { NetworkEnvironment } from './NetworkEnvironment';
* 支持启动服务端、客户端，管理连接状态
*/
export class NetworkManager {
private static readonly _logger = createLogger('NetworkManager');
private static _instance: NetworkManager | null = null;
private _server: NetworkServer | null = null;
private _client: NetworkClient | null = null;
@@ -38,7 +40,7 @@ export class NetworkManager {
const instance = NetworkManager.Instance;
if (instance._isServer) {
console.warn('[NetworkManager] 服务端已经在运行');
NetworkManager._logger.warn('服务端已经在运行');
return false;
}
@@ -50,10 +52,10 @@ export class NetworkManager {
// 自动设置网络环境为服务端模式
NetworkEnvironment.SetServerMode();
console.log(`[NetworkManager] 服务端启动成功，监听 ${host}:${port}`);
NetworkManager._logger.info(`服务端启动成功，监听 ${host}:${port}`);
return true;
} catch (error) {
console.error('[NetworkManager] 服务端启动失败:', error);
NetworkManager._logger.error('服务端启动失败:', error);
instance._server = null;
return false;
}
@@ -69,7 +71,7 @@ export class NetworkManager {
const instance = NetworkManager.Instance;
if (instance._isClient) {
console.warn('[NetworkManager] 客户端已经在运行');
NetworkManager._logger.warn('客户端已经在运行');
return false;
}
@@ -81,10 +83,10 @@ export class NetworkManager {
// 自动设置网络环境为客户端模式
NetworkEnvironment.SetClientMode();
console.log(`[NetworkManager] 客户端连接成功: ${url}`);
NetworkManager._logger.info(`客户端连接成功: ${url}`);
return true;
} catch (error) {
console.error('[NetworkManager] 客户端连接失败:', error);
NetworkManager._logger.error('客户端连接失败:', error);
instance._client = null;
return false;
}
@@ -104,7 +106,7 @@ export class NetworkManager {
// 清除服务端环境模式
NetworkEnvironment.ClearServerMode();
console.log('[NetworkManager] 服务端已停止');
NetworkManager._logger.info('服务端已停止');
}
}
@@ -122,7 +124,7 @@ export class NetworkManager {
// 清除客户端环境模式
NetworkEnvironment.ClearClientMode();
console.log('[NetworkManager] 客户端已断开连接');
NetworkManager._logger.info('客户端已断开连接');
}
}

18
packages/network/src/Core/NetworkPerformanceMonitor.ts
View File

@@ -3,6 +3,7 @@
*
* 监控网络连接的性能指标，包括延迟、吞吐量、包丢失率等
*/
import { createLogger } from '@esengine/ecs-framework';
export interface NetworkMetrics {
/** 往返时延 (ms) */
@@ -56,6 +57,7 @@ export interface PerformanceSnapshot {
* 网络性能监控器
*/
export class NetworkPerformanceMonitor {
private static readonly logger = createLogger('NetworkPerformanceMonitor');
private static _instance: NetworkPerformanceMonitor | null = null;
/** 性能快照历史 */
@@ -117,7 +119,7 @@ export class NetworkPerformanceMonitor {
*/
public startMonitoring(interval: number = 1000): void {
if (this._isMonitoring) {
console.warn('[NetworkPerformanceMonitor] 监控已在运行');
NetworkPerformanceMonitor.logger.warn('监控已在运行');
return;
}
@@ -128,7 +130,7 @@ export class NetworkPerformanceMonitor {
this.collectMetrics();
}, this._monitoringInterval);
console.log(`[NetworkPerformanceMonitor] 开始性能监控，间隔: ${interval}ms`);
NetworkPerformanceMonitor.logger.info(`开始性能监控，间隔: ${interval}ms`);
}
/**
@@ -145,7 +147,7 @@ export class NetworkPerformanceMonitor {
}
this._isMonitoring = false;
console.log('[NetworkPerformanceMonitor] 停止性能监控');
NetworkPerformanceMonitor.logger.info('停止性能监控');
}
/**
@@ -308,7 +310,7 @@ export class NetworkPerformanceMonitor {
syncDataSize: stats.totalDataSize || 0
};
} catch (error) {
console.warn('[NetworkPerformanceMonitor] 获取SyncVar统计失败:', error);
NetworkPerformanceMonitor.logger.warn('获取SyncVar统计失败:', error);
return undefined;
}
}
@@ -337,7 +339,7 @@ export class NetworkPerformanceMonitor {
if (warnings.length > 0) {
this.emit('performanceWarning', warnings);
console.warn('[NetworkPerformanceMonitor] 性能警告:', warnings.join(', '));
NetworkPerformanceMonitor.logger.warn('性能警告:', warnings.join(', '));
}
}
@@ -418,7 +420,7 @@ export class NetworkPerformanceMonitor {
this._snapshots = [];
this._rttHistory = [];
this._bandwidthWindow = [];
console.log('[NetworkPerformanceMonitor] 清除历史数据');
NetworkPerformanceMonitor.logger.debug('清除历史数据');
}
/**
@@ -504,7 +506,7 @@ export class NetworkPerformanceMonitor {
try {
listener(...args);
} catch (error) {
console.error(`[NetworkPerformanceMonitor] 事件处理器错误 (${event}):`, error);
NetworkPerformanceMonitor.logger.error(`事件处理器错误 (${event}):`, error);
}
});
}
@@ -530,7 +532,7 @@ export class NetworkPerformanceMonitor {
this._bandwidthWindowSize = options.bandwidthWindowSize;
}
console.log('[NetworkPerformanceMonitor] 配置已更新:', options);
NetworkPerformanceMonitor.logger.info('配置已更新:', options);
}
/**

44
packages/network/src/Core/NetworkServer.ts
View File

@@ -6,6 +6,7 @@ import { SyncVarMessageHandler } from '../SyncVar/SyncVarMessageHandler';
import { SyncVarSyncScheduler } from '../SyncVar/SyncVarSyncScheduler';
import { MessageHandler } from '../Messaging/MessageHandler';
import { NetworkPerformanceMonitor } from './NetworkPerformanceMonitor';
import { createLogger } from '@esengine/ecs-framework';
/**
* 服务端事件接口
@@ -26,6 +27,7 @@ export interface NetworkServerEvents {
* 支持多客户端连接，提供广播和单播功能
*/
export class NetworkServer {
private static readonly _logger = createLogger('NetworkServer');
private _wss: WebSocketServer | null = null;
private _connections: Map<string, NetworkConnection> = new Map();
private _isRunning: boolean = false;
@@ -104,13 +106,13 @@ export class NetworkServer {
// 启动性能监控
this.startPerformanceMonitoring();
console.log(`[NetworkServer] 服务器启动成功: ${host}:${port}`);
NetworkServer._logger.info(`服务器启动成功: ${host}:${port}`);
this.emit('serverStarted', port, host);
resolve();
});
this._wss.on('error', (error) => {
console.error('[NetworkServer] 服务器错误:', error);
NetworkServer._logger.error('服务器错误:', error);
this.emit('error', error);
if (!this._isRunning) {
@@ -154,7 +156,7 @@ export class NetworkServer {
this._host = '';
this._startTime = 0;
console.log('[NetworkServer] 服务器已停止');
NetworkServer._logger.info('服务器已停止');
this.emit('serverStopped');
resolve();
});
@@ -170,7 +172,7 @@ export class NetworkServer {
private handleNewConnection(ws: WebSocket, request: any): void {
// 检查连接数限制
if (this._connections.size >= NetworkServer.MAX_CONNECTIONS) {
console.warn('[NetworkServer] 达到最大连接数限制，拒绝新连接');
NetworkServer._logger.warn('达到最大连接数限制，拒绝新连接');
ws.close(1013, 'Server full');
return;
}
@@ -185,13 +187,13 @@ export class NetworkServer {
// 设置连接事件监听
connection.on('connected', () => {
this._connections.set(connectionId, connection);
console.log(`[NetworkServer] 客户端连接: ${connectionId} (${clientAddress})`);
NetworkServer._logger.info(`客户端连接: ${connectionId} (${clientAddress})`);
this.emit('clientConnected', connection);
});
connection.on('disconnected', (reason) => {
this._connections.delete(connectionId);
console.log(`[NetworkServer] 客户端断开: ${connectionId} (${reason})`);
NetworkServer._logger.info(`客户端断开: ${connectionId} (${reason})`);
this.emit('clientDisconnected', connection, reason);
});
@@ -205,7 +207,7 @@ export class NetworkServer {
});
connection.on('error', (error) => {
console.error(`[NetworkServer] 连接错误 ${connectionId}:`, error);
NetworkServer._logger.error(`连接错误 ${connectionId}:`, error);
this.emit('error', error);
});
}
@@ -220,7 +222,7 @@ export class NetworkServer {
public sendToClient(connectionId: string, data: Uint8Array): boolean {
const connection = this._connections.get(connectionId);
if (!connection) {
console.warn(`[NetworkServer] 连接不存在: ${connectionId}`);
NetworkServer._logger.warn(`连接不存在: ${connectionId}`);
return false;
}
@@ -370,7 +372,7 @@ export class NetworkServer {
try {
handler(...args);
} catch (error) {
console.error(`[NetworkServer] 事件处理器错误 (${event}):`, error);
NetworkServer._logger.error(`事件处理器错误 (${event}):`, error);
}
});
}
@@ -417,9 +419,9 @@ export class NetworkServer {
private startSyncVarScheduler(): void {
try {
this._syncScheduler.start();
console.log('[NetworkServer] SyncVar同步调度器已启动');
NetworkServer._logger.info('SyncVar同步调度器已启动');
} catch (error) {
console.error('[NetworkServer] 启动SyncVar调度器失败:', error);
NetworkServer._logger.error('启动SyncVar调度器失败:', error);
}
}
@@ -429,9 +431,9 @@ export class NetworkServer {
private stopSyncVarScheduler(): void {
try {
this._syncScheduler.stop();
console.log('[NetworkServer] SyncVar同步调度器已停止');
NetworkServer._logger.info('SyncVar同步调度器已停止');
} catch (error) {
console.error('[NetworkServer] 停止SyncVar调度器失败:', error);
NetworkServer._logger.error('停止SyncVar调度器失败:', error);
}
}
@@ -445,9 +447,9 @@ export class NetworkServer {
const serializedMessage = message.serialize();
const successCount = this.broadcast(serializedMessage);
console.log(`[NetworkServer] 广播SyncVar消息: ${message.networkId}.${message.componentType}, 成功发送到 ${successCount} 个客户端`);
NetworkServer._logger.info(`广播SyncVar消息: ${message.networkId}.${message.componentType}, 成功发送到 ${successCount} 个客户端`);
} catch (error) {
console.error('[NetworkServer] 广播SyncVar消息失败:', error);
NetworkServer._logger.error('广播SyncVar消息失败:', error);
}
}
@@ -462,7 +464,7 @@ export class NetworkServer {
const serializedMessage = message.serialize();
return this.sendToClient(connectionId, serializedMessage);
} catch (error) {
console.error(`[NetworkServer] 发送SyncVar消息到客户端 ${connectionId} 失败:`, error);
NetworkServer._logger.error(`发送SyncVar消息到客户端 ${connectionId} 失败:`, error);
return false;
}
}
@@ -481,7 +483,7 @@ export class NetworkServer {
return this.sendToMultipleClients(targetConnections, serializedMessage);
} catch (error) {
console.error('[NetworkServer] 广播SyncVar消息（排除指定客户端）失败:', error);
NetworkServer._logger.error('广播SyncVar消息（排除指定客户端）失败:', error);
return 0;
}
}
@@ -506,9 +508,9 @@ export class NetworkServer {
private startPerformanceMonitoring(): void {
try {
this._performanceMonitor.startMonitoring();
console.log('[NetworkServer] 性能监控已启动');
NetworkServer._logger.info('性能监控已启动');
} catch (error) {
console.error('[NetworkServer] 启动性能监控失败:', error);
NetworkServer._logger.error('启动性能监控失败:', error);
}
}
@@ -518,9 +520,9 @@ export class NetworkServer {
private stopPerformanceMonitoring(): void {
try {
this._performanceMonitor.stopMonitoring();
console.log('[NetworkServer] 性能监控已停止');
NetworkServer._logger.info('性能监控已停止');
} catch (error) {
console.error('[NetworkServer] 停止性能监控失败:', error);
NetworkServer._logger.error('停止性能监控失败:', error);
}
}

14
packages/network/src/Core/index.ts
View File

@@ -11,22 +11,10 @@ export { NetworkConnection, ConnectionState } from './NetworkConnection';
export { NetworkEnvironment, NetworkEnvironmentState } from './NetworkEnvironment';
export { NetworkIdentity, NetworkIdentityRegistry } from './NetworkIdentity';
export { NetworkPerformanceMonitor } from './NetworkPerformanceMonitor';
export {
LoggerManager,
ConsoleLogger,
Logger,
createLogger,
setGlobalLogLevel,
LogLevel
} from './Logger';
// 事件接口导出
export type { NetworkServerEvents } from './NetworkServer';
export type { NetworkClientEvents } from './NetworkClient';
export type { NetworkConnectionEvents } from './NetworkConnection';
// 性能监控类型导出
export type { NetworkMetrics, PerformanceSnapshot } from './NetworkPerformanceMonitor';
// 日志类型导出
export type { ILogger, LoggerConfig } from './Logger';
export type { NetworkMetrics, PerformanceSnapshot } from './NetworkPerformanceMonitor';

20
packages/network/src/Messaging/MessageHandler.ts
View File

@@ -1,6 +1,7 @@
import { NetworkMessage } from './NetworkMessage';
import { NetworkConnection } from '../Core/NetworkConnection';
import { INetworkMessage, MessageData } from '../types/NetworkTypes';
import { createLogger } from '@esengine/ecs-framework';
/**
* 消息处理器接口
@@ -31,6 +32,7 @@ interface MessageHandlerInfo<T extends MessageData = MessageData> {
* 支持消息优先级和类型匹配
*/
export class MessageHandler {
private static readonly logger = createLogger('MessageHandler');
private static _instance: MessageHandler | null = null;
private _handlers: Map<number, MessageHandlerInfo[]> = new Map();
private _messageClasses: Map<number, new (...args: any[]) => INetworkMessage> = new Map();
@@ -74,7 +76,7 @@ export class MessageHandler {
// 检查是否已经注册了相同的处理器
const existingIndex = handlers.findIndex(h => h.handler === handler);
if (existingIndex !== -1) {
console.warn(`[MessageHandler] 消息类型 ${messageType} 的处理器已存在，将替换优先级`);
MessageHandler.logger.warn(`消息类型 ${messageType} 的处理器已存在，将替换优先级`);
handlers[existingIndex].priority = priority;
} else {
// 添加新处理器
@@ -88,7 +90,7 @@ export class MessageHandler {
// 按优先级排序（数字越小优先级越高）
handlers.sort((a, b) => a.priority - b.priority);
console.log(`[MessageHandler] 注册消息处理器: 类型=${messageType}, 优先级=${priority}`);
MessageHandler.logger.debug(`注册消息处理器: 类型=${messageType}, 优先级=${priority}`);
}
/**
@@ -106,7 +108,7 @@ export class MessageHandler {
const index = handlers.findIndex(h => h.handler === handler);
if (index !== -1) {
handlers.splice(index, 1);
console.log(`[MessageHandler] 注销消息处理器: 类型=${messageType}`);
MessageHandler.logger.debug(`注销消息处理器: 类型=${messageType}`);
}
// 如果没有处理器了，清理映射
@@ -125,7 +127,7 @@ export class MessageHandler {
*/
public async handleRawMessage(data: Uint8Array, connection?: NetworkConnection): Promise<boolean> {
if (data.length < 4) {
console.error('[MessageHandler] 消息数据长度不足，至少需要4字节消息类型');
MessageHandler.logger.error('消息数据长度不足，至少需要4字节消息类型');
return false;
}
@@ -136,7 +138,7 @@ export class MessageHandler {
// 查找消息类
const MessageClass = this._messageClasses.get(messageType);
if (!MessageClass) {
console.warn(`[MessageHandler] 未知的消息类型: ${messageType}`);
MessageHandler.logger.warn(`未知的消息类型: ${messageType}`);
return false;
}
@@ -147,7 +149,7 @@ export class MessageHandler {
return await this.handleMessage(message, connection);
} catch (error) {
console.error(`[MessageHandler] 消息反序列化失败 (类型=${messageType}):`, error);
MessageHandler.logger.error(`消息反序列化失败 (类型=${messageType}):`, error);
return false;
}
}
@@ -164,7 +166,7 @@ export class MessageHandler {
const handlers = this._handlers.get(messageType);
if (!handlers || handlers.length === 0) {
console.warn(`[MessageHandler] 没有找到消息类型 ${messageType} 的处理器`);
MessageHandler.logger.warn(`没有找到消息类型 ${messageType} 的处理器`);
return false;
}
@@ -182,7 +184,7 @@ export class MessageHandler {
handledCount++;
} catch (error) {
console.error(`[MessageHandler] 处理器执行错误 (类型=${messageType}, 优先级=${handlerInfo.priority}):`, error);
MessageHandler.logger.error(`处理器执行错误 (类型=${messageType}, 优先级=${handlerInfo.priority}):`, error);
// 继续执行其他处理器
}
}
@@ -226,7 +228,7 @@ export class MessageHandler {
public clear(): void {
this._handlers.clear();
this._messageClasses.clear();
console.log('[MessageHandler] 已清除所有消息处理器');
MessageHandler.logger.info('已清除所有消息处理器');
}
/**

10
packages/network/src/NetworkComponent.ts
View File

@@ -5,6 +5,7 @@ import { NetworkEnvironment } from './Core/NetworkEnvironment';
import { createSyncVarProxy, isSyncVarProxied, destroySyncVarProxy } from './SyncVar/SyncVarProxy';
import { SyncVarManager } from './SyncVar/SyncVarManager';
import { getSyncVarMetadata } from './SyncVar/SyncVarDecorator';
import { createLogger } from '@esengine/ecs-framework';
/**
* 网络组件基类
@@ -92,10 +93,12 @@ export abstract class NetworkComponent extends Component implements INetworkSync
if (!ComponentRegistry.isRegistered(this.constructor)) {
// 如果未注册，自动注册
ComponentRegistry.register(this.constructor);
console.log(`[NetworkComponent] 自动注册组件类型: ${this.constructor.name}`);
const logger = createLogger('NetworkComponent');
logger.debug(`自动注册组件类型: ${this.constructor.name}`);
}
} catch (error) {
console.warn(`[NetworkComponent] 无法注册组件类型 ${this.constructor.name}:`, error);
const logger = createLogger('NetworkComponent');
logger.warn(`无法注册组件类型 ${this.constructor.name}:`, error);
}
}
@@ -107,7 +110,8 @@ export abstract class NetworkComponent extends Component implements INetworkSync
private initializeSyncVar(): void {
const metadata = getSyncVarMetadata(this.constructor);
if (metadata.length > 0) {
console.log(`[NetworkComponent] ${this.constructor.name} 发现 ${metadata.length} 个SyncVar字段，将启用代理监听`);
const logger = createLogger('NetworkComponent');
logger.debug(`${this.constructor.name} 发现 ${metadata.length} 个SyncVar字段，将启用代理监听`);
}
}

14
packages/network/src/Serialization/ProtobufSerializer.ts
View File

@@ -12,6 +12,7 @@ import {
getProtoName
} from './ProtobufDecorators';
import { SerializedData } from './SerializationTypes';
import { createLogger } from '@esengine/ecs-framework';
/**
* 可序列化组件接口
@@ -28,6 +29,7 @@ interface SerializableComponent extends Component {
export class ProtobufSerializer {
private registry: ProtobufRegistry;
private static instance: ProtobufSerializer;
private static readonly logger = createLogger('ProtobufSerializer');
/** protobuf.js根对象 */
private root: protobuf.Root | null = null;
@@ -104,7 +106,7 @@ export class ProtobufSerializer {
private async initializeProtobuf(): Promise<void> {
try {
this.buildProtoDefinitions();
console.log('[ProtobufSerializer] Protobuf支持已启用');
ProtobufSerializer.logger.info('Protobuf支持已启用');
} catch (error) {
throw new Error('[ProtobufSerializer] 初始化protobuf失败: ' + error);
}
@@ -127,7 +129,7 @@ export class ProtobufSerializer {
} else {
this.buildProtoDefinitions();
}
console.log('[ProtobufSerializer] Protobuf支持已手动启用');
ProtobufSerializer.logger.info('Protobuf支持已手动启用');
}
/**
@@ -247,7 +249,7 @@ export class ProtobufSerializer {
// 记录错误统计
if (errors.length > 0) {
console.warn(`[ProtobufSerializer] 批量序列化完成，${results.length} 成功，${errors.length} 失败`);
ProtobufSerializer.logger.warn(`批量序列化完成，${results.length} 成功，${errors.length} 失败`);
}
return results;
@@ -382,7 +384,7 @@ export class ProtobufSerializer {
this.componentDataCache.delete(key);
}
console.log(`[ProtobufSerializer] 清理了 ${entries.length} 个缓存项`);
ProtobufSerializer.logger.debug(`清理了 ${entries.length} 个缓存项`);
}
/**
@@ -434,7 +436,7 @@ export class ProtobufSerializer {
this.messageTypeCache.clear();
this.cacheAccessCount.clear();
} catch (error) {
console.error('[ProtobufSerializer] 构建protobuf定义失败:', error);
ProtobufSerializer.logger.error('构建protobuf定义失败:', error);
}
}
@@ -463,7 +465,7 @@ export class ProtobufSerializer {
}
return null;
} catch (error) {
console.warn(`[ProtobufSerializer] 未找到消息类型: ${fullTypeName}`);
ProtobufSerializer.logger.warn(`未找到消息类型: ${fullTypeName}`);
return null;
}
}

20
packages/network/src/Snapshot/SnapshotManager.ts
View File

@@ -1,4 +1,4 @@
import { Entity, Component, ComponentType } from '@esengine/ecs-framework';
import { Entity, Component, ComponentType, createLogger } from '@esengine/ecs-framework';
import { ISnapshotable, SceneSnapshot, EntitySnapshot, ComponentSnapshot, SnapshotConfig } from './ISnapshotable';
import { ProtobufSerializer } from '../Serialization/ProtobufSerializer';
import { SerializedData } from '../Serialization/SerializationTypes';
@@ -103,6 +103,8 @@ class ComponentTypeRegistry implements IComponentFactory {
* 使用protobuf序列化
*/
export class SnapshotManager {
private static readonly logger = createLogger('SnapshotManager');
/** 默认快照配置 */
private static readonly DEFAULT_CONFIG: SnapshotConfig = {
includeInSnapshot: true,
@@ -240,7 +242,7 @@ export class SnapshotManager {
return entity;
} catch (error) {
console.error(`[SnapshotManager] 创建实体失败: ${entitySnapshot.name}`, error);
SnapshotManager.logger.error(`创建实体失败: ${entitySnapshot.name}`, error);
return null;
}
}
@@ -253,7 +255,7 @@ export class SnapshotManager {
// 尝试获取组件构造函数
const componentType = this.getComponentType(componentSnapshot.type);
if (!componentType) {
console.warn(`[SnapshotManager] 未知组件类型: ${componentSnapshot.type}`);
SnapshotManager.logger.warn(`未知组件类型: ${componentSnapshot.type}`);
return;
}
@@ -272,7 +274,7 @@ export class SnapshotManager {
this.protobufSerializer.deserialize(component, serializedData);
} catch (error) {
console.error(`[SnapshotManager] 创建组件失败: ${componentSnapshot.type}`, error);
SnapshotManager.logger.error(`创建组件失败: ${componentSnapshot.type}`, error);
}
}
@@ -282,7 +284,7 @@ export class SnapshotManager {
private getComponentType(typeName: string): NetworkComponentType | null {
const componentType = this.componentRegistry.get(typeName);
if (!componentType) {
console.warn(`[SnapshotManager] 组件类型 ${typeName} 未注册，请先调用 registerComponentType() 注册`);
SnapshotManager.logger.warn(`组件类型 ${typeName} 未注册，请先调用 registerComponentType() 注册`);
return null;
}
return componentType;
@@ -414,7 +416,7 @@ export class SnapshotManager {
public initializeProtobuf(protobufJs: any): void {
if (this.protobufSerializer) {
this.protobufSerializer.initialize(protobufJs);
console.log('[SnapshotManager] Protobuf支持已手动启用');
SnapshotManager.logger.info('Protobuf支持已手动启用');
}
}
@@ -425,7 +427,7 @@ export class SnapshotManager {
*/
public registerComponentType<T extends Component & INetworkSyncable>(constructor: NetworkComponentType<T>): void {
this.componentRegistry.autoRegister(constructor);
console.log(`[SnapshotManager] 已注册组件类型: ${constructor.name}`);
SnapshotManager.logger.debug(`已注册组件类型: ${constructor.name}`);
}
/**
@@ -597,7 +599,7 @@ export class SnapshotManager {
// 查找现有组件
const componentType = this.getComponentType(componentSnapshot.type);
if (!componentType) {
console.warn(`[SnapshotManager] 组件类型 ${componentSnapshot.type} 未注册，无法恢复`);
SnapshotManager.logger.warn(`组件类型 ${componentSnapshot.type} 未注册，无法恢复`);
return;
}
@@ -605,7 +607,7 @@ export class SnapshotManager {
if (!component) {
// 组件不存在，需要创建
console.warn(`[SnapshotManager] 组件 ${componentSnapshot.type} 不存在于实体 ${entity.name}，无法恢复`);
SnapshotManager.logger.warn(`组件 ${componentSnapshot.type} 不存在于实体 ${entity.name}，无法恢复`);
return;
}

12
packages/network/src/SyncVar/SyncVarDecorator.ts
View File

@@ -1,4 +1,7 @@
import 'reflect-metadata';
import { createLogger } from '@esengine/ecs-framework';
const logger = createLogger('SyncVarDecorator');
/**
* SyncVar配置选项
@@ -151,7 +154,8 @@ export function getSyncVarMetadataForProperty(target: any, propertyKey: string):
* public isReady: boolean = false;
*
* onNameChanged(oldName: string, newName: string) {
* console.log(`Name changed: ${oldName} -> ${newName}`);
* const logger = createLogger('PlayerComponent');
* logger.info(`Name changed: ${oldName} -> ${newName}`);
* }
* }
* ```
@@ -165,7 +169,7 @@ export function SyncVar(options: SyncVarOptions = {}): PropertyDecorator {
// 获取属性类型
const type = Reflect.getMetadata('design:type', target, propertyKey);
if (!type) {
console.warn(`[SyncVar] 无法获取属性 ${propertyKey} 的类型信息`);
logger.warn(`无法获取属性 ${propertyKey} 的类型信息`);
}
// 获取现有元数据
@@ -174,7 +178,7 @@ export function SyncVar(options: SyncVarOptions = {}): PropertyDecorator {
// 检查是否已经存在
const existingIndex = existingMetadata.findIndex(m => m.propertyKey === propertyKey);
if (existingIndex !== -1) {
console.warn(`[SyncVar] 属性 ${propertyKey} 已经被标记为SyncVar，将覆盖配置`);
logger.warn(`属性 ${propertyKey} 已经被标记为SyncVar，将覆盖配置`);
existingMetadata[existingIndex].options = options;
existingMetadata[existingIndex].type = type;
} else {
@@ -194,7 +198,7 @@ export function SyncVar(options: SyncVarOptions = {}): PropertyDecorator {
// 保存元数据
setSyncVarMetadata(target.constructor, existingMetadata);
console.log(`[SyncVar] 注册同步变量: ${target.constructor.name}.${propertyKey}, 字段编号: ${existingMetadata.find(m => m.propertyKey === propertyKey)?.fieldNumber}`);
logger.debug(`注册同步变量: ${target.constructor.name}.${propertyKey}, 字段编号: ${existingMetadata.find(m => m.propertyKey === propertyKey)?.fieldNumber}`);
};
}

5
packages/network/src/SyncVar/SyncVarFactory.ts
View File

@@ -1,6 +1,7 @@
import { createSyncVarProxy } from './SyncVarProxy';
import { getSyncVarMetadata } from './SyncVarDecorator';
import { INetworkSyncable } from '../types/NetworkTypes';
import { createLogger } from '@esengine/ecs-framework';
/**
* SyncVar工厂函数
@@ -16,6 +17,8 @@ import { INetworkSyncable } from '../types/NetworkTypes';
* @param args - 构造函数参数
* @returns 带代理的组件实例
*/
const logger = createLogger('SyncVarFactory');
export function createNetworkComponent<T extends INetworkSyncable>(
ComponentClass: new (...args: any[]) => T,
...args: any[]
@@ -36,7 +39,7 @@ export function createNetworkComponent<T extends INetworkSyncable>(
debugLog: false // 可以根据需要启用调试
});
console.log(`[SyncVarFactory] 为 ${ComponentClass.name} 创建了SyncVar代理，包含 ${metadata.length} 个同步字段`);
logger.debug(`为 ${ComponentClass.name} 创建了SyncVar代理，包含 ${metadata.length} 个同步字段`);
return proxy;
}

40
packages/network/src/SyncVar/SyncVarManager.ts
View File

@@ -12,6 +12,7 @@ import {
NetworkComponentType,
TypeGuards
} from '../types/NetworkTypes';
import { createLogger } from '@esengine/ecs-framework';
/**
* SyncVar变化记录
@@ -83,6 +84,7 @@ export interface SyncVarSyncData {
*/
export class SyncVarManager {
private static _instance: SyncVarManager | null = null;
private static readonly logger = createLogger('SyncVarManager');
/**
* 组件实例的SyncVar变化监听器
@@ -133,7 +135,7 @@ export class SyncVarManager {
}
if (validationErrors.length > 0) {
console.error(`[SyncVarManager] 组件 ${component.constructor.name} 的SyncVar配置错误:`, validationErrors);
SyncVarManager.logger.error(`组件 ${component.constructor.name} 的SyncVar配置错误:`, validationErrors);
return false;
}
@@ -141,7 +143,7 @@ export class SyncVarManager {
this._componentChanges.set(componentId, []);
this._lastSyncTimes.set(componentId, new Map());
console.log(`[SyncVarManager] 初始化组件 ${component.constructor.name} 的SyncVar系统，共 ${metadata.length} 个同步变量`);
SyncVarManager.logger.info(`初始化组件 ${component.constructor.name} 的SyncVar系统，共 ${metadata.length} 个同步变量`);
return true;
}
@@ -174,13 +176,13 @@ export class SyncVarManager {
const metadata = getSyncVarMetadataForProperty(component, propertyKey);
if (!metadata) {
console.warn(`[SyncVarManager] 属性 ${propertyKey} 不是SyncVar`);
SyncVarManager.logger.warn(`属性 ${propertyKey} 不是SyncVar`);
return;
}
// 检查值是否真的发生了变化
if (!TypeGuards.isSyncVarValue(oldValue) || !TypeGuards.isSyncVarValue(newValue)) {
console.warn(`[SyncVarManager] 无效的SyncVar值类型: ${typeof oldValue}, ${typeof newValue}`);
SyncVarManager.logger.warn(`无效的SyncVar值类型: ${typeof oldValue}, ${typeof newValue}`);
return;
}
@@ -195,14 +197,14 @@ export class SyncVarManager {
if (metadata.options.throttleMs && metadata.options.throttleMs > 0) {
if (now - lastSyncTime < metadata.options.throttleMs) {
console.log(`[SyncVarManager] 属性 ${propertyKey} 变化过于频繁，跳过同步`);
SyncVarManager.logger.debug(`属性 ${propertyKey} 变化过于频繁，跳过同步`);
return;
}
}
// 检查权限
if (metadata.options.authorityOnly && !this.hasAuthority(component)) {
console.warn(`[SyncVarManager] 属性 ${propertyKey} 需要权限才能修改，但当前没有权限`);
SyncVarManager.logger.warn(`属性 ${propertyKey} 需要权限才能修改，但当前没有权限`);
return;
}
@@ -229,7 +231,7 @@ export class SyncVarManager {
lastSyncTimes.set(propertyKey, now);
}
console.log(`[SyncVarManager] 记录变化: ${component.constructor.name}.${propertyKey} = ${newValue} (was ${oldValue})`);
SyncVarManager.logger.debug(`记录变化: ${component.constructor.name}.${propertyKey} = ${newValue} (was ${oldValue})`);
// 触发hook回调
this.triggerHook(component, metadata, oldValue, newValue);
@@ -294,7 +296,7 @@ export class SyncVarManager {
data: serializedData
});
} catch (error) {
console.error(`[SyncVarManager] 序列化失败 ${change.propertyKey}:`, error);
SyncVarManager.logger.error(`序列化失败 ${change.propertyKey}:`, error);
}
}
@@ -322,7 +324,7 @@ export class SyncVarManager {
for (const update of syncData.fieldUpdates) {
const meta = metadataMap.get(update.fieldNumber);
if (!meta) {
console.warn(`[SyncVarManager] 未找到字段编号 ${update.fieldNumber} 的元数据`);
SyncVarManager.logger.warn(`未找到字段编号 ${update.fieldNumber} 的元数据`);
continue;
}
@@ -336,9 +338,9 @@ export class SyncVarManager {
// 触发hook回调
this.triggerHook(component, meta, oldValue, newValue);
console.log(`[SyncVarManager] 应用同步: ${component.constructor.name}.${meta.propertyKey} = ${newValue}`);
SyncVarManager.logger.debug(`应用同步: ${component.constructor.name}.${meta.propertyKey} = ${newValue}`);
} catch (error) {
console.error(`[SyncVarManager] 反序列化失败 ${meta.propertyKey}:`, error);
SyncVarManager.logger.error(`反序列化失败 ${meta.propertyKey}:`, error);
}
}
}
@@ -421,7 +423,7 @@ export class SyncVarManager {
private shouldSync(component: any, metadata: SyncVarMetadata): boolean {
// 权限检查：权威字段只有在有权限时才同步
if (metadata.options.authorityOnly && !this.hasAuthority(component)) {
console.log(`[SyncVarManager] 字段 ${metadata.propertyKey} 是权威字段，但当前没有权限，跳过同步`);
SyncVarManager.logger.debug(`字段 ${metadata.propertyKey} 是权威字段，但当前没有权限，跳过同步`);
return false;
}
@@ -457,7 +459,7 @@ export class SyncVarManager {
try {
hookFunction.call(component, oldValue, newValue);
} catch (error) {
console.error(`[SyncVarManager] Hook函数执行失败 ${metadata.options.hook}:`, error);
SyncVarManager.logger.error(`Hook函数执行失败 ${metadata.options.hook}:`, error);
}
}
}
@@ -641,7 +643,7 @@ export class SyncVarManager {
syncSequence
);
console.log(`[SyncVarManager] 创建SyncVar更新消息: ${component.constructor.name}, ${fieldUpdates.length} 个字段`);
SyncVarManager.logger.debug(`创建SyncVar更新消息: ${component.constructor.name}, ${fieldUpdates.length} 个字段`);
return message;
}
@@ -653,7 +655,7 @@ export class SyncVarManager {
*/
public applySyncVarUpdateMessage(component: any, message: SyncVarUpdateMessage): void {
if (message.componentType !== component.constructor.name) {
console.warn(`[SyncVarManager] 组件类型不匹配: 期望 ${component.constructor.name}, 收到 ${message.componentType}`);
SyncVarManager.logger.warn(`组件类型不匹配: 期望 ${component.constructor.name}, 收到 ${message.componentType}`);
return;
}
@@ -663,7 +665,7 @@ export class SyncVarManager {
for (const fieldUpdate of message.fieldUpdates) {
const meta = metadataMap.get(fieldUpdate.fieldNumber);
if (!meta) {
console.warn(`[SyncVarManager] 未找到字段编号 ${fieldUpdate.fieldNumber} 的元数据`);
SyncVarManager.logger.warn(`未找到字段编号 ${fieldUpdate.fieldNumber} 的元数据`);
continue;
}
@@ -672,7 +674,7 @@ export class SyncVarManager {
if (fieldUpdate.authorityOnly && NetworkEnvironment.isClient && !this.hasAuthority(component)) {
// 如果这是来自服务端的更新，则允许应用
// 这里简单实现：客户端接受所有权威字段的更新
console.log(`[SyncVarManager] 客户端接受权威字段更新: ${fieldUpdate.propertyKey}`);
SyncVarManager.logger.debug(`客户端接受权威字段更新: ${fieldUpdate.propertyKey}`);
}
try {
@@ -684,9 +686,9 @@ export class SyncVarManager {
// 触发hook回调
this.triggerHook(component, meta, oldValue, fieldUpdate.newValue);
console.log(`[SyncVarManager] 应用SyncVar消息更新: ${component.constructor.name}.${meta.propertyKey} = ${fieldUpdate.newValue}`);
SyncVarManager.logger.debug(`应用SyncVar消息更新: ${component.constructor.name}.${meta.propertyKey} = ${fieldUpdate.newValue}`);
} catch (error) {
console.error(`[SyncVarManager] 应用SyncVar更新失败 ${meta.propertyKey}:`, error);
SyncVarManager.logger.error(`应用SyncVar更新失败 ${meta.propertyKey}:`, error);
}
}

45
packages/network/src/SyncVar/SyncVarMessageHandler.ts
View File

@@ -4,7 +4,7 @@ import { NetworkConnection } from '../Core/NetworkConnection';
import { NetworkIdentityRegistry } from '../Core/NetworkIdentity';
import { SyncVarManager } from './SyncVarManager';
import { NetworkEnvironment } from '../Core/NetworkEnvironment';
import { ComponentRegistry } from '@esengine/ecs-framework';
import { ComponentRegistry, createLogger } from '@esengine/ecs-framework';
import { NetworkManager } from '../Core/NetworkManager';
/**
@@ -13,6 +13,7 @@ import { NetworkManager } from '../Core/NetworkManager';
* 处理接收到的SyncVar更新消息，自动查找目标网络对象并应用更新
*/
export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessage> {
private static readonly logger = createLogger('SyncVarMessageHandler');
private _processedMessages: Set<string> = new Set();
private _maxProcessedCache: number = 1000;
@@ -27,7 +28,7 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
// 生成消息唯一标识符用于去重
const messageKey = this.generateMessageKey(message);
if (this._processedMessages.has(messageKey)) {
console.log(`[SyncVarMessageHandler] 跳过重复消息: ${messageKey}`);
SyncVarMessageHandler.logger.debug(` 跳过重复消息: ${messageKey}`);
return;
}
@@ -36,27 +37,27 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
// 验证消息基本有效性
if (!this.validateMessage(message)) {
console.error('[SyncVarMessageHandler] 消息验证失败');
SyncVarMessageHandler.logger.error(' 消息验证失败');
return;
}
// 查找目标网络对象
const targetIdentity = NetworkIdentityRegistry.Instance.find(message.networkId);
if (!targetIdentity) {
console.warn(`[SyncVarMessageHandler] 未找到网络对象: ${message.networkId}`);
SyncVarMessageHandler.logger.warn(` 未找到网络对象: ${message.networkId}`);
return;
}
// 权限检查
if (!this.checkAuthority(message, connection, targetIdentity)) {
console.warn(`[SyncVarMessageHandler] 权限检查失败: ${message.networkId}`);
SyncVarMessageHandler.logger.warn(` 权限检查失败: ${message.networkId}`);
return;
}
// 查找目标组件
const targetComponent = this.findTargetComponent(targetIdentity, message.componentType);
if (!targetComponent) {
console.warn(`[SyncVarMessageHandler] 未找到目标组件: ${message.componentType} on ${message.networkId}`);
SyncVarMessageHandler.logger.warn(` 未找到目标组件: ${message.componentType} on ${message.networkId}`);
return;
}
@@ -74,10 +75,10 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
await this.forwardToOtherClients(message, connection);
}
console.log(`[SyncVarMessageHandler] 成功处理SyncVar更新: ${message.networkId}.${message.componentType}, ${message.fieldUpdates.length}个字段`);
SyncVarMessageHandler.logger.debug(` 成功处理SyncVar更新: ${message.networkId}.${message.componentType}, ${message.fieldUpdates.length}个字段`);
} catch (error) {
console.error('[SyncVarMessageHandler] 处理SyncVar更新失败:', error);
SyncVarMessageHandler.logger.error(' 处理SyncVar更新失败:', error);
}
}
@@ -106,12 +107,12 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
*/
private validateMessage(message: SyncVarUpdateMessage): boolean {
if (!message.networkId || !message.componentType) {
console.error('[SyncVarMessageHandler] 消息缺少必要字段');
SyncVarMessageHandler.logger.error(' 消息缺少必要字段');
return false;
}
if (!message.fieldUpdates || message.fieldUpdates.length === 0) {
console.error('[SyncVarMessageHandler] 消息没有字段更新');
SyncVarMessageHandler.logger.error(' 消息没有字段更新');
return false;
}
@@ -119,7 +120,7 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
const now = Date.now();
const maxAge = 60000; // 1分钟
if (message.timestamp > now + 5000 || message.timestamp < now - maxAge) {
console.warn(`[SyncVarMessageHandler] 消息时间戳异常: ${message.timestamp}, 当前: ${now}`);
SyncVarMessageHandler.logger.warn(` 消息时间戳异常: ${message.timestamp}, 当前: ${now}`);
return false;
}
@@ -143,7 +144,7 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
// 非拥有者只能发送非权威字段更新
const hasAuthorityOnlyUpdates = message.fieldUpdates.some(update => update.authorityOnly);
if (hasAuthorityOnlyUpdates) {
console.warn(`[SyncVarMessageHandler] 非拥有者 ${connection.connectionId} 尝试修改权威字段`);
SyncVarMessageHandler.logger.warn(` 非拥有者 ${connection.connectionId} 尝试修改权威字段`);
return false;
}
}
@@ -165,7 +166,7 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
private findTargetComponent(targetIdentity: any, componentType: string): any {
const entity = targetIdentity.entity;
if (!entity || typeof entity.getComponent !== 'function') {
console.error('[SyncVarMessageHandler] NetworkIdentity缺少有效的Entity引用');
SyncVarMessageHandler.logger.error(' NetworkIdentity缺少有效的Entity引用');
return null;
}
@@ -179,13 +180,13 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
// 使用Entity的getComponent方法查找组件
const component = entity.getComponent(ComponentClass);
if (!component) {
console.warn(`[SyncVarMessageHandler] Entity ${entity.id} 上未找到组件: ${componentType}`);
SyncVarMessageHandler.logger.warn(` Entity ${entity.id} 上未找到组件: ${componentType}`);
return null;
}
return component;
} catch (error) {
console.error(`[SyncVarMessageHandler] 查找组件失败: ${componentType}`, error);
SyncVarMessageHandler.logger.error(`查找组件失败: ${componentType}`, error);
return null;
}
}
@@ -197,7 +198,7 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
const componentClass = ComponentRegistry.getComponentType(componentType);
if (!componentClass) {
console.warn(`[SyncVarMessageHandler] 未找到组件类型: ${componentType}`);
SyncVarMessageHandler.logger.warn(` 未找到组件类型: ${componentType}`);
return null;
}
@@ -213,7 +214,7 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
try {
syncVarManager.applySyncVarUpdateMessage(targetComponent, message);
} catch (error) {
console.error('[SyncVarMessageHandler] 应用SyncVar更新失败:', error);
SyncVarMessageHandler.logger.error(' 应用SyncVar更新失败:', error);
throw error;
}
}
@@ -230,7 +231,7 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
const server = NetworkManager.GetServer();
if (!server || !server.isRunning) {
console.warn('[SyncVarMessageHandler] NetworkServer未运行，无法转发消息');
SyncVarMessageHandler.logger.warn(' NetworkServer未运行，无法转发消息');
return;
}
@@ -238,12 +239,12 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
const successCount = await server.broadcastSyncVarMessageExcept(message, senderConnection.connectionId);
if (successCount > 0) {
console.log(`[SyncVarMessageHandler] 成功转发消息给 ${successCount} 个其他客户端 (发送者: ${senderConnection.connectionId})`);
SyncVarMessageHandler.logger.debug(` 成功转发消息给 ${successCount} 个其他客户端 (发送者: ${senderConnection.connectionId})`);
} else {
console.log(`[SyncVarMessageHandler] 没有其他客户端需要转发消息 (发送者: ${senderConnection.connectionId})`);
SyncVarMessageHandler.logger.debug(` 没有其他客户端需要转发消息 (发送者: ${senderConnection.connectionId})`);
}
} catch (error) {
console.error(`[SyncVarMessageHandler] 转发消息失败 (发送者: ${senderConnection.connectionId}):`, error);
SyncVarMessageHandler.logger.error(`转发消息失败 (发送者: ${senderConnection.connectionId}):`, error);
}
}
@@ -267,7 +268,7 @@ export class SyncVarMessageHandler implements IMessageHandler<SyncVarUpdateMessa
*/
public clearProcessedCache(): void {
this._processedMessages.clear();
console.log('[SyncVarMessageHandler] 已清理消息处理缓存');
SyncVarMessageHandler.logger.info('已清理消息处理缓存');
}
/**

10
packages/network/src/SyncVar/SyncVarOptimizer.ts
View File

@@ -1,4 +1,5 @@
import { SyncVarUpdateMessage, SyncVarFieldUpdate } from '../Messaging/MessageTypes';
import { createLogger } from '@esengine/ecs-framework';
/**
* SyncVar优化配置
@@ -325,6 +326,7 @@ export class SyncVarDistanceCuller {
* SyncVar性能优化器
*/
export class SyncVarOptimizer {
private static readonly logger = createLogger('SyncVarOptimizer');
private _config: SyncVarOptimizationConfig;
private _messageMerger: SyncVarMessageMerger;
private _rateLimiter: SyncVarRateLimiter;
@@ -376,7 +378,7 @@ export class SyncVarOptimizer {
// 频率限制检查
if (!this._rateLimiter.canSend(message.networkId)) {
this._stats.messagesBlocked++;
console.log(`[SyncVarOptimizer] 消息被频率限制阻止: ${message.networkId}`);
SyncVarOptimizer.logger.debug(` 消息被频率限制阻止: ${message.networkId}`);
return;
}
@@ -385,7 +387,7 @@ export class SyncVarOptimizer {
if (validObservers.length === 0 && targetObservers.length > 0) {
this._stats.messagesBlocked++;
console.log(`[SyncVarOptimizer] 消息被距离剔除阻止: ${message.networkId}`);
SyncVarOptimizer.logger.debug(` 消息被距离剔除阻止: ${message.networkId}`);
return;
}
@@ -393,7 +395,7 @@ export class SyncVarOptimizer {
this._messageMerger.addMessage(message, (mergedMessage) => {
if (mergedMessage !== message) {
this._stats.messagesMerged++;
console.log(`[SyncVarOptimizer] 消息已合并: ${message.networkId}`);
SyncVarOptimizer.logger.debug(` 消息已合并: ${message.networkId}`);
}
onOptimized([mergedMessage], validObservers);
@@ -412,7 +414,7 @@ export class SyncVarOptimizer {
*/
public configure(config: Partial<SyncVarOptimizationConfig>): void {
this._config = { ...this._config, ...config };
console.log('[SyncVarOptimizer] 配置已更新:', this._config);
SyncVarOptimizer.logger.info(' 配置已更新:', this._config);
}
/**

20
packages/network/src/SyncVar/SyncVarProxy.ts
View File

@@ -1,6 +1,7 @@
import { getSyncVarMetadata, isSyncVar } from './SyncVarDecorator';
import { SyncVarManager } from './SyncVarManager';
import { INetworkSyncable, SyncVarValue, TypeGuards } from '../types/NetworkTypes';
import { createLogger } from '@esengine/ecs-framework';
/**
* SyncVar代理配置
@@ -36,9 +37,11 @@ export function createSyncVarProxy<T extends INetworkSyncable>(
// 检查目标是否有SyncVar
const metadata = getSyncVarMetadata(target.constructor);
const logger = createLogger('SyncVarProxy');
if (metadata.length === 0) {
if (debugLog) {
console.log(`[SyncVarProxy] 对象 ${target.constructor.name} 没有SyncVar，返回原对象`);
logger.debug(`对象 ${target.constructor.name} 没有SyncVar，返回原对象`);
}
return target;
}
@@ -47,7 +50,7 @@ export function createSyncVarProxy<T extends INetworkSyncable>(
syncVarManager.initializeComponent(target);
if (debugLog) {
console.log(`[SyncVarProxy] 为 ${target.constructor.name} 创建代理，SyncVar字段:`,
logger.debug(`为 ${target.constructor.name} 创建代理，SyncVar字段:`,
metadata.map(m => m.propertyKey));
}
@@ -81,7 +84,7 @@ export function createSyncVarProxy<T extends INetworkSyncable>(
const value = Reflect.get(obj, prop);
if (debugLog && isSyncVar(obj, propertyKey)) {
console.log(`[SyncVarProxy] GET ${obj.constructor.name}.${propertyKey} = ${value}`);
logger.debug(`GET ${obj.constructor.name}.${propertyKey} = ${value}`);
}
return value;
@@ -117,7 +120,7 @@ export function createSyncVarProxy<T extends INetworkSyncable>(
const oldValue = originalValues.get(propertyKey);
if (debugLog) {
console.log(`[SyncVarProxy] SET ${obj.constructor.name}.${propertyKey} = ${newValue} (was ${oldValue})`);
logger.debug(`SET ${obj.constructor.name}.${propertyKey} = ${newValue} (was ${oldValue})`);
}
// 设置新值
@@ -133,7 +136,7 @@ export function createSyncVarProxy<T extends INetworkSyncable>(
syncVarManager.recordChange(obj, propertyKey, oldValue, newValue);
}
} catch (error) {
console.error(`[SyncVarProxy] 记录SyncVar变化失败:`, error);
logger.error(`记录SyncVar变化失败:`, error);
}
}
@@ -147,7 +150,7 @@ export function createSyncVarProxy<T extends INetworkSyncable>(
const propertyKey = prop as string;
if (typeof prop === 'string' && isSyncVar(obj, propertyKey)) {
console.warn(`[SyncVarProxy] 尝试删除SyncVar属性 ${propertyKey}，这可能会导致同步问题`);
logger.warn(`尝试删除SyncVar属性 ${propertyKey}，这可能会导致同步问题`);
}
return Reflect.deleteProperty(obj, prop);
@@ -180,7 +183,7 @@ export function createSyncVarProxy<T extends INetworkSyncable>(
(proxy as T & { _syncVarProxied: boolean; _syncVarOptions: SyncVarProxyOptions })._syncVarOptions = options;
if (debugLog) {
console.log(`[SyncVarProxy] ${target.constructor.name} 代理创建完成`);
logger.debug(`${target.constructor.name} 代理创建完成`);
}
return proxy;
@@ -229,7 +232,8 @@ export function destroySyncVarProxy(proxy: INetworkSyncable & { _syncVarProxied?
proxy._syncVarProxied = false;
proxy._syncVarDestroyed = true;
console.log(`[SyncVarProxy] ${proxy.constructor?.name || 'Unknown'} 代理已销毁`);
const logger = createLogger('SyncVarProxy');
logger.debug(`${proxy.constructor?.name || 'Unknown'} 代理已销毁`);
}
/**

31
packages/network/src/SyncVar/SyncVarSyncScheduler.ts
View File

@@ -2,7 +2,7 @@ import { SyncVarManager } from './SyncVarManager';
import { NetworkIdentityRegistry, NetworkIdentity } from '../Core/NetworkIdentity';
import { SyncVarUpdateMessage } from '../Messaging/MessageTypes';
import { NetworkEnvironment } from '../Core/NetworkEnvironment';
import { ComponentRegistry } from '@esengine/ecs-framework';
import { ComponentRegistry, createLogger } from '@esengine/ecs-framework';
import { NetworkComponent } from '../NetworkComponent';
/**
@@ -69,6 +69,7 @@ export class DefaultSyncPriorityCalculator implements ISyncPriorityCalculator {
* 支持批处理、优先级排序和性能优化
*/
export class SyncVarSyncScheduler {
private static readonly logger = createLogger('SyncVarSyncScheduler');
private static _instance: SyncVarSyncScheduler | null = null;
private _config: SyncVarSyncConfig;
@@ -130,7 +131,7 @@ export class SyncVarSyncScheduler {
this.start();
}
console.log('[SyncVarSyncScheduler] 调度器配置已更新:', this._config);
SyncVarSyncScheduler.logger.debug('调度器配置已更新:', this._config);
}
/**
@@ -140,7 +141,7 @@ export class SyncVarSyncScheduler {
*/
public setPriorityCalculator(calculator: ISyncPriorityCalculator): void {
this._priorityCalculator = calculator;
console.log('[SyncVarSyncScheduler] 优先级计算器已更新');
SyncVarSyncScheduler.logger.debug('优先级计算器已更新');
}
/**
@@ -150,7 +151,7 @@ export class SyncVarSyncScheduler {
*/
public setMessageSendCallback(callback: (message: SyncVarUpdateMessage) => Promise<void>): void {
this._messageSendCallback = callback;
console.log('[SyncVarSyncScheduler] 消息发送回调已设置');
SyncVarSyncScheduler.logger.debug('消息发送回调已设置');
}
/**
@@ -158,7 +159,7 @@ export class SyncVarSyncScheduler {
*/
public start(): void {
if (this._isRunning) {
console.warn('[SyncVarSyncScheduler] 调度器已经在运行');
SyncVarSyncScheduler.logger.warn('调度器已经在运行');
return;
}
@@ -170,7 +171,7 @@ export class SyncVarSyncScheduler {
this.performSyncCycle();
}, this._config.syncInterval);
console.log(`[SyncVarSyncScheduler] 调度器已启动，同步间隔: ${this._config.syncInterval}ms`);
SyncVarSyncScheduler.logger.info(`调度器已启动，同步间隔: ${this._config.syncInterval}ms`);
}
/**
@@ -188,7 +189,7 @@ export class SyncVarSyncScheduler {
this._syncTimer = null;
}
console.log('[SyncVarSyncScheduler] 调度器已停止');
SyncVarSyncScheduler.logger.info('调度器已停止');
}
/**
@@ -235,7 +236,7 @@ export class SyncVarSyncScheduler {
} catch (error) {
this._stats.errors++;
console.error('[SyncVarSyncScheduler] 同步周期执行失败:', error);
SyncVarSyncScheduler.logger.error('同步周期执行失败:', error);
}
}
@@ -285,7 +286,7 @@ export class SyncVarSyncScheduler {
});
}
} catch (error) {
console.error(`[SyncVarSyncScheduler] 处理网络对象失败: ${identity.networkId}`, error);
SyncVarSyncScheduler.logger.error(`处理网络对象失败: ${identity.networkId}`, error);
}
}
@@ -298,7 +299,7 @@ export class SyncVarSyncScheduler {
private getNetworkComponents(identity: NetworkIdentity): NetworkComponent[] {
const entity = identity.entity;
if (!entity) {
console.warn(`[SyncVarSyncScheduler] NetworkIdentity ${identity.networkId} 缺少Entity引用`);
SyncVarSyncScheduler.logger.warn(`NetworkIdentity ${identity.networkId} 缺少Entity引用`);
return [];
}
@@ -318,7 +319,7 @@ export class SyncVarSyncScheduler {
}
}
} catch (error) {
console.error(`[SyncVarSyncScheduler] 获取网络组件失败 (${identity.networkId}):`, error);
SyncVarSyncScheduler.logger.error(`获取网络组件失败 (${identity.networkId}):`, error);
}
return networkComponents;
@@ -383,7 +384,7 @@ export class SyncVarSyncScheduler {
}
} catch (error) {
console.error(`[SyncVarSyncScheduler] 处理同步候选对象失败: ${candidate.identity.networkId}`, error);
SyncVarSyncScheduler.logger.error(`处理同步候选对象失败: ${candidate.identity.networkId}`, error);
}
}
@@ -398,7 +399,7 @@ export class SyncVarSyncScheduler {
*/
private async sendMessageBatch(messages: SyncVarUpdateMessage[]): Promise<void> {
if (!this._messageSendCallback) {
console.warn('[SyncVarSyncScheduler] 没有设置消息发送回调，消息被丢弃');
SyncVarSyncScheduler.logger.warn('没有设置消息发送回调，消息被丢弃');
return;
}
@@ -407,7 +408,7 @@ export class SyncVarSyncScheduler {
await this._messageSendCallback(message);
this._stats.totalMessagesSent++;
} catch (error) {
console.error('[SyncVarSyncScheduler] 发送SyncVar消息失败:', error);
SyncVarSyncScheduler.logger.error('发送SyncVar消息失败:', error);
this._stats.errors++;
}
}
@@ -458,7 +459,7 @@ export class SyncVarSyncScheduler {
lastCycleTime: 0,
errors: 0
};
console.log('[SyncVarSyncScheduler] 统计信息已重置');
SyncVarSyncScheduler.logger.debug('统计信息已重置');
}
/**

52
packages/network/src/types/global.d.ts vendored
View File

@@ -1,49 +1,11 @@
/**
* 全局宏定义类型声明
*
* 这些宏变量由构建工具在编译时定义，用于条件编译
* 支持在客户端构建时移除服务端代码，在服务端构建时移除客户端代码
* 网络库编译时宏定义
* 这些宏在构建时会被具体的布尔值替换，用于实现客户端/服务端代码的编译时过滤
*/
/**
* 客户端构建标志
*
* 当构建客户端版本时为true，服务端版本时为false
* 使用示例：
* ```typescript
* if (__CLIENT__) {
* // 只在客户端构建中包含的代码
* this.renderUI();
* }
* ```
*/
declare const __CLIENT__: boolean;
declare global {
const __CLIENT__: boolean;
const __SERVER__: boolean;
}
/**
* 服务端构建标志
*
* 当构建服务端版本时为true，客户端版本时为false
* 使用示例：
* ```typescript
* if (__SERVER__) {
* // 只在服务端构建中包含的代码
* this.validateInput();
* this.saveToDatabase();
* }
* ```
*/
declare const __SERVER__: boolean;
/**
* 开发环境标志（可选）
*
* 当在开发环境时为true，生产环境时为false
*/
declare const __DEV__: boolean;
/**
* 生产环境标志（可选）
*
* 当在生产环境时为true，开发环境时为false
*/
declare const __PROD__: boolean;
export {};