Cocos Creator事件系统深度设计与实现：构建高效游戏通信机制

monkeyhlf

于 2025-03-06 22:46:15 发布

阅读量298

点赞数 4

文章标签：游戏

本文链接：https://blog.youkuaiyun.com/xcvmonkey/article/details/146082102

版权

一、为什么需要自定义事件系统？

1.原生事件系统的局限

缺乏全局事件总线
不支持事件优先级
缺少异步事件处理
类型安全缺失

2.游戏开发痛点

graph LR
A[UI交互] --> B[角色控制]
C[游戏状态] --> D[音效系统]
E[资源加载] --> F[场景切换]

二、核心设计目标

特性	实现方案	优势
全局访问	单例模式	跨场景通信
性能优化	事件池	减少GC压力
类型安全	TypeScript接口	开发时校验
生命周期	自动解绑	防止内存泄漏

三、基础架构设计

3.1 类关系图

class EventSystem {
    - _instance: EventSystem
    + getInstance(): EventSystem
    + on(event: string, callback: Function, context?: any, priority?: number): void
    + once(event: string, callback: Function, context?: any): void
    + off(event: string, callback?: Function, context?: any): void
    + emit(event: string, ...args: any[]): Promise<void>
}

class EventNode extends cc.Component {
    + registerEvent(event: string, callback: Function): void
    + unregisterAllEvents(): void
}

3.2 执行流程

sequenceDiagram
    participant A as 发送者
    participant ES as EventSystem
    participant B as 监听者
    
    A->>ES: emit('PLAYER_HURT', damage)
    ES->>ES: 查找事件队列
    ES->>B: 执行回调1(damage)
    ES->>B: 执行回调2(damage)

四、核心实现代码

4.1 事件系统基类

type EventHandler = {
    callback: Function;
    context: any;
    priority: number;
    once: boolean;
};

export default class EventSystem {
    private static _instance: EventSystem;
    private _eventPool = new cc.NodePool();
    private _handlers = new Map<string, EventHandler[]>();
    
    public static getInstance(): EventSystem {
        if (!this._instance) {
            this._instance = new EventSystem();
        }
        return this._instance;
    }

    public on(event: string, callback: Function, 
             context?: any, priority: number = 0): void {
        // 实现注册逻辑
    }

    public async emit(event: string, ...args: any[]): Promise<void> {
        const handlers = this._handlers.get(event) || [];
        const results = [];
        
        // 按优先级排序
        handlers.sort((a, b) => b.priority - a.priority);
        
        for (const handler of handlers) {
            try {
                const result = handler.callback.call(handler.context, ...args);
                if (result instanceof Promise) {
                    results.push(result);
                }
            } catch (e) {
                console.error(`Event ${event} handler error:`, e);
            }
            
            if (handler.once) {
                this.off(event, handler.callback, handler.context);
            }
        }
        
        await Promise.all(results);
    }
}

4.2 自动绑定组件

const {ccclass, property} = cc._decorator;

@ccclass
export class EventNode extends cc.Component {
    private _eventBindings = new Map<string, Function>();
    
    onDestroy() {
        this.unregisterAllEvents();
    }

    public registerEvent(event: string, callback: Function): void {
        const handler = (...args: any[]) => {
            if (this.isValid) callback(...args);
        };
        
        EventSystem.getInstance().on(event, handler, this);
        this._eventBindings.set(event, handler);
    }

    public unregisterAllEvents(): void {
        this._eventBindings.forEach((handler, event) => {
            EventSystem.getInstance().off(event, handler, this);
        });
        this._eventBindings.clear();
    }
}

五、高级功能实现

5.1 事件优先级控制

// 定义优先级枚举
export enum EventPriority {
    HIGHEST = 100,
    HIGH = 75,
    NORMAL = 50,
    LOW = 25,
    LOWEST = 0
}

// 使用示例
EventSystem.getInstance().on(
    'GAME_OVER', 
    this.showResultUI, 
    this, 
    EventPriority.HIGHEST
);

5.2 异步事件处理

// 发送端
await EventSystem.getInstance().emit(
    'SAVE_GAME_DATA', 
    playerData, 
    settings
);

// 监听端
this.registerEvent('SAVE_GAME_DATA', async (data, settings) => {
    await this.validateData(data);
    await this.uploadToServer();
    this.localCache.save(data);
});

5.3 事件拦截机制

public emit(event: string, ...args: any[]): Promise<void> {
    const cancelToken = { isCancelled: false };
    
    // 预发射阶段
    this.emit(`pre:${event}`, cancelToken, ...args);
    if (cancelToken.isCancelled) return;

    // 主事件处理
    return this._emitMain(event, args);
}

六、性能优化方案

6.1 内存管理策略

// 对象池实现
private _getHandler(): EventHandler {
    return this._eventPool.size() > 0 
        ? this._eventPool.get() 
        : { callback: null, context: null, priority: 0, once: false };
}

private _putHandler(handler: EventHandler): void {
    handler.callback = null;
    handler.context = null;
    this._eventPool.put(handler);
}

6.2 事件分析工具

// 调试模式开关
const DEBUG_MODE = true;

class EventSystem {
    private _logEvent(event: string, type: 'emit' | 'handle') {
        if (!DEBUG_MODE) return;
        
        const stack = new Error().stack.split('\n').slice(3).join('\n');
        cc.log(`[EventTrace] ${type}: ${event}\n${stack}`);
    }
}

七、应用实例

7.1 UI系统通信

// 商店购买流程
this.registerEvent('ITEM_PURCHASE', (itemId) => {
    this.playSound(SoundType.COIN);
    this.updatePlayerGold(-itemPrice);
    this.showParticleEffect(itemId);
});

// 触发购买
EventSystem.getInstance().emit('ITEM_PURCHASE', selectedItem.id);

7.2 游戏状态同步

// 战斗系统事件流
sequenceDiagram
    participant A as 角色攻击
    participant B as 伤害计算
    participant C as UI更新
    
    A->>B: emit('ATTACK_START')
    B->>B: calculateDamage()
    B->>C: emit('HP_UPDATE')
    B->>A: emit('ATTACK_END')

八、最佳实践建议

1.命名规范

使用全大写+下划线：PLAYER_LEVEL_UP
添加命名空间：ACHIEVEMENT:UNLOCK

2.生命周期管理

// 场景切换时清理
cc.director.on(cc.Director.EVENT_BEFORE_SCENE_LOADING, () => {
    EventSystem.getInstance().cleanSceneEvents();
});

3.安全防护

// 频率限制
const emitWithCooldown = (event: string, cooldown: number) => {
    if (!this._lastEmitTimes.has(event) || 
        Date.now() - this._lastEmitTimes.get(event) > cooldown) {
        this.emit(event);
        this._lastEmitTimes.set(event, Date.now());
    }
};