移除eventhandler装饰器

packages/core/tests/ECS/Systems/EntitySystem.test.ts

@@ -3,7 +3,7 @@ import { Entity } from '../../../src/ECS/Entity';
 import { Component } from '../../../src/ECS/Component';
 import { Scene } from '../../../src/ECS/Scene';
 import { Matcher } from '../../../src/ECS/Utils/Matcher';
-import { EventHandler, AsyncEventHandler, GlobalEventBus } from '../../../src/ECS/Core/EventBus';
+import { GlobalEventBus } from '../../../src/ECS/Core/EventBus';
 import { TypeSafeEventSystem } from '../../../src/ECS/Core/EventSystem';
 
 // 测试组件
@@ -23,18 +23,11 @@ interface TestEvent {
     message: string;
 }
 
-interface AsyncTestEvent {
-    data: string;
-    timestamp: number;
-}
 
 // 具体的实体系统实现
 class ConcreteEntitySystem extends EntitySystem {
     public processCallCount = 0;
     public eventHandlerCallCount = 0;
-    public asyncEventHandlerCallCount = 0;
-    public lastEvent: TestEvent | null = null;
-    public lastAsyncEvent: AsyncTestEvent | null = null;
 
     constructor() {
         super(Matcher.all(TestComponent));
@@ -44,19 +37,6 @@ class ConcreteEntitySystem extends EntitySystem {
         this.processCallCount++;
     }
 
-    @EventHandler('test_event')
-    onTestEvent(event: TestEvent): void {
-        this.eventHandlerCallCount++;
-        this.lastEvent = event;
-    }
-
-    @AsyncEventHandler('async_test_event')
-    async onAsyncTestEvent(event: AsyncTestEvent): Promise<void> {
-        this.asyncEventHandlerCallCount++;
-        this.lastAsyncEvent = event;
-        // 模拟异步操作
-        await new Promise(resolve => setTimeout(resolve, 10));
-    }
 
     // 测试用的手动事件监听器
     public addManualEventListener(): void {
@@ -122,53 +102,6 @@ describe('EntitySystem', () => {
         scene.removeSystem(system);
     });
 
-    describe('装饰器事件处理', () => {
-        it('应该自动注册 @EventHandler 装饰器标记的方法', () => {
-            const testEvent: TestEvent = { id: 1, message: 'test' };
-
-            // 发射事件（使用全局事件总线，因为装饰器注册在那里）
-            GlobalEventBus.getInstance().emit('test_event', testEvent);
-
-            // 验证事件处理器被调用
-            expect(system.eventHandlerCallCount).toBe(1);
-            expect(system.lastEvent).toEqual(testEvent);
-        });
-
-        it('应该自动注册 @AsyncEventHandler 装饰器标记的方法', async () => {
-            const asyncEvent: AsyncTestEvent = {
-                data: 'async test',
-                timestamp: Date.now()
-            };
-
-            // 发射异步事件（使用全局事件总线）
-            await GlobalEventBus.getInstance().emitAsync('async_test_event', asyncEvent);
-
-            // 等待异步处理完成
-            await new Promise(resolve => setTimeout(resolve, 20));
-
-            // 验证异步事件处理器被调用
-            expect(system.asyncEventHandlerCallCount).toBe(1);
-            expect(system.lastAsyncEvent).toEqual(asyncEvent);
-        });
-
-        it('当系统被销毁时，应该自动清理装饰器事件监听器', () => {
-            const testEvent: TestEvent = { id: 2, message: 'test after destroy' };
-
-            // 验证事件监听器工作正常
-            GlobalEventBus.getInstance().emit('test_event', testEvent);
-            expect(system.eventHandlerCallCount).toBe(1);
-
-            // 销毁系统
-            scene.removeSystem(system);
-
-            // 重置计数器并再次发射事件
-            system.eventHandlerCallCount = 0;
-            GlobalEventBus.getInstance().emit('test_event', testEvent);
-
-            // 验证事件监听器已被清理，不再响应事件
-            expect(system.eventHandlerCallCount).toBe(0);
-        });
-    });
 
     describe('手动事件监听器管理', () => {
         it('应该能够手动添加事件监听器', () => {
@@ -241,23 +174,18 @@ describe('EntitySystem', () => {
             // 添加手动监听器
             system.testAddEventListener('destroy_order_test', handler);
 
-            // 验证装饰器和手动监听器都工作
-            GlobalEventBus.getInstance().emit('test_event', testEvent);
+            // 验证手动监听器工作
             scene.eventSystem.emitSync('destroy_order_test', {});
-            expect(system.eventHandlerCallCount).toBe(1);
             expect(handler).toHaveBeenCalledTimes(1);
 
             // 直接调用框架的销毁方法
             system.destroy();
 
-            // 重置计数器并验证所有监听器都被清理
-            system.eventHandlerCallCount = 0;
+            // 重置计数器并验证监听器被清理
             handler.mockClear();
 
-            GlobalEventBus.getInstance().emit('test_event', testEvent);
             scene.eventSystem.emitSync('destroy_order_test', {});
 
-            expect(system.eventHandlerCallCount).toBe(0);
             expect(handler).not.toHaveBeenCalled();
         });
     });
@@ -286,41 +214,4 @@ describe('EntitySystem', () => {
         });
     });
 
-    describe('多个事件监听器', () => {
-        it('应该支持同一个系统监听多个不同的事件', () => {
-            const event1: TestEvent = { id: 1, message: 'first' };
-            const event2: AsyncTestEvent = { data: 'second', timestamp: Date.now() };
-
-            // 发射两个不同的事件
-            GlobalEventBus.getInstance().emit('test_event', event1);
-            GlobalEventBus.getInstance().emitAsync('async_test_event', event2);
-
-            // 等待异步处理
-            return new Promise<void>(resolve => {
-                setTimeout(() => {
-                    expect(system.eventHandlerCallCount).toBe(1);
-                    expect(system.asyncEventHandlerCallCount).toBe(1);
-                    expect(system.lastEvent).toEqual(event1);
-                    expect(system.lastAsyncEvent).toEqual(event2);
-                    resolve();
-                }, 50);
-            });
-        });
-
-        it('应该支持多个系统监听同一个事件', () => {
-            const system2 = new ConcreteEntitySystem();
-            scene.addSystem(system2);
-
-            const testEvent: TestEvent = { id: 4, message: 'shared event' };
-
-            // 发射事件
-            GlobalEventBus.getInstance().emit('test_event', testEvent);
-
-            // 验证两个系统都接收到了事件
-            expect(system.eventHandlerCallCount).toBe(1);
-            expect(system2.eventHandlerCallCount).toBe(1);
-            expect(system.lastEvent).toEqual(testEvent);
-            expect(system2.lastEvent).toEqual(testEvent);
-        });
-    });
 });