refactor: 删除污染严重的 TEnemy 和 THero，仅在战斗系统中包含

packages-user/data-base/src/enemy/manager.ts

@@ -12,16 +12,18 @@ import {
 } from './types';
 import { SaveCompression } from '@user/data-common';
 
-export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
+export class EnemyManager<TEnemy> implements IEnemyManager<TEnemy> {
     /** 特殊属性注册表，code -> 创建函数 */
-    private readonly specialRegistry: Map<number, SpecialCreation<any, TAttr>> =
+    private readonly specialRegistry: Map<
-        new Map();
+        number,
+        SpecialCreation<any, TEnemy>
+    > = new Map();
     /** 自定义怪物属性注册表，name -> 默认值 */
-    private readonly attributeRegistry: Map<keyof TAttr, any> = new Map();
+    private readonly attributeRegistry: Map<keyof TEnemy, any> = new Map();
     /** 怪物模板表，code -> IEnemy */
-    private readonly prefabByCode: Map<number, IEnemy<TAttr>> = new Map();
+    private readonly prefabByCode: Map<number, IEnemy<TEnemy>> = new Map();
     /** 怪物模板表，id -> IEnemy */
-    private readonly prefabById: Map<string, IEnemy<TAttr>> = new Map();
+    private readonly prefabById: Map<string, IEnemy<TEnemy>> = new Map();
     /** 旧样板怪物 id 到 code 的映射，用于 fromLegacyEnemy 快速查找已有模板 */
     private readonly legacyIdToCode: Map<string, number> = new Map();
     /** 复用映射，reusedCode -> sourceCode */
@@ -31,21 +33,21 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
     /** 脏模板集合，存储发生了变化的模板 code */
     private readonly dirtySet: Set<number> = new Set();
     /** 参考快照，code -> IReadonlyEnemy，由 compareWith 提供 */
-    private referenceByCode: Map<number, IReadonlyEnemy<TAttr>> = new Map();
+    private referenceByCode: Map<number, IReadonlyEnemy<TEnemy>> = new Map();
     /** 当前附加的怪物比较器 */
-    private comparer: IEnemyComparer<TAttr> | null = null;
+    private comparer: IEnemyComparer<TEnemy> | null = null;
     /** 是否已首次调用 compareWith */
     private hasReference: boolean = false;
 
-    constructor(readonly bridge: IEnemyLegacyBridge<TAttr>) {}
+    constructor(readonly bridge: IEnemyLegacyBridge<TEnemy>) {}
 
-    registerSpecial(code: number, cons: SpecialCreation<any, TAttr>): void {
+    registerSpecial(code: number, cons: SpecialCreation<any, TEnemy>): void {
         this.specialRegistry.set(code, cons);
     }
 
-    setAttributeDefaults<K extends keyof TAttr>(
+    setAttributeDefaults<K extends keyof TEnemy>(
         name: K,
-        defaultValue: TAttr[K]
+        defaultValue: TEnemy[K]
     ): void {
         if (
             typeof defaultValue === 'function' ||
@@ -59,7 +61,7 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
         this.attributeRegistry.set(name, defaultValue);
     }
 
-    fromLegacyEnemy(code: number, enemy: Enemy): IEnemy<TAttr> {
+    fromLegacyEnemy(code: number, enemy: Enemy): IEnemy<TEnemy> {
         // 如果该旧样板怪物已经通过 addPrefabFromLegacy 注册为模板，直接克隆模板
         const existingCode = this.legacyIdToCode.get(enemy.id);
         if (existingCode) {
@@ -76,15 +78,15 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
      * 根据旧样板怪物与注册过的默认属性构造属性对象
      * @param enemy 旧样板怪物对象
      */
-    private createAttributes(enemy: Enemy): TAttr {
+    private createAttributes(enemy: Enemy): TEnemy {
-        const attrs: Partial<TAttr> = {};
+        const attrs: Partial<TEnemy> = {};
         for (const [name, defaultValue] of this.attributeRegistry) {
             attrs[name] = structuredClone(defaultValue);
         }
 
         Object.assign(attrs, this.bridge.fromLegacyEnemy(enemy, attrs));
 
-        return attrs as TAttr;
+        return attrs as TEnemy;
     }
 
     /**
@@ -92,9 +94,9 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
      * @param code 怪物图块数字
      * @param enemy 旧样板怪物对象
      */
-    private convertLegacyEnemy(code: number, enemy: Enemy): IEnemy<TAttr> {
+    private convertLegacyEnemy(code: number, enemy: Enemy): IEnemy<TEnemy> {
         const attrs = this.createAttributes(enemy);
-        const result = new EnemyImpl<TAttr>(
+        const result = new EnemyImpl<TEnemy>(
             enemy.id,
             code,
             structuredClone(attrs)
@@ -114,13 +116,13 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
         return result;
     }
 
-    createEnemy(code: number): IEnemy<TAttr> | null {
+    createEnemy(code: number): IEnemy<TEnemy> | null {
         const prefab = this.prefabByCode.get(code);
         if (!prefab) return null;
         return prefab.clone();
     }
 
-    createEnemyById(id: string): IEnemy<TAttr> | null {
+    createEnemyById(id: string): IEnemy<TEnemy> | null {
         const prefab = this.prefabById.get(id);
         if (!prefab) return null;
         return prefab.clone();
@@ -136,7 +138,7 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
         }
     }
 
-    addPrefab(enemy: IEnemy<TAttr>): void {
+    addPrefab(enemy: IEnemy<TEnemy>): void {
         if (
             this.prefabByCode.has(enemy.code) ||
             this.prefabById.has(enemy.id)
@@ -160,12 +162,12 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
         this.updateDirty(code, prefab);
     }
 
-    getPrefab(code: number): IReadonlyEnemy<TAttr> | null {
+    getPrefab(code: number): IReadonlyEnemy<TEnemy> | null {
         const sourceCode = this.reuseByCode.get(code) ?? code;
         return this.prefabByCode.get(sourceCode) ?? null;
     }
 
-    getPrefabById(id: string): IReadonlyEnemy<TAttr> | null {
+    getPrefabById(id: string): IReadonlyEnemy<TEnemy> | null {
         const sourceId = this.reuseById.get(id) ?? id;
         return this.prefabById.get(sourceId) ?? null;
     }
@@ -177,7 +179,7 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
         this.prefabById.delete(prefab.id);
     }
 
-    changePrefab(code: number | string, enemy: IEnemy<TAttr>): void {
+    changePrefab(code: number | string, enemy: IEnemy<TEnemy>): void {
         // 先删除旧的模板（如果存在）
         this.deletePrefab(code);
         // 再添加新的模板
@@ -193,7 +195,7 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
         this.reuseById.set(id, prefab.id);
     }
 
-    compareWith(reference: ReadonlyMap<number, IReadonlyEnemy<TAttr>>): void {
+    compareWith(reference: ReadonlyMap<number, IReadonlyEnemy<TEnemy>>): void {
         const isSubsequentCall = this.hasReference;
         if (isSubsequentCall) {
             logger.warn(117);
@@ -211,7 +213,7 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
 
     modifyPrefabAttribute(
         code: number | string,
-        modify: (prefab: IEnemy<TAttr>) => IEnemy<TAttr>
+        modify: (prefab: IEnemy<TEnemy>) => IEnemy<TEnemy>
     ): void {
         const prefab = this.internalGetPrefab(code);
         if (!prefab) return;
@@ -230,16 +232,16 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
         this.updateDirty(result.code, result);
     }
 
-    attachEnemyComparer(comparer: IEnemyComparer<TAttr>): void {
+    attachEnemyComparer(comparer: IEnemyComparer<TEnemy>): void {
         this.comparer = comparer;
     }
 
-    getEnemyComparer(): IEnemyComparer<TAttr> | null {
+    getEnemyComparer(): IEnemyComparer<TEnemy> | null {
         return this.comparer;
     }
 
-    saveState(compression: SaveCompression): IEnemyManagerSaveState<TAttr> {
+    saveState(compression: SaveCompression): IEnemyManagerSaveState<TEnemy> {
-        const modified: Map<number, IEnemySaveState<TAttr>> = new Map();
+        const modified: Map<number, IEnemySaveState<TEnemy>> = new Map();
         for (const code of this.dirtySet) {
             const prefab = this.prefabByCode.get(code);
             if (!prefab) continue;
@@ -249,7 +251,7 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
     }
 
     loadState(
-        state: IEnemyManagerSaveState<TAttr>,
+        state: IEnemyManagerSaveState<TEnemy>,
         compression: SaveCompression
     ): void {
         for (const [code, enemyState] of state.modified) {
@@ -269,7 +271,7 @@ export class EnemyManager<TAttr> implements IEnemyManager<TAttr> {
      * @param code 怪物图块数字
      * @param current 当前模板对象
      */
-    private updateDirty(code: number, current: IEnemy<TAttr>): void {
+    private updateDirty(code: number, current: IEnemy<TEnemy>): void {
         if (!this.hasReference) return;
         if (!this.comparer) {
             logger.warn(118);

packages-user/data-base/src/types.ts

@@ -2,21 +2,26 @@ import { IHeroFollower, IHeroState } from './hero';
 import { IEnemyManager } from './enemy';
 import { IFlagSystem } from './flag';
 import { IMapStore } from './map';
-import { IDataCommon, ISaveableContent } from '@user/data-common';
+import {
+    IDataCommon,
+    IEnemyAttr,
+    IHeroAttr,
+    ISaveableContent
+} from '@user/data-common';
 
 export interface IStateSaveData {
     /** 跟随者列表 */
     readonly followers: readonly IHeroFollower[];
 }
 
-export interface IStateBase<TEnemy, THero> extends IDataCommon {
+export interface IStateBase extends IDataCommon {
     /** 地图状态 */
     readonly maps: IMapStore;
     /** 勇士状态 */
-    readonly hero: IHeroState<THero>;
+    readonly hero: IHeroState<IHeroAttr>;
 
     /** 怪物管理器 */
-    readonly enemyManager: IEnemyManager<TEnemy>;
+    readonly enemyManager: IEnemyManager<IEnemyAttr>;
 
     /** Flag 系统 */
     readonly flags: IFlagSystem;
@@ -35,7 +40,7 @@ export interface IStateBase<TEnemy, THero> extends IDataCommon {
     getSaveableContent<T>(id: string): ISaveableContent<T> | null;
 }
 
-export interface IStateBaseExtended<TEnemy = unknown, THero = unknown> {
+export interface IStateBaseExtended {
     /** 当前对象对应的数据层对象（Layer 1 对象） */
-    readonly state: IStateBase<TEnemy, THero>;
+    readonly state: IStateBase;
 }

packages-user/data-common/src/types.ts

@@ -1,6 +1,47 @@
+import { ITileLocator } from '@motajs/common';
 import { IFaceManager, IRoleFaceBinder } from './common';
 import { ITileStore } from './store';
 
+export interface IEnemyAttr {
+    /** 怪物生命值 */
+    hp: number;
+    /** 怪物攻击力 */
+    atk: number;
+    /** 怪物防御力 */
+    def: number;
+    /** 怪物金币 */
+    money: number;
+    /** 怪物经验值 */
+    exp: number;
+    /** 怪物加点量 */
+    point: number;
+    /** 支援来源怪物坐标索引列表 */
+    guard: Set<ITileLocator>;
+}
+
+export interface IHeroAttr {
+    /** 勇士名称 */
+    name: string;
+    /** 勇士生命值 */
+    hp: number;
+    /** 勇士生命值上限 */
+    hpmax: number;
+    /** 勇士攻击力 */
+    atk: number;
+    /** 勇士防御力 */
+    def: number;
+    /** 勇士护盾 */
+    mdef: number;
+    /** 勇士魔法值 */
+    mana: number;
+    /** 勇士魔法上限 */
+    manamax: number;
+    /** 勇士拥有的金币 */
+    money: number;
+    /** 勇士拥有的经验 */
+    exp: number;
+}
+
 export interface IDataCommon {
     /** 图块定义存储 */
     readonly tileStore: ITileStore<MapDataOf<keyof NumberToId>>;

packages-user/data-state/src/core.ts

@@ -11,7 +11,9 @@ import {
     Dir4FaceHandler,
     Dir8FaceHandler,
     FaceGroup,
-    FaceDirection
+    FaceDirection,
+    IHeroAttr,
+    IEnemyAttr
 } from '@user/data-common';
 import {
     EnemyManager,
@@ -48,8 +50,7 @@ import {
     MainMapDamageConverter,
     MainMapDamageReducer,
     registerSpecials,
-    MainEnemyComparer,
+    MainEnemyComparer
-    IEnemyAttr
 } from './enemy';
 import {
     BG2_ZINDEX,
@@ -61,7 +62,6 @@ import {
     TILE_HEIGHT,
     TILE_WIDTH
 } from './shared';
-import { IHeroAttr } from './hero';
 import { LegacyTileData, TileLegacyBridge } from './legacy';
 import { ILoadProgressTotal, LoadProgressTotal } from '@motajs/loader';
 import { isNil } from 'lodash-es';
@@ -82,8 +82,8 @@ export class CoreState implements ICoreState {
 
     // Layer 2 执行层，游戏逻辑对象都在这
     readonly enemyContext: IEnemyContext<IEnemyAttr, IHeroAttr>;
-    readonly triggerRegistry: ITriggerRegistry<IEnemyAttr, IHeroAttr>;
+    readonly triggerRegistry: ITriggerRegistry;
-    readonly triggerCollector: ITriggerCollector<IEnemyAttr, IHeroAttr>;
+    readonly triggerCollector: ITriggerCollector;
 
     // 用户层内容，也就是最顶层的内容，一般仅用于初始化
     readonly loadProgress: ILoadProgressTotal;
@@ -171,10 +171,8 @@ export class CoreState implements ICoreState {
         this.enemyContext = enemyContext;
 
         // 触发器注册与收集器
-        const triggerRegistry = new TriggerRegistry<IEnemyAttr, IHeroAttr>(
+        const triggerRegistry = new TriggerRegistry(this);
-            this
+        const triggerCollector = new TriggerCollector();
-        );
-        const triggerCollector = new TriggerCollector<IEnemyAttr, IHeroAttr>();
         triggerCollector.attachRegistry(triggerRegistry);
         this.triggerRegistry = triggerRegistry;
         this.triggerCollector = triggerCollector;

packages-user/data-state/src/enemy/aura.ts

@@ -18,8 +18,7 @@ import {
 } from '@user/data-system';
 import { IReadonlyEnemy, ISpecial } from '@user/data-base';
 import { IHaloValue } from './special';
-import { IEnemyAttr } from './types';
+import { IHeroAttr, IEnemyAttr } from '@user/data-common';
-import { IHeroAttr } from '../hero';
 
 const FULL_RANGE = new FullRange();
 const RECT_RANGE = new RectRange();
@@ -176,7 +175,7 @@ export class GuardAura implements IEnemyAuraView<
         if (locator.x === this.locator.x && locator.y === this.locator.y) {
             return;
         }
-        enemy.getAttribute('guard').add(this.sourceView);
+        enemy.getAttribute('guard').add(this.locator);
     }
 
     applySpecial(): IEnemySpecialModifier<IEnemyAttr> | null {

packages-user/data-state/src/enemy/calculator.ts

@@ -4,10 +4,10 @@ import {
     IEnemyDamageInfo,
     IReadonlyEnemyHandler
 } from '@user/data-system';
-import { IEnemyAttr } from './types';
+import { IEnemyAttr, IHeroAttr } from '@user/data-common';
 import { IVampireValue } from './special';
-import { IHeroAttr } from '../hero';
 import { state } from '../ins';
+import { logger } from '@motajs/common';
 
 export class MainDamageCalculator implements IDamageCalculator<
     IEnemyAttr,
@@ -87,8 +87,14 @@ export class MainDamageCalculator implements IDamageCalculator<
             // 因此回合数需要加上打支援怪的回合数
             for (const guard of guards) {
                 // 直接把 enemy 传过去，因此支援的 enemy 会吃到其原本所在位置的光环加成
+                const view = handler.context.getEnemyByLocator(guard);
+                if (!view) {
+                    logger.warn(137, guard.x.toString(), guard.y.toString());
+                    continue;
+                }
                 const extraInfo = this.calculate({
-                    enemy: guard.getComputedEnemy(),
+                    enemy: view.getComputedEnemy(),
+                    context: handler.context,
                     locator,
                     hero,
                     data: handler.data

packages-user/data-state/src/enemy/comparer.ts

@@ -1,5 +1,5 @@
 import { IEnemyComparer, IReadonlyEnemy } from '@user/data-base';
-import { IEnemyAttr } from './types';
+import { IEnemyAttr } from '@user/data-common';
 
 export class MainEnemyComparer implements IEnemyComparer<IEnemyAttr> {
     compare(

packages-user/data-state/src/enemy/final.ts

@@ -1,6 +1,5 @@
 import { IEnemyFinalEffect, IEnemyHandler } from '@user/data-system';
-import { IEnemyAttr } from './types';
+import { IEnemyAttr, IHeroAttr } from '@user/data-common';
-import { IHeroAttr } from '../hero';
 
 export class MainEnemyFinalEffect implements IEnemyFinalEffect<
     IEnemyAttr,

packages-user/data-state/src/enemy/legacy.ts

@@ -1,5 +1,5 @@
 import { IEnemyLegacyBridge } from '@user/data-base';
-import { IEnemyAttr } from './types';
+import { IEnemyAttr } from '@user/data-common';
 
 export class EnemyLegacyBridge implements IEnemyLegacyBridge<IEnemyAttr> {
     fromLegacyEnemy(

packages-user/data-state/src/enemy/mapDamage.ts

@@ -24,8 +24,8 @@ import {
     IReadonlyEnemy
 } from '@user/data-base';
 import { IZoneValue } from './special';
-import { IEnemyAttr, MapDamageType } from './types';
+import { MapDamageType } from './types';
-import { IHeroAttr } from '../hero';
+import { IHeroAttr, IEnemyAttr } from '@user/data-common';
 import { IFaceHandler, FaceGroup } from '@user/data-common';
 
 const RECT_RANGE = new RectRange();

packages-user/data-state/src/enemy/special.ts

@@ -4,7 +4,7 @@ import {
     IEnemyManager
 } from '@user/data-base';
 import { getHeroStatusOn } from '../legacy/hero';
-import { IEnemyAttr } from './types';
+import { IEnemyAttr } from '@user/data-common';
 
 //#region 复合属性值类型
 

packages-user/data-state/src/enemy/types.ts

@@ -1,5 +1,3 @@
-import { IEnemyView } from '@user/data-system';
-
 export interface IEnemyAttr {
     /** 怪物生命值 */
     hp: number;
@@ -13,8 +11,8 @@ export interface IEnemyAttr {
     exp: number;
     /** 怪物加点量 */
     point: number;
-    /** 支援来源怪物视图列表 */
+    /** 支援来源怪物坐标索引列表 */
-    guard: Set<IEnemyView<IEnemyAttr>>;
+    guard: Set<number>;
 }
 
 export const enum MapDamageType {

packages-user/data-state/src/hero/types.ts

@@ -1,26 +1,5 @@
 //#region 勇士属性
 
-export interface IHeroAttr {
+export interface IHeroAttr {}
-    /** 勇士名称 */
-    name: string;
-    /** 勇士生命值 */
-    hp: number;
-    /** 勇士生命值上限 */
-    hpmax: number;
-    /** 勇士攻击力 */
-    atk: number;
-    /** 勇士防御力 */
-    def: number;
-    /** 勇士护盾 */
-    mdef: number;
-    /** 勇士魔法值 */
-    mana: number;
-    /** 勇士魔法上限 */
-    manamax: number;
-    /** 勇士拥有的金币 */
-    money: number;
-    /** 勇士拥有的经验 */
-    exp: number;
-}
 
 //#endregion

packages-user/data-state/src/shared.ts

@@ -1,4 +1,4 @@
-import { IHeroAttr } from './hero';
+import { IHeroAttr } from '@user/data-common';
 
 //#region 地图相关
 

packages-user/data-state/src/types.ts

@@ -1,21 +1,19 @@
 import { IMotaDataLoader, IStateBase } from '@user/data-base';
-import { IEnemyAttr } from './enemy';
-import { IHeroAttr } from './hero';
 import { ILoadProgressTotal } from '@motajs/loader';
 import { ISaveSystem } from './save';
 import { IStateSystem } from '@user/data-system';
 import { ISaveableContent } from '@user/data-common';
 
-export interface ISaveableExecutor<T, TEnemy = IEnemyAttr, THero = IHeroAttr> {
+export interface ISaveableExecutor<T> {
     /**
      * 当数据读取后执行的函数，允许对其他存档对象进行读取
      * @param data 对应可存档对象的存档数据
      * @param state 当前的基础状态
      */
-    afterLoad(data: T, state: IStateBase<TEnemy, THero>): void;
+    afterLoad(data: T, state: IStateBase): void;
 }
 
-export interface ICoreState extends IStateSystem<IEnemyAttr, IHeroAttr> {
+export interface ICoreState extends IStateSystem {
     /** 加载进度对象 */
     readonly loadProgress: ILoadProgressTotal;
     /** 数据端加载对象 */

packages-user/data-system/src/combat/context.ts

@@ -100,7 +100,7 @@ export class EnemyContext<TEnemy, THero> implements IEnemyContext<
     width: number = 0;
     height: number = 0;
 
-    constructor(readonly dataState: IStateBase<TEnemy, THero>) {}
+    constructor(readonly dataState: IStateBase) {}
 
     resize(width: number, height: number): void {
         this.clear();
@@ -210,7 +210,13 @@ export class EnemyContext<TEnemy, THero> implements IEnemyContext<
         enemy: IEnemy<TEnemy>,
         locator: ITileLocator
     ): IEnemyHandler<TEnemy, THero> {
-        return { enemy, locator, hero: this.bindedHero!, data: this.dataState };
+        return {
+            enemy,
+            context: this,
+            locator,
+            hero: this.bindedHero!,
+            data: this.dataState
+        };
     }
 
     getEnemyLocator(enemy: IEnemy<TEnemy>): Readonly<ITileLocator> | null {

packages-user/data-system/src/combat/damage.ts

@@ -34,7 +34,7 @@ export class DamageContext<TEnemy, THero> implements IDamageContext<
     /** 当前勇士属性 */
     protected heroStatus: IReadonlyHeroAttribute<THero> | null;
 
-    readonly dataState: IStateBase<TEnemy, THero>;
+    readonly dataState: IStateBase;
 
     constructor(
         readonly context: IEnemyContext<TEnemy, THero>,
@@ -57,7 +57,13 @@ export class DamageContext<TEnemy, THero> implements IDamageContext<
         locator: ITileLocator,
         hero: IReadonlyHeroAttribute<THero>
     ): IReadonlyEnemyHandler<TEnemy, THero> {
-        return { enemy, locator, hero, data: this.dataState };
+        return {
+            enemy,
+            context: this.context,
+            locator,
+            hero,
+            data: this.dataState
+        };
     }
 
     getDamageInfo(enemy: IEnemyView<TEnemy>): IEnemyDamageInfo | null {

packages-user/data-system/src/combat/mapDamage.ts

@@ -64,7 +64,7 @@ export class MapDamage<TEnemy, THero> implements IMapDamage<TEnemy, THero> {
     /** 坐标索引对象 */
     private readonly indexer: ILocationHelper;
 
-    readonly dataState: IStateBase<TEnemy, THero>;
+    readonly dataState: IStateBase;
 
     constructor(readonly context: IEnemyContext<TEnemy, THero>) {
         this.indexer = context.indexer;
@@ -89,6 +89,7 @@ export class MapDamage<TEnemy, THero> implements IMapDamage<TEnemy, THero> {
         if (!hero) return null;
         return {
             enemy: view.getComputedEnemy(),
+            context: this.context,
             locator,
             hero,
             data: this.context.dataState

packages-user/data-system/src/combat/types.ts

@@ -14,23 +14,27 @@ import { ILocationHelper } from '@user/data-common';
 export interface IEnemyHandler<TEnemy, THero> {
     /** 怪物属性信息 */
     readonly enemy: IEnemy<TEnemy>;
+    /** 怪物上下文 */
+    readonly context: IEnemyContext<TEnemy, THero>;
     /** 怪物定位符 */
     readonly locator: ITileLocator;
     /** 勇士属性信息 */
     readonly hero: IReadonlyHeroAttribute<THero>;
     /** 当前全局状态对象 */
-    readonly data: IStateBase<TEnemy, THero>;
+    readonly data: IStateBase;
 }
 
 export interface IReadonlyEnemyHandler<TEnemy, THero> {
     /** 怪物属性信息 */
     readonly enemy: IReadonlyEnemy<TEnemy>;
+    /** 怪物上下文 */
+    readonly context: IReadonlyEnemyContext<TEnemy, THero>;
     /** 怪物定位符 */
     readonly locator: ITileLocator;
     /** 勇士属性信息 */
     readonly hero: IReadonlyHeroAttribute<THero>;
     /** 当前全局状态对象 */
-    readonly data: IStateBase<TEnemy, THero>;
+    readonly data: IStateBase;
 }
 
 //#endregion
@@ -282,7 +286,7 @@ export interface IMapDamage<TEnemy, THero> {
     /** 当前绑定的怪物上下文 */
     readonly context: IEnemyContext<TEnemy, THero>;
     /** 地图伤害系统绑定的全局状态对象 */
-    readonly dataState: IStateBase<TEnemy, THero>;
+    readonly dataState: IStateBase;
 
     /**
      * 设置地图伤害转换器，并基于当前上下文重建所有地图伤害视图
@@ -398,7 +402,7 @@ export interface IDamageCalculator<TEnemy, THero> {
 
 export interface IDamageContext<TEnemy, THero> {
     /** 伤害上下文所属的全局状态对象 */
-    readonly dataState: IStateBase<TEnemy, THero>;
+    readonly dataState: IStateBase;
 
     /**
      * 获取战斗伤害信息
@@ -479,7 +483,7 @@ export interface IDamageSystem<TEnemy, THero> extends IDamageContext<
 
 //#region 上下文
 
-export interface IEnemyContext<TEnemy, THero> {
+export interface IReadonlyEnemyContext<TEnemy, THero> {
     /** 怪物上下文宽度 */
     readonly width: number;
     /** 怪物上下文高度 */
@@ -487,7 +491,84 @@ export interface IEnemyContext<TEnemy, THero> {
     /** 此上下文使用的索引对象 */
     readonly indexer: ILocationHelper;
     /** 当前怪物上下文绑定的全局状态对象 */
-    readonly dataState: IStateBase<TEnemy, THero>;
+    readonly dataState: IStateBase;
+
+    /**
+     * 获取当前绑定的勇士属性对象
+     */
+    getBindedHero(): IReadonlyHeroAttribute<THero> | null;
+
+    /**
+     * 获取指定怪物对象当前所在位置
+     * @param enemy 怪物对象
+     */
+    getEnemyLocator(enemy: IEnemy<TEnemy>): Readonly<ITileLocator> | null;
+
+    /**
+     * 获取指定怪物视图当前所在位置
+     * @param view 怪物视图
+     */
+    getEnemyLocatorByView(
+        view: IEnemyView<TEnemy>
+    ): Readonly<ITileLocator> | null;
+
+    /**
+     * 根据定位符获取怪物视图
+     * @param locator 地图定位符
+     */
+    getEnemyByLocator(locator: ITileLocator): IEnemyView<TEnemy> | null;
+
+    /**
+     * 根据坐标获取怪物视图
+     * @param x 横坐标
+     * @param y 纵坐标
+     */
+    getEnemyByLoc(x: number, y: number): IEnemyView<TEnemy> | null;
+
+    /**
+     * 根据计算后怪物对象反查怪物视图
+     * @param enemy 计算后怪物对象
+     */
+    getViewByComputed(enemy: IReadonlyEnemy<TEnemy>): IEnemyView<TEnemy> | null;
+
+    /**
+     * 扫描指定范围内的怪物视图
+     * @param range 范围对象
+     * @param param 范围参数
+     */
+    scanRange<T>(
+        range: IRange<T>,
+        param: T
+    ): Iterable<[ITileLocator, IEnemyView<TEnemy>]>;
+
+    /**
+     * 迭代上下文中的全部怪物
+     */
+    iterateEnemy(): Iterable<[ITileLocator, IEnemyView<TEnemy>]>;
+
+    /**
+     * 获取当前绑定的地图伤害管理器
+     */
+    getMapDamage(): IMapDamage<TEnemy, THero> | null;
+
+    /**
+     * 获取当前绑定的伤害计算系统
+     */
+    getDamageSystem(): IDamageSystem<TEnemy, THero> | null;
+}
+
+export interface IEnemyContext<TEnemy, THero> extends IReadonlyEnemyContext<
+    TEnemy,
+    THero
+> {
+    /** 怪物上下文宽度 */
+    readonly width: number;
+    /** 怪物上下文高度 */
+    readonly height: number;
+    /** 此上下文使用的索引对象 */
+    readonly indexer: ILocationHelper;
+    /** 当前怪物上下文绑定的全局状态对象 */
+    readonly dataState: IStateBase;
 
     /**
      * 调整上下文尺寸，并清空当前上下文中的所有怪物与状态
@@ -572,44 +653,6 @@ export interface IEnemyContext<TEnemy, THero> {
      */
     bindHero(hero: IReadonlyHeroAttribute<THero> | null): void;
 
-    /**
-     * 获取当前绑定的勇士属性对象
-     */
-    getBindedHero(): IReadonlyHeroAttribute<THero> | null;
-
-    /**
-     * 获取指定怪物对象当前所在位置
-     * @param enemy 怪物对象
-     */
-    getEnemyLocator(enemy: IEnemy<TEnemy>): Readonly<ITileLocator> | null;
-
-    /**
-     * 获取指定怪物视图当前所在位置
-     * @param view 怪物视图
-     */
-    getEnemyLocatorByView(
-        view: IEnemyView<TEnemy>
-    ): Readonly<ITileLocator> | null;
-
-    /**
-     * 根据定位符获取怪物视图
-     * @param locator 地图定位符
-     */
-    getEnemyByLocator(locator: ITileLocator): IEnemyView<TEnemy> | null;
-
-    /**
-     * 根据坐标获取怪物视图
-     * @param x 横坐标
-     * @param y 纵坐标
-     */
-    getEnemyByLoc(x: number, y: number): IEnemyView<TEnemy> | null;
-
-    /**
-     * 根据计算后怪物对象反查怪物视图
-     * @param enemy 计算后怪物对象
-     */
-    getViewByComputed(enemy: IReadonlyEnemy<TEnemy>): IEnemyView<TEnemy> | null;
-
     /**
      * 在指定位置放置一个怪物对象
      * @param locator 地图定位符
@@ -623,21 +666,6 @@ export interface IEnemyContext<TEnemy, THero> {
      */
     deleteEnemy(locator: ITileLocator): void;
 
-    /**
-     * 扫描指定范围内的怪物视图
-     * @param range 范围对象
-     * @param param 范围参数
-     */
-    scanRange<T>(
-        range: IRange<T>,
-        param: T
-    ): Iterable<[ITileLocator, IEnemyView<TEnemy>]>;
-
-    /**
-     * 迭代上下文中的全部怪物
-     */
-    iterateEnemy(): Iterable<[ITileLocator, IEnemyView<TEnemy>]>;
-
     /**
      * 添加一个全局光环视图
      * @param aura 光环视图
@@ -656,22 +684,12 @@ export interface IEnemyContext<TEnemy, THero> {
      */
     attachMapDamage(damage: IMapDamage<TEnemy, THero> | null): void;
 
-    /**
-     * 获取当前绑定的地图伤害管理器
-     */
-    getMapDamage(): IMapDamage<TEnemy, THero> | null;
-
     /**
      * 绑定伤害计算系统
      * @param system 伤害系统
      */
     attachDamageSystem(system: IDamageSystem<TEnemy, unknown> | null): void;
 
-    /**
-     * 获取当前绑定的伤害计算系统
-     */
-    getDamageSystem(): IDamageSystem<TEnemy, THero> | null;
-
     /**
      * 重建当前上下文中的全部怪物计算结果
      *

packages-user/data-system/src/trigger/collection.ts

@@ -1,13 +1,10 @@
 import { ITrigger, ITriggerCollection, ITriggerHandler } from './types';
 
-export class TriggerCollection<
+export class TriggerCollection implements ITriggerCollection {
-    TEnemy = unknown,
-    THero = unknown
-> implements ITriggerCollection<TEnemy, THero> {
     /** 当前集合内部维护的触发器列表 */
-    private readonly triggerList: ITrigger<TEnemy, THero>[];
+    private readonly triggerList: ITrigger[];
 
-    constructor(triggers: Iterable<ITrigger<TEnemy, THero>>) {
+    constructor(triggers: Iterable<ITrigger>) {
         this.triggerList = [...triggers];
     }
 
@@ -15,19 +12,15 @@ export class TriggerCollection<
         return this.triggerList.length;
     }
 
-    async trigger(handler: ITriggerHandler<TEnemy, THero>): Promise<void> {
+    async trigger(handler: ITriggerHandler): Promise<void> {
         for (const trigger of this.triggerList) {
             await trigger.trigger(handler);
         }
     }
 
     async *triggerIter(
-        handler: ITriggerHandler<TEnemy, THero>
+        handler: ITriggerHandler
-    ): AsyncGenerator<
+    ): AsyncGenerator<ITrigger, void, ITriggerHandler | null> {
-        ITrigger<TEnemy, THero>,
-        void,
-        ITriggerHandler<TEnemy, THero> | null
-    > {
         let currentHandler = handler;
         for (const trigger of this.triggerList) {
             await trigger.trigger(currentHandler);
@@ -40,21 +33,19 @@ export class TriggerCollection<
         }
     }
 
-    iterate(): Iterable<ITrigger<TEnemy, THero>> {
+    iterate(): Iterable<ITrigger> {
         return this.triggerList.values();
     }
 
-    push(trigger: ITrigger<TEnemy, THero>): void {
+    push(trigger: ITrigger): void {
         this.triggerList.push(trigger);
     }
 
-    unshift(trigger: ITrigger<TEnemy, THero>): void {
+    unshift(trigger: ITrigger): void {
         this.triggerList.unshift(trigger);
     }
 
-    concat(
+    concat(...others: ITriggerCollection[]): ITriggerCollection {
-        ...others: ITriggerCollection<TEnemy, THero>[]
-    ): ITriggerCollection<TEnemy, THero> {
         const merged = [...this.triggerList];
         for (const other of others) {
             merged.push(...other.iterate());

packages-user/data-system/src/trigger/collector.ts

@@ -8,18 +8,11 @@ import {
 import { logger } from '@motajs/common';
 import { TriggerCollection } from './collection';
 
-export class TriggerCollector<
+export class TriggerCollector implements ITriggerCollector {
-    TEnemy = unknown,
-    THero = unknown
-> implements ITriggerCollector<TEnemy, THero> {
     /** 当前收集器使用的注册对象 */
-    private registry: ITriggerRegistry<TEnemy, THero> | null = null;
+    private registry: ITriggerRegistry | null = null;
 
-    collect(
+    collect(x: number, y: number, layer: IMapLayer): ITriggerCollection {
-        x: number,
-        y: number,
-        layer: IMapLayer
-    ): ITriggerCollection<TEnemy, THero> {
         if (!this.registry) {
             logger.warn(135);
             return new TriggerCollection([]);
@@ -62,8 +55,8 @@ export class TriggerCollector<
             const duplicate = new Set<number>();
             if (staticTrigger) {
                 // 有静态触发器
-                const lessTriggers: ITrigger<TEnemy, THero>[] = [];
+                const lessTriggers: ITrigger[] = [];
-                const greaterTriggers: ITrigger<TEnemy, THero>[] = [];
+                const greaterTriggers: ITrigger[] = [];
                 // 先收集所有的触发器，并记录重复情况
                 for (const tile of layer.dynamicLayer.getDynamicTilesAt(x, y)) {
                     const trigger = this.registry.create(tile.triggerType);
@@ -92,7 +85,7 @@ export class TriggerCollector<
                 return new TriggerCollection(arr);
             } else {
                 // 没有静态触发器
-                const triggers: ITrigger<TEnemy, THero>[] = [];
+                const triggers: ITrigger[] = [];
                 for (const tile of layer.dynamicLayer.getDynamicTilesAt(x, y)) {
                     const trigger = this.registry.create(tile.triggerType);
                     if (trigger) {
@@ -113,7 +106,7 @@ export class TriggerCollector<
         }
     }
 
-    attachRegistry(registry: ITriggerRegistry<TEnemy, THero> | null): void {
+    attachRegistry(registry: ITriggerRegistry | null): void {
         this.registry = registry;
     }
 }

packages-user/data-system/src/trigger/registry.ts

@@ -2,28 +2,24 @@ import { logger } from '@motajs/common';
 import { ITrigger, ITriggerRegistry, TriggerFactory } from './types';
 import { IStateBase } from '@user/data-base';
 
-export class TriggerRegistry<
+export class TriggerRegistry implements ITriggerRegistry {
-    TEnemy = unknown,
-    THero = unknown
-> implements ITriggerRegistry<TEnemy, THero> {
     /** 数字类型到触发器工厂的映射 */
-    private readonly typeMap: Map<number, TriggerFactory<TEnemy, THero>> =
+    private readonly typeMap: Map<number, TriggerFactory> = new Map();
-        new Map();
 
-    constructor(public readonly state: IStateBase<TEnemy, THero>) {}
+    constructor(public readonly state: IStateBase) {}
 
-    register(type: number, factory: TriggerFactory<TEnemy, THero>): void {
+    register(type: number, factory: TriggerFactory): void {
         if (this.typeMap.has(type)) {
             logger.warn(132, 'type', type.toString());
         }
         this.typeMap.set(type, factory);
     }
 
-    get(type: number): TriggerFactory<TEnemy, THero> | null {
+    get(type: number): TriggerFactory | null {
         return this.typeMap.get(type) ?? null;
     }
 
-    create(num: number): ITrigger<TEnemy, THero> | null {
+    create(num: number): ITrigger | null {
         const factory = this.get(num);
         if (!factory) return null;
         return factory(num, this.state);

packages-user/data-system/src/trigger/types.ts

@@ -6,9 +6,9 @@ import {
     IStateBaseExtended
 } from '@user/data-base';
 
-export interface ITriggerHandler<TEnemy = unknown, THero = unknown> {
+export interface ITriggerHandler {
     /** 当前全局状态对象 */
-    readonly state: IStateBase<TEnemy, THero>;
+    readonly state: IStateBase;
     /** 当前楼层状态对象 */
     readonly layer?: ILayerState;
     /** 当前参与触发的图层对象 */
@@ -17,15 +17,9 @@ export interface ITriggerHandler<TEnemy = unknown, THero = unknown> {
     readonly locator?: ITileLocator;
 }
 
-export type TriggerFactory<TEnemy, THero> = (
+export type TriggerFactory = (type: number, state: IStateBase) => ITrigger;
-    type: number,
-    state: IStateBase<TEnemy, THero>
-) => ITrigger<TEnemy, THero>;
 
-export interface ITrigger<
+export interface ITrigger extends IStateBaseExtended {
-    TEnemy = unknown,
-    THero = unknown
-> extends IStateBaseExtended<TEnemy, THero> {
     /** 触发器类型标识 */
     readonly type: number;
     /** 触发器优先级 */
@@ -35,39 +29,36 @@ export interface ITrigger<
      * 使用给定上下文触发当前触发器
      * @param handler 触发上下文对象
      */
-    trigger(handler: ITriggerHandler<TEnemy, THero>): Promise<void>;
+    trigger(handler: ITriggerHandler): Promise<void>;
 
     /**
      * 将当前触发器包装为单元素触发器集合
      */
-    collection(): ITriggerCollection<TEnemy, THero>;
+    collection(): ITriggerCollection;
 }
 
-export interface ITriggerRegistry<
+export interface ITriggerRegistry extends IStateBaseExtended {
-    TEnemy = unknown,
-    THero = unknown
-> extends IStateBaseExtended<TEnemy, THero> {
     /**
      * 注册一个按类型创建的触发器工厂
      * @param type 触发器类型
      * @param factory 触发器工厂函数
      */
-    register(type: number, factory: TriggerFactory<TEnemy, THero>): void;
+    register(type: number, factory: TriggerFactory): void;
 
     /**
      * 获取指定类型的触发器工厂
      * @param type 触发器类型
      */
-    get(type: number): TriggerFactory<TEnemy, THero> | null;
+    get(type: number): TriggerFactory | null;
 
     /**
      * 根据触发器类型创建一个触发器实例，如果对应工厂不存在则返回 `null`
      * @param num 触发器类型
      */
-    create(num: number): ITrigger<TEnemy, THero> | null;
+    create(num: number): ITrigger | null;
 }
 
-export interface ITriggerCollection<TEnemy, THero> {
+export interface ITriggerCollection {
     /**
      * 当前集合中的触发器数量
      */
@@ -77,62 +68,52 @@ export interface ITriggerCollection<TEnemy, THero> {
      * 顺序触发当前集合中的所有触发器
      * @param handler 初始触发上下文对象
      */
-    trigger(handler: ITriggerHandler<TEnemy, THero>): Promise<void>;
+    trigger(handler: ITriggerHandler): Promise<void>;
 
     /**
      * 逐个触发当前集合中的触发器，并允许为下一次推进提供新上下文
      * @param handler 初始触发上下文对象
      */
     triggerIter(
-        handler: ITriggerHandler<TEnemy, THero>
+        handler: ITriggerHandler
-    ): AsyncGenerator<
+    ): AsyncGenerator<ITrigger, void, ITriggerHandler | null>;
-        ITrigger<TEnemy, THero>,
-        void,
-        ITriggerHandler<TEnemy, THero> | null
-    >;
 
     /**
      * 迭代当前集合中的所有触发器
      */
-    iterate(): Iterable<ITrigger<TEnemy, THero>>;
+    iterate(): Iterable<ITrigger>;
 
     /**
      * 向集合末尾追加一个触发器
      * @param trigger 要追加的触发器
      */
-    push(trigger: ITrigger<TEnemy, THero>): void;
+    push(trigger: ITrigger): void;
 
     /**
      * 向集合头部插入一个触发器
      * @param trigger 要插入的触发器
      */
-    unshift(trigger: ITrigger<TEnemy, THero>): void;
+    unshift(trigger: ITrigger): void;
 
     /**
      * 将当前集合与其他集合顺序拼接为一个新集合
      * @param others 要拼接的其他集合
      */
-    concat(
+    concat(...others: ITriggerCollection[]): ITriggerCollection;
-        ...others: ITriggerCollection<TEnemy, THero>[]
-    ): ITriggerCollection<TEnemy, THero>;
 }
 
-export interface ITriggerCollector<TEnemy, THero> {
+export interface ITriggerCollector {
     /**
      * 收集指定图层中某一点的所有触发器
      * @param x 横坐标
      * @param y 纵坐标
      * @param layer 目标图层
      */
-    collect(
+    collect(x: number, y: number, layer: IMapLayer): ITriggerCollection;
-        x: number,
-        y: number,
-        layer: IMapLayer
-    ): ITriggerCollection<TEnemy, THero>;
 
     /**
      * 绑定或清除当前 collector 使用的注册表
      * @param registry 触发器注册表
      */
-    attachRegistry(registry: ITriggerRegistry<TEnemy, THero> | null): void;
+    attachRegistry(registry: ITriggerRegistry | null): void;
 }

packages-user/data-system/src/types.ts

@@ -1,17 +1,18 @@
 import { IStateBase } from '@user/data-base';
 import { IEnemyContext } from './combat';
 import { ITriggerCollector, ITriggerRegistry } from './trigger';
+import { IEnemyAttr, IHeroAttr } from '@user/data-common';
 
-export interface IStateSystem<TEnemy, THero> extends IStateBase<TEnemy, THero> {
+export interface IStateSystem extends IStateBase {
     /** 怪物上下文 */
-    readonly enemyContext: IEnemyContext<TEnemy, THero>;
+    readonly enemyContext: IEnemyContext<IEnemyAttr, IHeroAttr>;
     /** 触发器注册 */
-    readonly triggerRegistry: ITriggerRegistry<TEnemy, THero>;
+    readonly triggerRegistry: ITriggerRegistry;
     /** 触发器收集器 */
-    readonly triggerCollector: ITriggerCollector<TEnemy, THero>;
+    readonly triggerCollector: ITriggerCollector;
 }
 
-export interface IStateSystemExtended<TEnemy = unknown, THero = unknown> {
+export interface IStateSystemExtended {
     /** 当前对象对应的执行层对象（Layer 2 对象） */
-    readonly state: IStateSystem<TEnemy, THero>;
+    readonly state: IStateSystem;
 }

packages/common/src/logger.json

@@ -193,6 +193,7 @@
         "133": "TileStore.addTile: tile number $1 already exists (id: '$2'), old tile data will be overridden.",
         "134": "TileStore.addTile: tile id '$1' already maps to number $2, old tile data will be overridden.",
         "135": "Expected a trigger registry attched before collect triggers.",
-        "136": "Unexpected duplicate trigger priority $1, which may cause trigger executed in an unexpected order."
+        "136": "Unexpected duplicate trigger priority $1, which may cause trigger executed in an unexpected order.",
+        "137": "Unknown guard enemy at locator '$1,$2'."
     }
 }