优化性能结构/延迟加载
新增测试代码用于测试性能
This commit is contained in:
YHH
@@ -0,0 +1,317 @@
|
||||
import { EntitySystem, Entity, Matcher, Time } from '@esengine/ecs-framework';
|
||||
import { AIComponent, Transform, Health } from '../components';
|
||||
|
||||
/**
|
||||
* AI系统 - 处理AI行为和状态机
|
||||
*/
|
||||
export class AISystem extends EntitySystem {
|
||||
|
||||
/** 系统处理的实体计数器 */
|
||||
private processedEntityCount: number = 0;
|
||||
|
||||
/** 状态转换计数器 */
|
||||
private stateTransitionCount: number = 0;
|
||||
|
||||
constructor() {
|
||||
// 处理具有AI组件的实体
|
||||
super(Matcher.empty().all(AIComponent));
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理所有实体
|
||||
*/
|
||||
protected process(entities: Entity[]): void {
|
||||
const deltaTime = Time.deltaTime;
|
||||
const currentTime = Time.totalTime;
|
||||
|
||||
this.processedEntityCount = entities.length;
|
||||
|
||||
for (const entity of entities) {
|
||||
this.processEntity(entity, deltaTime, currentTime);
|
||||
}
|
||||
|
||||
// 批量处理AI间的交互
|
||||
this.processAIInteractions(entities);
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理单个实体
|
||||
*/
|
||||
private processEntity(entity: Entity, deltaTime: number, currentTime: number): void {
|
||||
const ai = entity.getComponent(AIComponent);
|
||||
const transform = entity.getComponent(Transform);
|
||||
const health = entity.getComponent(Health);
|
||||
|
||||
if (!ai) return;
|
||||
|
||||
// 更新感知系统
|
||||
ai.updatePerception(deltaTime);
|
||||
|
||||
// 处理状态机
|
||||
this.updateStateMachine(ai, deltaTime);
|
||||
|
||||
// 更新行为树
|
||||
this.updateBehaviorTree(ai, deltaTime);
|
||||
|
||||
// 处理AI能力（如果有Transform和Health组件）
|
||||
if (transform && health) {
|
||||
this.updateAICapabilities(ai, transform, health, deltaTime);
|
||||
}
|
||||
|
||||
// 处理记忆衰减
|
||||
this.updateMemory(ai, deltaTime);
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新状态机
|
||||
*/
|
||||
private updateStateMachine(ai: AIComponent, deltaTime: number): void {
|
||||
const currentStateName = ai.currentState;
|
||||
const transitions = ai.stateMachine.transitions.get(currentStateName);
|
||||
|
||||
if (transitions) {
|
||||
// 按优先级排序转换条件
|
||||
const sortedTransitions = transitions.sort((a, b) => b.priority - a.priority);
|
||||
|
||||
for (const transition of sortedTransitions) {
|
||||
if (transition.condition()) {
|
||||
// 执行状态转换
|
||||
const currentState = ai.stateMachine.states.get(currentStateName);
|
||||
const newState = ai.stateMachine.states.get(transition.targetState);
|
||||
|
||||
if (currentState && newState) {
|
||||
currentState.exit();
|
||||
ai.currentState = transition.targetState as any;
|
||||
newState.enter();
|
||||
this.stateTransitionCount++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新行为树
|
||||
*/
|
||||
private updateBehaviorTree(ai: AIComponent, deltaTime: number): void {
|
||||
const behaviorTree = ai.config.behaviorTree;
|
||||
const blackboard = behaviorTree.blackboard;
|
||||
|
||||
// 更新黑板数据
|
||||
blackboard.set('deltaTime', deltaTime);
|
||||
blackboard.set('currentTime', Date.now());
|
||||
|
||||
// 模拟行为树执行
|
||||
const executionResult = this.executeBehaviorNode(behaviorTree.rootNode, ai);
|
||||
|
||||
// 记录执行历史
|
||||
behaviorTree.executionHistory.push({
|
||||
nodeName: behaviorTree.rootNode.name,
|
||||
startTime: Date.now(),
|
||||
endTime: Date.now() + Math.random() * 10,
|
||||
result: executionResult,
|
||||
data: { deltaTime }
|
||||
});
|
||||
|
||||
// 保持历史记录在合理范围内
|
||||
if (behaviorTree.executionHistory.length > 50) {
|
||||
behaviorTree.executionHistory.shift();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 执行行为树节点（模拟）
|
||||
*/
|
||||
private executeBehaviorNode(node: any, ai: AIComponent): 'success' | 'failure' | 'running' {
|
||||
// 简单的行为树执行模拟
|
||||
switch (node.name) {
|
||||
case 'root':
|
||||
case 'selector':
|
||||
// 选择器节点：尝试执行子节点直到一个成功
|
||||
for (const child of node.children) {
|
||||
const result = this.executeBehaviorNode(child, ai);
|
||||
if (result === 'success' || result === 'running') {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return 'failure';
|
||||
|
||||
case 'sequence':
|
||||
// 序列节点：按顺序执行所有子节点
|
||||
for (const child of node.children) {
|
||||
const result = this.executeBehaviorNode(child, ai);
|
||||
if (result === 'failure' || result === 'running') {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return 'success';
|
||||
|
||||
case 'condition':
|
||||
// 条件节点：检查AI状态
|
||||
return ai.config.personality.intelligence > 0.5 ? 'success' : 'failure';
|
||||
|
||||
case 'action':
|
||||
// 动作节点：执行AI行为
|
||||
return Math.random() > 0.3 ? 'success' : 'running';
|
||||
|
||||
default:
|
||||
return 'failure';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新AI能力
|
||||
*/
|
||||
private updateAICapabilities(ai: AIComponent, transform: Transform, health: Health, deltaTime: number): void {
|
||||
const capabilities = ai.config.capabilities;
|
||||
|
||||
// 根据健康状况调整能力
|
||||
const healthRatio = health.currentHealth / health.maxHealth;
|
||||
const effectiveSpeed = capabilities.movementSpeed * healthRatio;
|
||||
|
||||
// 更新移动速度
|
||||
transform.speed = effectiveSpeed;
|
||||
|
||||
// 根据个性调整行为
|
||||
if (ai.config.personality.aggression > 0.7 && healthRatio > 0.5) {
|
||||
// 高攻击性且健康状况良好时更主动
|
||||
ai.currentState = 'chase';
|
||||
} else if (healthRatio < 0.3) {
|
||||
// 生命值低时逃跑
|
||||
ai.currentState = 'flee';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新记忆系统
|
||||
*/
|
||||
private updateMemory(ai: AIComponent, deltaTime: number): void {
|
||||
const memory = ai.config.memory;
|
||||
const currentTime = Date.now();
|
||||
|
||||
// 衰减已知位置的可信度
|
||||
memory.knownLocations.forEach(location => {
|
||||
const timeSinceVisit = currentTime - location.lastVisited;
|
||||
const decayFactor = Math.exp(-timeSinceVisit / 30000); // 30秒衰减率
|
||||
location.confidence *= decayFactor;
|
||||
});
|
||||
|
||||
// 移除可信度过低的位置
|
||||
memory.knownLocations = memory.knownLocations.filter(location => location.confidence > 0.1);
|
||||
|
||||
// 衰减关系信任度
|
||||
memory.relationships.forEach(relation => {
|
||||
const timeSinceInteraction = currentTime - relation.lastInteraction;
|
||||
if (timeSinceInteraction > 60000) { // 60秒没有交互
|
||||
relation.trustLevel *= 0.99; // 缓慢衰减
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理AI间的交互
|
||||
*/
|
||||
private processAIInteractions(entities: Entity[]): void {
|
||||
const aiEntities = entities.filter(e => e.getComponent(AIComponent));
|
||||
|
||||
for (let i = 0; i < aiEntities.length; i++) {
|
||||
for (let j = i + 1; j < aiEntities.length; j++) {
|
||||
this.processAIPair(aiEntities[i], aiEntities[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理两个AI实体间的交互
|
||||
*/
|
||||
private processAIPair(entity1: Entity, entity2: Entity): void {
|
||||
const ai1 = entity1.getComponent(AIComponent);
|
||||
const ai2 = entity2.getComponent(AIComponent);
|
||||
const transform1 = entity1.getComponent(Transform);
|
||||
const transform2 = entity2.getComponent(Transform);
|
||||
|
||||
if (!ai1 || !ai2 || !transform1 || !transform2) return;
|
||||
|
||||
// 计算距离
|
||||
const distance = Math.sqrt(
|
||||
Math.pow(transform1.position.x - transform2.position.x, 2) +
|
||||
Math.pow(transform1.position.y - transform2.position.y, 2)
|
||||
);
|
||||
|
||||
// 视线范围内的交互
|
||||
if (distance <= ai1.config.capabilities.sightRange) {
|
||||
this.handleVisualContact(ai1, ai2, entity1, entity2, distance);
|
||||
}
|
||||
|
||||
// 听力范围内的交互
|
||||
if (distance <= ai1.config.capabilities.hearingRange) {
|
||||
this.handleAudioContact(ai1, ai2, distance);
|
||||
}
|
||||
|
||||
// 创建盟友关系（随机）
|
||||
if (Math.random() < 0.001 && !ai1.allyIds.includes(entity2.id)) { // 0.1%概率每帧
|
||||
ai1.addAlly(entity2.id);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理视觉接触
|
||||
*/
|
||||
private handleVisualContact(ai1: AIComponent, ai2: AIComponent, entity1: Entity, entity2: Entity, distance: number): void {
|
||||
const currentTime = Date.now();
|
||||
|
||||
// 添加到可见实体列表
|
||||
const existingEntry = ai1.perception.visibleEntities.find(e => e.entityId === entity2.id);
|
||||
if (existingEntry) {
|
||||
existingEntry.distance = distance;
|
||||
existingEntry.lastSeen = currentTime;
|
||||
existingEntry.componentId = ai2.id; // 使用组件ID避免循环引用
|
||||
} else {
|
||||
ai1.perception.visibleEntities.push({
|
||||
entityId: entity2.id,
|
||||
position: entity2.getComponent(Transform)!.position.clone(),
|
||||
distance: distance,
|
||||
angle: Math.atan2(
|
||||
entity2.getComponent(Transform)!.position.y - entity1.getComponent(Transform)!.position.y,
|
||||
entity2.getComponent(Transform)!.position.x - entity1.getComponent(Transform)!.position.x
|
||||
),
|
||||
lastSeen: currentTime,
|
||||
componentId: ai2.id
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理音频接触
|
||||
*/
|
||||
private handleAudioContact(ai1: AIComponent, ai2: AIComponent, distance: number): void {
|
||||
const soundVolume = 1.0 - (distance / ai1.config.capabilities.hearingRange);
|
||||
|
||||
ai1.perception.audibleSounds.push({
|
||||
source: ai2.entity.getComponent(Transform)!.position.clone(),
|
||||
volume: soundVolume,
|
||||
type: 'movement',
|
||||
timestamp: Date.now()
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* 系统初始化时调用
|
||||
*/
|
||||
public initialize(): void {
|
||||
super.initialize();
|
||||
console.log('🤖 AI系统已启动');
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取系统统计信息
|
||||
*/
|
||||
public getSystemStats(): any {
|
||||
return {
|
||||
processedEntities: this.processedEntityCount,
|
||||
stateTransitions: this.stateTransitionCount,
|
||||
systemName: 'AISystem'
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
{
|
||||
"ver": "4.0.24",
|
||||
"importer": "typescript",
|
||||
"imported": true,
|
||||
"uuid": "449fa887-eece-424d-ae1d-7082454fac3f",
|
||||
"files": [],
|
||||
"subMetas": {},
|
||||
"userData": {}
|
||||
}
|
||||
@@ -0,0 +1,448 @@
|
||||
import { EntitySystem, Entity, Matcher, Time } from '@esengine/ecs-framework';
|
||||
import { NetworkComponent } from '../components';
|
||||
|
||||
/**
|
||||
* 网络系统 - 处理网络同步和连接管理
|
||||
*/
|
||||
export class NetworkSystem extends EntitySystem {
|
||||
|
||||
/** 网络统计 */
|
||||
private networkStats = {
|
||||
totalEntities: 0,
|
||||
connectedEntities: 0,
|
||||
totalMessagesSent: 0,
|
||||
totalMessagesReceived: 0,
|
||||
averagePing: 0,
|
||||
networkTraffic: 0
|
||||
};
|
||||
|
||||
/** 消息处理队列 */
|
||||
private globalMessageQueue: Array<{
|
||||
from: string;
|
||||
to: string;
|
||||
messageType: string;
|
||||
data: any;
|
||||
timestamp: number;
|
||||
priority: number;
|
||||
}> = [];
|
||||
|
||||
constructor() {
|
||||
// 处理具有网络组件的实体
|
||||
super(Matcher.empty().all(NetworkComponent));
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理所有实体
|
||||
*/
|
||||
protected process(entities: Entity[]): void {
|
||||
const deltaTime = Time.deltaTime;
|
||||
|
||||
this.networkStats.totalEntities = entities.length;
|
||||
this.networkStats.connectedEntities = entities.filter(e =>
|
||||
e.getComponent(NetworkComponent)?.connectionState === 'connected'
|
||||
).length;
|
||||
|
||||
for (const entity of entities) {
|
||||
this.processEntity(entity, deltaTime);
|
||||
}
|
||||
|
||||
// 处理全局消息队列
|
||||
this.processGlobalMessages();
|
||||
|
||||
// 更新网络统计
|
||||
this.updateGlobalNetworkStats(entities);
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理单个实体
|
||||
*/
|
||||
private processEntity(entity: Entity, deltaTime: number): void {
|
||||
const network = entity.getComponent(NetworkComponent);
|
||||
|
||||
if (!network) return;
|
||||
|
||||
// 更新网络统计
|
||||
network.updateNetworkStats(deltaTime);
|
||||
|
||||
// 处理连接状态
|
||||
this.updateConnectionState(network, deltaTime);
|
||||
|
||||
// 处理消息队列
|
||||
this.processEntityMessages(network, entity);
|
||||
|
||||
// 处理数据同步
|
||||
this.processSynchronization(network, deltaTime);
|
||||
|
||||
// 处理群组通信
|
||||
this.processGroupCommunication(network);
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新连接状态
|
||||
*/
|
||||
private updateConnectionState(network: NetworkComponent, deltaTime: number): void {
|
||||
const currentTime = Date.now();
|
||||
|
||||
switch (network.connectionState) {
|
||||
case 'disconnected':
|
||||
// 尝试连接
|
||||
if (network.config.autoReconnect &&
|
||||
network.networkStats.reconnectCount < network.config.maxReconnectAttempts) {
|
||||
network.connectionState = 'connecting';
|
||||
network.connection.lastHeartbeat = currentTime;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'connecting':
|
||||
// 模拟连接过程
|
||||
if (Math.random() > 0.1) { // 90% 成功率
|
||||
network.connectionState = 'connected';
|
||||
network.connection.sessionId = this.generateSessionId();
|
||||
network.connection.serverId = 'server_001';
|
||||
network.connection.lastHeartbeat = currentTime;
|
||||
} else if (currentTime - network.connection.lastHeartbeat > 5000) {
|
||||
// 连接超时
|
||||
network.connectionState = 'error';
|
||||
network.networkStats.errorCount++;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'connected':
|
||||
// 维持连接心跳
|
||||
if (currentTime - network.connection.lastHeartbeat > network.config.heartbeatInterval) {
|
||||
this.sendHeartbeat(network);
|
||||
network.connection.lastHeartbeat = currentTime;
|
||||
}
|
||||
|
||||
// 模拟网络质量变化
|
||||
network.connection.ping = Math.random() * 100 + 20; // 20-120ms
|
||||
network.connection.packetLoss = Math.random() * 0.05; // 0-5%
|
||||
network.connection.bandwidth = 1000 + Math.random() * 500; // 1000-1500 Kbps
|
||||
break;
|
||||
|
||||
case 'error':
|
||||
// 错误状态，尝试重连
|
||||
if (network.config.autoReconnect &&
|
||||
network.networkStats.reconnectCount < network.config.maxReconnectAttempts) {
|
||||
network.connectionState = 'disconnected';
|
||||
network.networkStats.reconnectCount++;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理实体消息
|
||||
*/
|
||||
private processEntityMessages(network: NetworkComponent, entity: Entity): void {
|
||||
// 处理传出消息
|
||||
const outgoingMessages = network.messageQueue.outgoing.slice();
|
||||
network.messageQueue.outgoing = [];
|
||||
|
||||
for (const message of outgoingMessages) {
|
||||
if (this.sendMessage(network, message)) {
|
||||
this.networkStats.totalMessagesSent++;
|
||||
network.networkStats.totalBytesSent += this.estimateMessageSize(message);
|
||||
} else {
|
||||
// 发送失败，重新加入队列
|
||||
message.attempts++;
|
||||
if (message.attempts < message.maxAttempts) {
|
||||
network.messageQueue.outgoing.push(message);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 处理传入消息
|
||||
this.processIncomingMessages(network, entity);
|
||||
}
|
||||
|
||||
/**
|
||||
* 发送消息
|
||||
*/
|
||||
private sendMessage(network: NetworkComponent, message: any): boolean {
|
||||
if (network.connectionState !== 'connected') {
|
||||
return false;
|
||||
}
|
||||
|
||||
// 模拟网络延迟和丢包
|
||||
const shouldDelay = Math.random() < 0.3; // 30% 概率有延迟
|
||||
const shouldDrop = Math.random() < network.connection.packetLoss;
|
||||
|
||||
if (shouldDrop) {
|
||||
network.networkStats.errorCount++;
|
||||
return false;
|
||||
}
|
||||
|
||||
// 添加到全局消息队列
|
||||
this.globalMessageQueue.push({
|
||||
from: network.networkId,
|
||||
to: message.targetId,
|
||||
messageType: message.messageType,
|
||||
data: message.data,
|
||||
timestamp: Date.now() + (shouldDelay ? Math.random() * 200 : 0),
|
||||
priority: message.priority
|
||||
});
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理传入消息
|
||||
*/
|
||||
private processIncomingMessages(network: NetworkComponent, entity: Entity): void {
|
||||
// 从全局队列中获取发给此实体的消息
|
||||
const incomingMessages = this.globalMessageQueue.filter(msg =>
|
||||
msg.to === network.networkId && msg.timestamp <= Date.now()
|
||||
);
|
||||
|
||||
// 从全局队列中移除这些消息
|
||||
this.globalMessageQueue = this.globalMessageQueue.filter(msg =>
|
||||
!(msg.to === network.networkId && msg.timestamp <= Date.now())
|
||||
);
|
||||
|
||||
// 处理消息
|
||||
for (const message of incomingMessages) {
|
||||
network.messageQueue.incoming.push({
|
||||
senderId: message.from,
|
||||
messageType: message.messageType,
|
||||
data: message.data,
|
||||
timestamp: message.timestamp,
|
||||
processed: false
|
||||
});
|
||||
|
||||
this.networkStats.totalMessagesReceived++;
|
||||
network.networkStats.totalBytesReceived += this.estimateMessageSize(message);
|
||||
|
||||
// 立即处理某些类型的消息
|
||||
this.handleSpecialMessages(network, message);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理特殊消息类型
|
||||
*/
|
||||
private handleSpecialMessages(network: NetworkComponent, message: any): void {
|
||||
switch (message.messageType) {
|
||||
case 'player_join_group':
|
||||
// 处理加入群组消息
|
||||
const groupData = message.data;
|
||||
if (groupData.members && Array.isArray(groupData.members)) {
|
||||
// 查找对应的网络组件并建立连接
|
||||
groupData.members.forEach((memberId: string) => {
|
||||
// 直接使用成员ID建立连接
|
||||
network.connectToPlayer(memberId);
|
||||
});
|
||||
}
|
||||
break;
|
||||
|
||||
case 'heartbeat':
|
||||
// 心跳响应
|
||||
network.connection.ping = Date.now() - message.data.timestamp;
|
||||
break;
|
||||
|
||||
case 'sync_request':
|
||||
// 同步请求
|
||||
this.handleSyncRequest(network, message);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理数据同步
|
||||
*/
|
||||
private processSynchronization(network: NetworkComponent, deltaTime: number): void {
|
||||
const currentTime = Date.now();
|
||||
const syncInterval = 1000 / network.config.syncFrequency; // 转换为毫秒
|
||||
|
||||
if (currentTime - network.syncData.lastSyncTime >= syncInterval) {
|
||||
this.performSynchronization(network);
|
||||
network.syncData.lastSyncTime = currentTime;
|
||||
}
|
||||
|
||||
// 处理排队的更新
|
||||
this.processQueuedUpdates(network);
|
||||
}
|
||||
|
||||
/**
|
||||
* 执行同步
|
||||
*/
|
||||
private performSynchronization(network: NetworkComponent): void {
|
||||
if (network.syncData.dirtyFlags.size === 0) {
|
||||
return; // 没有需要同步的数据
|
||||
}
|
||||
|
||||
const syncData = {
|
||||
networkId: network.networkId,
|
||||
timestamp: Date.now(),
|
||||
properties: Array.from(network.syncData.dirtyFlags),
|
||||
checksum: this.calculateChecksum(network)
|
||||
};
|
||||
|
||||
// 发送同步数据给连接的玩家
|
||||
network.connectedPlayerIds.forEach(playerId => {
|
||||
network.sendMessage(playerId, 'sync_data', syncData, 7);
|
||||
});
|
||||
|
||||
// 记录同步历史
|
||||
network.syncData.syncHistory.push({
|
||||
timestamp: syncData.timestamp,
|
||||
dataSize: this.estimateMessageSize(syncData),
|
||||
properties: syncData.properties,
|
||||
success: true
|
||||
});
|
||||
|
||||
// 清理脏标记
|
||||
network.syncData.dirtyFlags.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理排队的更新
|
||||
*/
|
||||
private processQueuedUpdates(network: NetworkComponent): void {
|
||||
// 按优先级和时间戳排序
|
||||
network.syncData.queuedUpdates.sort((a, b) => {
|
||||
if (a.priority !== b.priority) {
|
||||
return b.priority - a.priority; // 高优先级优先
|
||||
}
|
||||
return a.timestamp - b.timestamp; // 时间戳早的优先
|
||||
});
|
||||
|
||||
// 处理前10个更新
|
||||
const updatesToProcess = network.syncData.queuedUpdates.splice(0, 10);
|
||||
for (const update of updatesToProcess) {
|
||||
network.markDirty(update.property);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理群组通信
|
||||
*/
|
||||
private processGroupCommunication(network: NetworkComponent): void {
|
||||
if (network.groupMemberIds.length === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
// 群组消息广播
|
||||
if (Math.random() < 0.01) { // 1% 概率发送群组消息
|
||||
const groupMessage = {
|
||||
type: 'group_update',
|
||||
data: {
|
||||
sender: network.networkId,
|
||||
timestamp: Date.now(),
|
||||
groupSize: network.groupMemberIds.length,
|
||||
status: network.connectionState
|
||||
}
|
||||
};
|
||||
|
||||
network.groupMemberIds.forEach(memberId => {
|
||||
if (memberId !== network.networkId) {
|
||||
network.sendMessage(memberId, 'group_message', groupMessage, 5);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理全局消息
|
||||
*/
|
||||
private processGlobalMessages(): void {
|
||||
// 移除过期消息
|
||||
const currentTime = Date.now();
|
||||
this.globalMessageQueue = this.globalMessageQueue.filter(msg =>
|
||||
currentTime - msg.timestamp < 30000 // 30秒过期
|
||||
);
|
||||
|
||||
// 按优先级排序
|
||||
this.globalMessageQueue.sort((a, b) => b.priority - a.priority);
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新全局网络统计
|
||||
*/
|
||||
private updateGlobalNetworkStats(entities: Entity[]): void {
|
||||
let totalPing = 0;
|
||||
let connectedCount = 0;
|
||||
let totalTraffic = 0;
|
||||
|
||||
for (const entity of entities) {
|
||||
const network = entity.getComponent(NetworkComponent);
|
||||
if (network && network.connectionState === 'connected') {
|
||||
totalPing += network.connection.ping;
|
||||
connectedCount++;
|
||||
totalTraffic += network.networkStats.totalBytesSent + network.networkStats.totalBytesReceived;
|
||||
}
|
||||
}
|
||||
|
||||
this.networkStats.averagePing = connectedCount > 0 ? totalPing / connectedCount : 0;
|
||||
this.networkStats.networkTraffic = totalTraffic;
|
||||
}
|
||||
|
||||
/**
|
||||
* 辅助方法
|
||||
*/
|
||||
private generateSessionId(): string {
|
||||
return 'session_' + Math.random().toString(36).substring(2, 15);
|
||||
}
|
||||
|
||||
private estimateMessageSize(message: any): number {
|
||||
return JSON.stringify(message).length;
|
||||
}
|
||||
|
||||
private calculateChecksum(network: NetworkComponent): string {
|
||||
// 简单的校验和计算
|
||||
const data = JSON.stringify({
|
||||
networkId: network.networkId,
|
||||
connectionState: network.connectionState
|
||||
});
|
||||
return btoa(data).substring(0, 8);
|
||||
}
|
||||
|
||||
private sendHeartbeat(network: NetworkComponent): void {
|
||||
network.sendMessage('server', 'heartbeat', { timestamp: Date.now() }, 10);
|
||||
}
|
||||
|
||||
private findNetworkComponentById(networkId: string): NetworkComponent | null {
|
||||
// 这里应该有一个全局的网络组件注册表
|
||||
// 为了简化，我们返回null
|
||||
return null;
|
||||
}
|
||||
|
||||
private handleSyncRequest(network: NetworkComponent, message: any): void {
|
||||
// 处理同步请求
|
||||
const response = {
|
||||
requestId: message.data.requestId,
|
||||
data: this.gatherSyncData(network),
|
||||
timestamp: Date.now()
|
||||
};
|
||||
|
||||
network.sendMessage(message.from, 'sync_response', response, 8);
|
||||
}
|
||||
|
||||
private gatherSyncData(network: NetworkComponent): any {
|
||||
return {
|
||||
networkId: network.networkId,
|
||||
connectionState: network.connectionState,
|
||||
ping: network.connection.ping,
|
||||
groupSize: network.groupMemberIds.length
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* 系统初始化时调用
|
||||
*/
|
||||
public initialize(): void {
|
||||
super.initialize();
|
||||
console.log('🌐 网络系统已启动');
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取系统统计信息
|
||||
*/
|
||||
public getSystemStats(): any {
|
||||
return {
|
||||
...this.networkStats,
|
||||
globalMessageQueueSize: this.globalMessageQueue.length,
|
||||
systemName: 'NetworkSystem'
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
{
|
||||
"ver": "4.0.24",
|
||||
"importer": "typescript",
|
||||
"imported": true,
|
||||
"uuid": "09cb67c9-12ef-48e0-949d-c8edf2c7ae22",
|
||||
"files": [],
|
||||
"subMetas": {},
|
||||
"userData": {}
|
||||
}
|
||||
@@ -0,0 +1,475 @@
|
||||
import { EntitySystem, Entity, Matcher, Time } from '@esengine/ecs-framework';
|
||||
import { NodeComponent, Transform, Renderer } from '../components';
|
||||
import { Node, Vec3, Color } from 'cc';
|
||||
|
||||
/**
|
||||
* 节点渲染系统 - 处理NodeComponent和Cocos Creator节点的同步
|
||||
*/
|
||||
export class NodeRenderSystem extends EntitySystem {
|
||||
|
||||
/** 渲染统计 */
|
||||
private renderStats = {
|
||||
totalNodes: 0,
|
||||
visibleNodes: 0,
|
||||
renderCalls: 0,
|
||||
averageRenderTime: 0,
|
||||
totalRenderTime: 0,
|
||||
frameCount: 0
|
||||
};
|
||||
|
||||
/** 节点池 */
|
||||
private nodePool: Node[] = [];
|
||||
|
||||
/** 性能监控 */
|
||||
private performanceMonitor = {
|
||||
frameStartTime: 0,
|
||||
renderTimeHistory: [] as number[],
|
||||
cullCount: 0,
|
||||
frustumCullCount: 0
|
||||
};
|
||||
|
||||
constructor() {
|
||||
// 处理具有NodeComponent的实体
|
||||
super(Matcher.empty().all(NodeComponent));
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理所有实体
|
||||
*/
|
||||
protected process(entities: Entity[]): void {
|
||||
this.performanceMonitor.frameStartTime = performance.now();
|
||||
|
||||
this.renderStats.totalNodes = entities.length;
|
||||
this.renderStats.visibleNodes = 0;
|
||||
this.renderStats.renderCalls = 0;
|
||||
|
||||
for (const entity of entities) {
|
||||
this.processEntity(entity);
|
||||
}
|
||||
|
||||
// 处理节点层次结构
|
||||
this.updateNodeHierarchy(entities);
|
||||
|
||||
// 更新性能统计
|
||||
this.updatePerformanceStats();
|
||||
|
||||
// 清理过期的性能缓存
|
||||
this.cleanupPerformanceCache(entities);
|
||||
}
|
||||
|
||||
/**
|
||||
* 处理单个实体
|
||||
*/
|
||||
private processEntity(entity: Entity): void {
|
||||
const nodeComponent = entity.getComponent(NodeComponent);
|
||||
const transform = entity.getComponent(Transform);
|
||||
const renderer = entity.getComponent(Renderer);
|
||||
|
||||
if (!nodeComponent) return;
|
||||
|
||||
const renderStartTime = performance.now();
|
||||
|
||||
// 确保有对应的Cocos Creator节点
|
||||
this.ensureNode(nodeComponent, entity);
|
||||
|
||||
// 同步Transform数据
|
||||
if (transform && nodeComponent.node) {
|
||||
this.syncTransform(nodeComponent, transform);
|
||||
}
|
||||
|
||||
// 同步渲染数据
|
||||
if (renderer && nodeComponent.node) {
|
||||
this.syncRenderer(nodeComponent, renderer);
|
||||
}
|
||||
|
||||
// 更新节点配置
|
||||
this.updateNodeConfig(nodeComponent);
|
||||
|
||||
// 执行视锥体剔除
|
||||
const isVisible = this.performCulling(nodeComponent);
|
||||
if (isVisible) {
|
||||
this.renderStats.visibleNodes++;
|
||||
this.performRender(nodeComponent);
|
||||
}
|
||||
|
||||
// 更新性能统计
|
||||
const renderTime = performance.now() - renderStartTime;
|
||||
nodeComponent.updatePerformance(renderTime);
|
||||
|
||||
this.renderStats.renderCalls++;
|
||||
this.renderStats.totalRenderTime += renderTime;
|
||||
}
|
||||
|
||||
/**
|
||||
* 确保节点存在
|
||||
*/
|
||||
private ensureNode(nodeComponent: NodeComponent, entity: Entity): void {
|
||||
if (!nodeComponent.node) {
|
||||
// 从对象池中获取节点或创建新节点
|
||||
nodeComponent.node = this.getNodeFromPool() || new Node(nodeComponent.nodeConfig.name);
|
||||
|
||||
// 初始化节点
|
||||
this.initializeNode(nodeComponent.node, nodeComponent, entity);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 从对象池获取节点
|
||||
*/
|
||||
private getNodeFromPool(): Node | null {
|
||||
return this.nodePool.pop() || null;
|
||||
}
|
||||
|
||||
/**
|
||||
* 初始化节点
|
||||
*/
|
||||
private initializeNode(node: Node, nodeComponent: NodeComponent, entity: Entity): void {
|
||||
const config = nodeComponent.nodeConfig;
|
||||
|
||||
// 设置基本属性
|
||||
node.name = config.name;
|
||||
node.layer = config.layer;
|
||||
node.active = config.renderData.visible;
|
||||
|
||||
// 设置变换
|
||||
node.setPosition(config.transformData.position);
|
||||
node.setRotationFromEuler(config.transformData.rotation);
|
||||
node.setScale(config.transformData.scale);
|
||||
|
||||
// 设置渲染属性
|
||||
const opacity = Math.floor(config.renderData.opacity * 255);
|
||||
// 这里可以设置更多Cocos Creator特定的属性
|
||||
|
||||
// 添加用户数据
|
||||
config.userData.entityId = entity.id;
|
||||
config.userData.componentId = nodeComponent.id;
|
||||
}
|
||||
|
||||
/**
|
||||
* 同步Transform数据
|
||||
*/
|
||||
private syncTransform(nodeComponent: NodeComponent, transform: Transform): void {
|
||||
const node = nodeComponent.node!;
|
||||
const config = nodeComponent.nodeConfig;
|
||||
|
||||
// 更新配置中的变换数据
|
||||
config.transformData.position.set(transform.position);
|
||||
config.transformData.rotation.set(transform.rotation);
|
||||
config.transformData.scale.set(transform.scale);
|
||||
|
||||
// 同步到Cocos Creator节点
|
||||
node.setPosition(transform.position);
|
||||
node.setRotationFromEuler(transform.rotation);
|
||||
node.setScale(transform.scale);
|
||||
|
||||
// 更新缓存数据
|
||||
nodeComponent.complexData.cache.textureCache.set('lastPosition', transform.position.clone());
|
||||
}
|
||||
|
||||
/**
|
||||
* 同步渲染数据
|
||||
*/
|
||||
private syncRenderer(nodeComponent: NodeComponent, renderer: Renderer): void {
|
||||
const node = nodeComponent.node!;
|
||||
const config = nodeComponent.nodeConfig;
|
||||
|
||||
// 更新配置中的渲染数据
|
||||
config.renderData.color.set(renderer.color);
|
||||
config.renderData.opacity = renderer.alpha;
|
||||
config.renderData.visible = renderer.visible && renderer.alpha > 0;
|
||||
|
||||
// 同步到Cocos Creator节点
|
||||
node.active = config.renderData.visible;
|
||||
|
||||
// 更新材质缓存
|
||||
nodeComponent.complexData.cache.materialCache.set('currentColor', renderer.color.clone());
|
||||
nodeComponent.complexData.cache.materialCache.set('alpha', renderer.alpha);
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新节点配置
|
||||
*/
|
||||
private updateNodeConfig(nodeComponent: NodeComponent): void {
|
||||
const config = nodeComponent.nodeConfig;
|
||||
const currentTime = Date.now();
|
||||
|
||||
// 更新统计信息
|
||||
nodeComponent.complexData.statistics.frameCount++;
|
||||
nodeComponent.complexData.statistics.lastUpdateTime = currentTime;
|
||||
|
||||
// 更新用户数据
|
||||
config.userData.lastFrameUpdate = currentTime;
|
||||
config.userData.frameCount = nodeComponent.complexData.statistics.frameCount;
|
||||
|
||||
// 动态调整配置
|
||||
if (Math.random() < 0.01) { // 1% 概率调整
|
||||
config.renderData.opacity *= (0.95 + Math.random() * 0.1); // 轻微透明度变化
|
||||
config.renderData.opacity = Math.max(0.1, Math.min(1.0, config.renderData.opacity));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 执行视锥体剔除
|
||||
*/
|
||||
private performCulling(nodeComponent: NodeComponent): boolean {
|
||||
if (!nodeComponent.node) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const config = nodeComponent.nodeConfig;
|
||||
|
||||
// 简单的可见性检查
|
||||
if (!config.renderData.visible || config.renderData.opacity <= 0) {
|
||||
this.performanceMonitor.cullCount++;
|
||||
return false;
|
||||
}
|
||||
|
||||
// 距离剔除
|
||||
const position = config.transformData.position;
|
||||
const distance = position.length();
|
||||
if (distance > 1000) { // 超过1000单位距离的对象被剔除
|
||||
this.performanceMonitor.frustumCullCount++;
|
||||
return false;
|
||||
}
|
||||
|
||||
// 层级剔除
|
||||
if (config.layer < 0) {
|
||||
this.performanceMonitor.cullCount++;
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* 执行渲染
|
||||
*/
|
||||
private performRender(nodeComponent: NodeComponent): void {
|
||||
if (!nodeComponent.node) return;
|
||||
|
||||
const renderStartTime = performance.now();
|
||||
|
||||
// 模拟复杂的渲染过程
|
||||
this.simulateRenderingWork(nodeComponent);
|
||||
|
||||
// 更新子节点
|
||||
this.updateChildNodes(nodeComponent);
|
||||
|
||||
// 更新着色器缓存
|
||||
this.updateShaderCache(nodeComponent);
|
||||
|
||||
const renderTime = performance.now() - renderStartTime;
|
||||
|
||||
// 更新性能统计
|
||||
const perf = nodeComponent.complexData.statistics.performance;
|
||||
perf.renderHistory.push(renderTime);
|
||||
|
||||
if (perf.renderHistory.length > 100) {
|
||||
perf.renderHistory.shift();
|
||||
}
|
||||
|
||||
perf.avgRenderTime = perf.renderHistory.reduce((a, b) => a + b, 0) / perf.renderHistory.length;
|
||||
perf.maxRenderTime = Math.max(perf.maxRenderTime, renderTime);
|
||||
}
|
||||
|
||||
/**
|
||||
* 模拟渲染工作
|
||||
*/
|
||||
private simulateRenderingWork(nodeComponent: NodeComponent): void {
|
||||
const complexity = nodeComponent.complexData.cache.materialCache.size +
|
||||
nodeComponent.complexData.cache.textureCache.size;
|
||||
|
||||
// 模拟基于复杂度的计算工作
|
||||
let iterations = Math.min(complexity * 10, 1000);
|
||||
let result = 0;
|
||||
for (let i = 0; i < iterations; i++) {
|
||||
result += Math.sin(i * 0.001) * Math.cos(i * 0.002);
|
||||
}
|
||||
|
||||
// 存储计算结果到缓存
|
||||
nodeComponent.complexData.cache.shaderCache.set('computeResult', result);
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新子节点
|
||||
*/
|
||||
private updateChildNodes(nodeComponent: NodeComponent): void {
|
||||
if (nodeComponent.children.length === 0) return;
|
||||
|
||||
const parentNode = nodeComponent.node!;
|
||||
|
||||
// 同步子节点
|
||||
for (let i = 0; i < nodeComponent.children.length; i++) {
|
||||
const childNode = nodeComponent.children[i];
|
||||
if (childNode && childNode.parent !== parentNode) {
|
||||
parentNode.addChild(childNode);
|
||||
}
|
||||
}
|
||||
|
||||
// 更新层次结构数据
|
||||
nodeComponent.complexData.hierarchy.siblingIndex = parentNode.getSiblingIndex();
|
||||
|
||||
// 更新子组件的层次深度（需要通过实体管理器查找）
|
||||
// 这里省略了复杂的查找逻辑，避免循环引用
|
||||
if (nodeComponent.nodeConfig.childIds.length > 0) {
|
||||
// 实际项目中应该通过实体管理器查找子实体并更新深度
|
||||
// 为了示例简化，我们只更新自己的深度
|
||||
nodeComponent.complexData.hierarchy.depth = Math.max(0, nodeComponent.complexData.hierarchy.depth);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新着色器缓存
|
||||
*/
|
||||
private updateShaderCache(nodeComponent: NodeComponent): void {
|
||||
const shaderCache = nodeComponent.complexData.cache.shaderCache;
|
||||
|
||||
// 模拟着色器参数更新
|
||||
const currentTime = Date.now();
|
||||
shaderCache.set('time', currentTime);
|
||||
shaderCache.set('frameCount', nodeComponent.complexData.statistics.frameCount);
|
||||
|
||||
// 清理过期的着色器缓存
|
||||
if (shaderCache.size > 50) {
|
||||
const keys = Array.from(shaderCache.keys());
|
||||
const oldestKey = keys[0];
|
||||
shaderCache.delete(oldestKey);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新节点层次结构
|
||||
*/
|
||||
private updateNodeHierarchy(entities: Entity[]): void {
|
||||
// 构建层次结构映射
|
||||
const nodeMap = new Map<number, NodeComponent>();
|
||||
|
||||
entities.forEach(entity => {
|
||||
const nodeComponent = entity.getComponent(NodeComponent);
|
||||
if (nodeComponent) {
|
||||
nodeMap.set(entity.id, nodeComponent);
|
||||
}
|
||||
});
|
||||
|
||||
// 更新层次关系（使用ID避免循环引用）
|
||||
nodeMap.forEach((nodeComponent, entityId) => {
|
||||
// 更新根节点ID
|
||||
if (!nodeComponent.complexData.hierarchy.parentId) {
|
||||
nodeComponent.complexData.hierarchy.rootId = entityId;
|
||||
} else {
|
||||
// 查找根节点ID（简化版本，避免深度遍历）
|
||||
let currentParentId = nodeComponent.complexData.hierarchy.parentId;
|
||||
let depth = 0;
|
||||
|
||||
// 限制深度以避免无限循环
|
||||
while (currentParentId && depth < 10) {
|
||||
const parentNode = nodeMap.get(currentParentId);
|
||||
if (parentNode && parentNode.complexData.hierarchy.parentId) {
|
||||
currentParentId = parentNode.complexData.hierarchy.parentId;
|
||||
depth++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
nodeComponent.complexData.hierarchy.rootId = currentParentId || entityId;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* 更新性能统计
|
||||
*/
|
||||
private updatePerformanceStats(): void {
|
||||
const frameTime = performance.now() - this.performanceMonitor.frameStartTime;
|
||||
|
||||
this.performanceMonitor.renderTimeHistory.push(frameTime);
|
||||
if (this.performanceMonitor.renderTimeHistory.length > 60) {
|
||||
this.performanceMonitor.renderTimeHistory.shift();
|
||||
}
|
||||
|
||||
this.renderStats.frameCount++;
|
||||
if (this.renderStats.renderCalls > 0) {
|
||||
this.renderStats.averageRenderTime = this.renderStats.totalRenderTime / this.renderStats.renderCalls;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 清理性能缓存
|
||||
*/
|
||||
private cleanupPerformanceCache(entities: Entity[]): void {
|
||||
entities.forEach(entity => {
|
||||
const nodeComponent = entity.getComponent(NodeComponent);
|
||||
if (nodeComponent) {
|
||||
const caches = nodeComponent.complexData.cache;
|
||||
|
||||
// 清理纹理缓存
|
||||
if (caches.textureCache.size > 100) {
|
||||
const keys = Array.from(caches.textureCache.keys());
|
||||
const toDelete = keys.slice(0, 20); // 删除最旧的20个
|
||||
toDelete.forEach(key => caches.textureCache.delete(key));
|
||||
}
|
||||
|
||||
// 清理材质缓存
|
||||
if (caches.materialCache.size > 50) {
|
||||
const keys = Array.from(caches.materialCache.keys());
|
||||
const toDelete = keys.slice(0, 10); // 删除最旧的10个
|
||||
toDelete.forEach(key => caches.materialCache.delete(key));
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* 回收节点到对象池
|
||||
*/
|
||||
public recycleNode(node: Node): void {
|
||||
if (this.nodePool.length < 100) { // 限制对象池大小
|
||||
node.removeFromParent();
|
||||
node.destroyAllChildren();
|
||||
this.nodePool.push(node);
|
||||
} else {
|
||||
node.destroy();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 系统初始化时调用
|
||||
*/
|
||||
public initialize(): void {
|
||||
super.initialize();
|
||||
console.log('🎨 节点渲染系统已启动');
|
||||
|
||||
// 预热对象池
|
||||
for (let i = 0; i < 10; i++) {
|
||||
this.nodePool.push(new Node(`PooledNode_${i}`));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 当实体被移除时
|
||||
*/
|
||||
protected onRemoved(entity: Entity): void {
|
||||
const nodeComponent = entity.getComponent(NodeComponent);
|
||||
if (nodeComponent && nodeComponent.node) {
|
||||
this.recycleNode(nodeComponent.node);
|
||||
nodeComponent.node = null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 获取系统统计信息
|
||||
*/
|
||||
public getSystemStats(): any {
|
||||
return {
|
||||
...this.renderStats,
|
||||
cullCount: this.performanceMonitor.cullCount,
|
||||
frustumCullCount: this.performanceMonitor.frustumCullCount,
|
||||
nodePoolSize: this.nodePool.length,
|
||||
averageFrameTime: this.performanceMonitor.renderTimeHistory.length > 0
|
||||
? this.performanceMonitor.renderTimeHistory.reduce((a, b) => a + b, 0) / this.performanceMonitor.renderTimeHistory.length
|
||||
: 0,
|
||||
systemName: 'NodeRenderSystem'
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
{
|
||||
"ver": "4.0.24",
|
||||
"importer": "typescript",
|
||||
"imported": true,
|
||||
"uuid": "b4593488-685b-4e52-800b-b2a2990305d6",
|
||||
"files": [],
|
||||
"subMetas": {},
|
||||
"userData": {}
|
||||
}
|
||||
@@ -1,4 +1,7 @@
|
||||
// 导出所有系统
|
||||
export { MovementSystem } from './MovementSystem';
|
||||
export { HealthSystem } from './HealthSystem';
|
||||
export { RandomMovementSystem } from './RandomMovementSystem';
|
||||
export { RandomMovementSystem } from './RandomMovementSystem';
|
||||
export { AISystem } from './AISystem';
|
||||
export { NetworkSystem } from './NetworkSystem';
|
||||
export { NodeRenderSystem } from './NodeRenderSystem';
|
||||
Reference in New Issue
Block a user