refactor(plugin): 重构插件系统架构，统一类型导入路径 (#296)

* refactor(plugin): 重构插件系统架构，统一类型导入路径

## 主要更改

### 新增 @esengine/plugin-types 包
- 提供打破循环依赖的最小类型定义
- 包含 ServiceToken, createServiceToken, PluginServiceRegistry, IEditorModuleBase

### engine-core 类型统一
- IPlugin<T> 泛型参数改为 T = unknown
- 所有运行时类型（IRuntimeModule, ModuleManifest, SystemContext）在此定义
- 新增 PluginServiceRegistry.ts 导出服务令牌相关类型

### editor-core 类型优化
- 重命名 IPluginLoader.ts 为 EditorModule.ts
- 新增 IEditorPlugin = IPlugin<IEditorModuleLoader> 类型别名
- 移除弃用别名 IPluginLoader, IRuntimeModuleLoader

### 编辑器插件更新
- 所有 9 个编辑器插件使用 IEditorPlugin 类型
- 统一从 editor-core 导入编辑器类型

### 服务令牌规范
- 各模块在 tokens.ts 中定义自己的服务接口和令牌
- 遵循"谁定义接口，谁导出 Token"原则

## 导入规范

| 场景 | 导入来源 |
|------|---------|
| 运行时模块 | @esengine/engine-core |
| 编辑器插件 | @esengine/editor-core |
| 服务令牌 | @esengine/engine-core |

* refactor(plugin): 完善服务令牌规范，统一运行时模块

## 更改内容

### 运行时模块优化
- particle: 使用 PluginServiceRegistry 获取依赖服务
- physics-rapier2d: 通过服务令牌注册/获取物理查询接口
- tilemap: 使用服务令牌获取物理系统依赖
- sprite: 导出服务令牌
- ui: 导出服务令牌
- behavior-tree: 使用服务令牌系统

### 资产系统增强
- IAssetManager 接口扩展
- 加载器使用服务令牌获取依赖

### 运行时核心
- GameRuntime 使用 PluginServiceRegistry
- 导出服务令牌相关类型

### 编辑器服务
- EngineService 适配新的服务令牌系统
- AssetRegistryService 优化

* fix: 修复 editor-app 和 behavior-tree-editor 中的类型引用

- editor-app/PluginLoader.ts: 使用 IPlugin 替代 IPluginLoader
- behavior-tree-editor: 使用 IEditorPlugin 替代 IPluginLoader

* fix(ui): 添加缺失的 ecs-engine-bindgen 依赖

UIRuntimeModule 使用 EngineBridgeToken，需要声明对 ecs-engine-bindgen 的依赖

* fix(type): 解决 ServiceToken 跨包类型兼容性问题

- 在 engine-core 中直接定义 ServiceToken 和 PluginServiceRegistry
  而不是从 plugin-types 重新导出，确保 tsup 生成的类型声明
  以 engine-core 作为类型来源
- 移除 RuntimeResolver.ts 中的硬编码模块 ID 检查，
  改用 module.json 中的 name 配置
- 修复 pnpm-lock.yaml 中的依赖记录

* refactor(arch): 改进架构设计，移除硬编码

- 统一类型导出：editor-core 从 engine-core 导入 IEditorModuleBase
- RuntimeResolver: 将硬编码路径改为配置常量和搜索路径列表
- 添加跨平台安装路径支持（Windows/macOS/Linux）
- 使用 ENGINE_WASM_CONFIG 配置引擎 WASM 文件信息
- IBundlePackOptions 添加 preloadBundles 配置项

* fix(particle): 添加缺失的 ecs-engine-bindgen 依赖

ParticleRuntimeModule 导入了 @esengine/ecs-engine-bindgen 的 tokens，
但 package.json 中未声明该依赖，导致 CI 构建失败。

* fix(physics-rapier2d): 移除不存在的 PhysicsSystemContext 导出

PhysicsRuntimeModule 中不存在该类型，导致 type-check 失败

packages/tilemap/package.json

@@ -43,6 +43,7 @@
         "@esengine/asset-system": "workspace:*",
         "@esengine/engine-core": "workspace:*",
         "@esengine/ecs-engine-bindgen": "workspace:*",
+        "@esengine/physics-rapier2d": "workspace:*",
         "@esengine/build-config": "workspace:*",
         "rimraf": "^5.0.0",
         "tsup": "^8.0.0",

packages/tilemap/src/TilemapRuntimeModule.ts

@@ -1,22 +1,26 @@
 import type { IScene } from '@esengine/ecs-framework';
 import { ComponentRegistry } from '@esengine/ecs-framework';
 import type { IRuntimeModule, IPlugin, ModuleManifest, SystemContext } from '@esengine/engine-core';
-import type { AssetManager } from '@esengine/asset-system';
+import { AssetManagerToken } from '@esengine/asset-system';
+import { RenderSystemToken } from '@esengine/ecs-engine-bindgen';
+import { Physics2DWorldToken } from '@esengine/physics-rapier2d';
 
 import { TilemapComponent } from './TilemapComponent';
 import { TilemapRenderingSystem } from './systems/TilemapRenderingSystem';
 import { TilemapCollider2DComponent } from './physics/TilemapCollider2DComponent';
-import { TilemapPhysicsSystem, type IPhysicsWorld } from './physics/TilemapPhysicsSystem';
+import { TilemapPhysicsSystem } from './physics/TilemapPhysicsSystem';
 import { TilemapLoader } from './loaders/TilemapLoader';
 import { TilemapAssetType } from './constants';
+import {
+    TilemapSystemToken,
+    TilemapPhysicsSystemToken
+} from './tokens';
 
-export interface TilemapSystemContext extends SystemContext {
-    tilemapSystem?: TilemapRenderingSystem;
-    tilemapPhysicsSystem?: TilemapPhysicsSystem;
-    physics2DWorld?: IPhysicsWorld;
-    assetManager?: AssetManager;
-    renderSystem?: any;
-}
+// 重新导出 tokens | Re-export tokens
+export {
+    TilemapSystemToken,
+    TilemapPhysicsSystemToken
+} from './tokens';
 
 class TilemapRuntimeModule implements IRuntimeModule {
     private _tilemapPhysicsSystem: TilemapPhysicsSystem | null = null;
@@ -28,33 +32,36 @@ class TilemapRuntimeModule implements IRuntimeModule {
     }
 
     createSystems(scene: IScene, context: SystemContext): void {
-        const tilemapContext = context as TilemapSystemContext;
+        // 从服务注册表获取依赖 | Get dependencies from service registry
+        const assetManager = context.services.get(AssetManagerToken);
+        const renderSystem = context.services.get(RenderSystemToken);
 
-        if (!this._loaderRegistered && tilemapContext.assetManager) {
-            tilemapContext.assetManager.registerLoader(TilemapAssetType, new TilemapLoader());
+        if (!this._loaderRegistered && assetManager) {
+            assetManager.registerLoader(TilemapAssetType, new TilemapLoader());
             this._loaderRegistered = true;
         }
 
         const tilemapSystem = new TilemapRenderingSystem();
         scene.addSystem(tilemapSystem);
 
-        if (tilemapContext.renderSystem) {
-            tilemapContext.renderSystem.addRenderDataProvider(tilemapSystem);
+        if (renderSystem) {
+            renderSystem.addRenderDataProvider(tilemapSystem);
         }
 
-        tilemapContext.tilemapSystem = tilemapSystem;
-
         this._tilemapPhysicsSystem = new TilemapPhysicsSystem();
         scene.addSystem(this._tilemapPhysicsSystem);
 
-        tilemapContext.tilemapPhysicsSystem = this._tilemapPhysicsSystem;
+        // 注册服务到服务注册表 | Register services to service registry
+        context.services.register(TilemapSystemToken, tilemapSystem);
+        context.services.register(TilemapPhysicsSystemToken, this._tilemapPhysicsSystem);
     }
 
     onSystemsCreated(_scene: IScene, context: SystemContext): void {
-        const tilemapContext = context as TilemapSystemContext;
+        // 从服务注册表获取物理世界 | Get physics world from service registry
+        const physics2DWorld = context.services.get(Physics2DWorldToken);
 
-        if (this._tilemapPhysicsSystem && tilemapContext.physics2DWorld) {
-            this._tilemapPhysicsSystem.setPhysicsWorld(tilemapContext.physics2DWorld);
+        if (this._tilemapPhysicsSystem && physics2DWorld) {
+            this._tilemapPhysicsSystem.setPhysicsWorld(physics2DWorld);
         }
     }
 

packages/tilemap/src/index.ts

@@ -35,4 +35,10 @@ export { TiledConverter } from './loaders/TiledConverter';
 export type { ITiledMap, ITiledConversionResult } from './loaders/TiledConverter';
 
 // Runtime module and plugin
-export { TilemapRuntimeModule, TilemapPlugin, type TilemapSystemContext } from './TilemapRuntimeModule';
+export { TilemapRuntimeModule, TilemapPlugin } from './TilemapRuntimeModule';
+
+// Service tokens | 服务令牌
+export {
+    TilemapSystemToken,
+    TilemapPhysicsSystemToken
+} from './tokens';

packages/tilemap/src/loaders/TilemapLoader.ts

@@ -81,8 +81,13 @@ export class TilemapLoader implements IAssetLoader<ITilemapAsset> {
      * 释放已加载的资产
      */
     dispose(asset: ITilemapAsset): void {
-        (asset as any).data = null;
-        (asset as any).layers = null;
-        (asset as any).collisionData = null;
+        // 清理瓦片数据 | Clean up tile data
+        asset.data.length = 0;
+        if (asset.layers) {
+            asset.layers.length = 0;
+        }
+        if (asset.collisionData) {
+            asset.collisionData.length = 0;
+        }
     }
 }

packages/tilemap/src/loaders/TilesetLoader.ts

@@ -94,6 +94,9 @@ export class TilesetLoader implements IAssetLoader<ITilesetAsset> {
      * 释放已加载的资产
      */
     dispose(asset: ITilesetAsset): void {
-        (asset as any).tiles = null;
+        // 清理瓦片元数据 | Clean up tile metadata
+        if (asset.tiles) {
+            asset.tiles.length = 0;
+        }
     }
 }

packages/tilemap/src/physics/TilemapPhysicsSystem.ts

@@ -10,23 +10,10 @@ import { EntitySystem, Matcher, ECSSystem, type Entity, type Scene } from '@esen
 import { TransformComponent } from '@esengine/engine-core';
 import { TilemapComponent } from '../TilemapComponent';
 import { TilemapCollider2DComponent, type CollisionRect } from './TilemapCollider2DComponent';
+import type { IPhysics2DWorld } from '@esengine/physics-rapier2d';
 
-/**
- * 物理世界接口（避免直接依赖 physics-rapier2d）
- */
-export interface IPhysicsWorld {
-    createStaticCollider(
-        entityId: number,
-        position: { x: number; y: number },
-        halfExtents: { x: number; y: number },
-        collisionLayer: number,
-        collisionMask: number,
-        friction: number,
-        restitution: number,
-        isTrigger: boolean
-    ): number | null;
-    removeCollider(handle: number): void;
-}
+// 重新导出类型以保持向后兼容 | Re-export types for backward compatibility
+export type IPhysicsWorld = IPhysics2DWorld;
 
 /**
  * 物理系统接口

packages/tilemap/src/tokens.ts

@@ -0,0 +1,27 @@
+/**
+ * Tilemap 模块服务令牌
+ * Tilemap module service tokens
+ *
+ * 定义 tilemap 模块导出的服务令牌。
+ * Defines service tokens exported by tilemap module.
+ */
+
+import { createServiceToken } from '@esengine/engine-core';
+import type { TilemapRenderingSystem } from './systems/TilemapRenderingSystem';
+import type { TilemapPhysicsSystem } from './physics/TilemapPhysicsSystem';
+
+// ============================================================================
+// Tilemap 模块导出的令牌 | Tokens exported by Tilemap module
+// ============================================================================
+
+/**
+ * Tilemap 渲染系统令牌
+ * Tilemap rendering system token
+ */
+export const TilemapSystemToken = createServiceToken<TilemapRenderingSystem>('tilemapSystem');
+
+/**
+ * Tilemap 物理系统令牌
+ * Tilemap physics system token
+ */
+export const TilemapPhysicsSystemToken = createServiceToken<TilemapPhysicsSystem>('tilemapPhysicsSystem');