diff --git a/.planning/phases/06-unit-tests/06-COVERAGE-MAP.md b/.planning/phases/06-unit-tests/06-COVERAGE-MAP.md index df3b82f..f7b73e3 100644 --- a/.planning/phases/06-unit-tests/06-COVERAGE-MAP.md +++ b/.planning/phases/06-unit-tests/06-COVERAGE-MAP.md @@ -12,6 +12,15 @@ | 100 | combat/context.ts | `warns 100 when both add and delete are non-empty` | 06-01 | | 101 | combat/context.ts | `warns 101 when a local refresh removes a converted special`、`warns 101 when a local refresh adds a converted special` | 06-01 | | 110 | combat/context.ts | `warns 110 and skips buildup without a bound hero` | 06-01 | +| 106 | combat/damage.ts | `warns 106 when the calculator is missing` | 06-01 | +| 107 | combat/damage.ts | `warns 107 when hero status is missing` | 06-01 | +| 102 | combat/mapDamage.ts | `warns 102 when the converter is missing during a full refresh` | 06-01 | +| 103 | combat/mapDamage.ts | `warns 103 when the reducer is missing` | 06-01 | +| 104 | combat/mapDamage.ts | `warns 104 when marking an unregistered enemy dirty` | 06-01 | +| 138 | combat/combat.ts | `warns 138 for collaborators bound to a foreign state` | 06-01 | +| 139 | combat/combat.ts | `warns 139 when a required collaborator is missing` | 06-01 | +| 140 | combat/combat.ts | `sorts scripts by descending priority and rejects duplicates` | 06-01 | +| 141 | combat/combat.ts | `warns 141 when the damage context cannot produce damage info` | 06-01 | ## 06-01 战斗系统（packages-user/data-system/src/combat） @@ -21,4 +30,5 @@ 138 / 139 / 140 / 141 → `combat/combat.ts`（`CombatFlow`）。105 在当前实现不可达，排除。 阶段 1（构件级）不产生 warn/error 码断言。阶段 2（组合/流水线）已完成 97/98/99/100/101/110； -106/107/102/103/104/138/139/140/141 对应的具体用例名将在阶段 3 完成后补全。 +阶段 3（完整/集成）已完成 106/107/102/103/104/138/139/140/141。105 在当前实现不可达，排除。 +`#06-01-1..4` 为疑似缺陷的 `it.skip` 正确预期用例，详见 `06-TEST-FINDINGS.md`。 diff --git a/.planning/phases/06-unit-tests/06-TEST-FINDINGS.md b/.planning/phases/06-unit-tests/06-TEST-FINDINGS.md index d2ef3dd..efefefc 100644 --- a/.planning/phases/06-unit-tests/06-TEST-FINDINGS.md +++ b/.planning/phases/06-unit-tests/06-TEST-FINDINGS.md @@ -26,6 +26,7 @@ | `damage.ts` `DamageContext.calculateCritical` / `findNextCritical` | 产出的临界点 `info` 与 `nextValue` 不对应 | 假计算器 `damage = 100 - atk * 10`、`getCriticalLimit = 10`、当前 `atk = 0`；首个临界点 `nextValue = 1`（正确伤害应为 90），但 `info.damage = 0`、`damageDiff = -100` | `findNextCritical` 在 `middleInfo.damage < referenceDamage` 分支只更新 `right`，从不更新 `targetInfo`，`targetInfo` 一直停留在初始 `upperLimit` 处的计算结果 | 临界点查询（数值提示、战斗模拟）展示的伤害与对应属性值不匹配 | 在 `middleInfo.damage < referenceDamage` 分支同步 `targetInfo = middleInfo`，或二分结束后按最终 `right` 重新计算一次 | `damage.test.ts` `reports the damage info matching the yielded critical value`（#06-01-1） | 中 | | `mapDamage.ts` `MapDamage.deleteEnemy` | 删除怪物后，该怪物产生的有来源地图伤害仍然存在 | 注册一个怪物视图并转换出伤害（假视图伤害 7）→ `getSeparatedDamage` 有 1 条 → `deleteEnemy(view)` → `getSeparatedDamage` 仍有 1 条（正确应为 0） | `viewStore` 与 `damageStore` 只在读/删路径出现，全文件没有任何 `.set(...)` 写入，因此 `deleteEnemy` / `removeEnemyAffecting` 中 `viewStore.get(viewItem)` 恒为 `undefined`，清理循环被整体跳过；`sourcedDamage` 点位与 `affectedBy` 都不会被移除 | 怪物死亡/离场后地图伤害不消失，`getSeparatedDamage` / `getReducedDamage` 继续返回幽灵伤害，并会污染后续 `refreshIndex` 的重新聚合 | 在 `refreshEnemy` / `refreshEnemyAndClearCache` 建立 sourced 伤害时同步写入 `viewStore.set(viewItem, { damages, enemy })` 与 `damageStore.set(damage, { sourceView, sourceEnemy, index })`，或改为在 `deleteEnemy` 中直接遍历 `sourcedDamage` 的 `affectedBy` 反向清理 | `mapDamage.test.ts` `removes enemy-sourced damage when the enemy is deleted`（#06-01-2） | 中 | | `combat.ts` `CombatFlow.combatFlow` / `ICombatScript.before` | 实现与接口文档语义相反：接口声明返回 `false` 放弃战斗，实现却在返回**真值**时短路 | 加载一个 `onBeforeCombat` 钩子，脚本 `before` 返回 `false`；`battle()` 仍会执行该钩子（正确实现应直接返回并放弃） | `const skip = await script.before(...); if (skip) return damage;` 以真值短路，与文档「返回 false 会立刻停止并放弃此次战斗」相反；文档或实现其一有误 | 所有战斗脚本的短路约定：按接口文档编写的脚本会得到相反效果，可能漏战或误战 | 先与接口设计者确认语义，再二选一统一：以 `true` 短路为准则修正接口注释，以文档为准则改为 `if (!skip) return damage;` | `combat.test.ts` `abandons the battle when the before script returns false`（#06-01-3） | 中 | +| `context.ts` `EnemyContext.buildup` | 重复调用 `buildup()` 会重复累加光环效果，而非从原始怪物重新计算 | 绑定勇士 → 放置基础 `atk = 2` 且带特殊属性的怪物（假转换器产出 `atk + 5` 的光环）→ `buildup()`（计算后 `atk = 7`）→ `addAura`（全局光环 `atk + 10`）→ `buildup()`；正确应为 `2 + 5 + 10 = 17`，实际为 `22`（`+5` 又被叠加一次） | `buildup` 只清空光环拓扑（`sortedAura` / `convertedAura` 等），未像 `refreshEnemy` 那样对每个视图调用 `reset()` 把计算后怪物恢复至原始怪物，导致 `buildupBase` / `buildupQuery` / `buildupFinal` 在既有计算结果上继续叠加 | 任何在已有怪物视图上再次触发的全量构建（重新绑定勇士、注册/注销光环转换器或效果后再构建）都会放大怪物属性 | 在 `buildup` 进入各效果阶段前对每个视图调用 `reset()`，或在重建开始时重建全部计算后怪物 | `damage.test.ts` `recomputes a repeat buildup from the base enemy without compounding`（#06-01-4） | 中 | ## #06-02 顶层战斗实现（data-state/src/enemy） diff --git a/packages-user/data-system/src/combat/combat.test.ts b/packages-user/data-system/src/combat/combat.test.ts index 544c2c3..cb7636b 100644 --- a/packages-user/data-system/src/combat/combat.test.ts +++ b/packages-user/data-system/src/combat/combat.test.ts @@ -1,4 +1,4 @@ -// 测试战斗流程：同源绑定与外来绑定、脚本优先级与去重、缺参告警 139/141、真实计时器下的 await 顺序 +// 测试战斗流程：同源绑定与外来绑定、脚本优先级与去重、缺参告警 139/141、非地图与独立怪物流程、真实计时器下的 await 顺序 import { beforeAll, describe, expect, it, vi } from 'vitest'; import { type ITileLocator } from '@motajs/common'; import { @@ -358,6 +358,61 @@ describe('CombatFlow scripts and guards', () => { expect(info).toBe(fixture.info); }); + + // 验证怪物无法解析出地图位置时战斗信息对象标记为非地图状态 + it('marks the combat handler as off-map when no locator can be resolved', async () => { + const fixture = createFixture(); + const context = { + state: fixture.state, + getEnemyLocatorByView: () => null, + getEnemyLocator: () => null, + getViewByComputed: () => null, + getEnemyByLocator: () => null, + getEnemyByLoc: () => null + } as never; + fixture.flow.bindContext(context); + fixture.flow.bindHero(fixture.hero); + fixture.flow.bindDamage(fixture.damage); + let onMap: boolean | null = null; + fixture.flow.addCombatScript({ + priority: 1, + before: async (_info, handler) => { + onMap = handler.onMap; + return false; + }, + after: async () => {} + }); + + const info = await fixture.flow.battle(fixture.view); + + expect(info).toBe(fixture.info); + expect(onMap).toBe(false); + }); + + // 验证未登记的怪物对象会走独立战斗流程并返回伤害信息 + it('battles an unregistered computed enemy through the standalone path', async () => { + const fixture = createFixture(); + const context = { + state: fixture.state, + getEnemyLocatorByView: () => null, + getEnemyLocator: () => null, + getViewByComputed: () => null, + getEnemyByLocator: () => null, + getEnemyByLoc: () => null + } as never; + fixture.flow.bindContext(context); + fixture.flow.bindHero(fixture.hero); + fixture.flow.bindDamage(fixture.damage); + const foreign = new modules.Enemy('foreign', 2, { + hp: 5, + atk: 1, + def: 0 + }); + + const info = await fixture.flow.battleComputed(foreign.clone()); + + expect(info).toBe(fixture.info); + }); }); describe('CombatFlow async ordering', () => { diff --git a/packages-user/data-system/src/combat/damage.test.ts b/packages-user/data-system/src/combat/damage.test.ts index 7f9ff2e..4d99060 100644 --- a/packages-user/data-system/src/combat/damage.test.ts +++ b/packages-user/data-system/src/combat/damage.test.ts @@ -1,4 +1,4 @@ -// 测试战斗伤害上下文与伤害系统：结果展开、handler 身份、告警码 106/107、缓存与 with、临界生成 +// 测试战斗伤害上下文与伤害系统：结果展开、handler 身份、告警码 106/107、缓存与 with、临界生成、属性到伤害联动（D-26） import { beforeAll, describe, expect, it, vi } from 'vitest'; import { type ITileLocator } from '@motajs/common'; import { type IEnemy, type IStateBase } from '@user/data-base'; @@ -59,9 +59,11 @@ interface TestHeroAttr { interface TestModules { DamageContext: typeof import('./damage').DamageContext; DamageSystem: typeof import('./damage').DamageSystem; + EnemyContext: typeof import('./context').EnemyContext; HeroAttribute: typeof import('@user/data-base').HeroAttribute; Enemy: typeof import('@user/data-base').Enemy; MapLocIndexer: typeof import('@user/data-common').MapLocIndexer; + FullRange: typeof import('@motajs/common').FullRange; logger: typeof import('@motajs/common').logger; } @@ -71,15 +73,18 @@ beforeAll(async () => { vi.stubGlobal('main', { replayChecking: true }); vi.stubGlobal('location', { origin: 'http://localhost' }); const damageModule = await import('./damage'); + const contextModule = await import('./context'); const baseModule = await import('@user/data-base'); const commonModule = await import('@user/data-common'); const motaModule = await import('@motajs/common'); modules = { DamageContext: damageModule.DamageContext, DamageSystem: damageModule.DamageSystem, + EnemyContext: contextModule.EnemyContext, HeroAttribute: baseModule.HeroAttribute, Enemy: baseModule.Enemy, MapLocIndexer: commonModule.MapLocIndexer, + FullRange: motaModule.FullRange, logger: motaModule.logger }; }); @@ -218,6 +223,83 @@ function createHandler( }; } +/** + * 创建一个最小特殊属性对象，用于驱动真实怪物上下文的光环转换 + * @param code 特殊属性代码 + */ +function createSpecial(code: number): never { + return { code, clone: () => createSpecial(code) } as never; +} + +/** + * 创建一个按怪物攻击力线性换算伤害的计算器，用于验证属性到伤害的联动 + */ +class EnemyAttributeCalculator + implements IDamageCalculator +{ + /** calculate 调用次数 */ + calls: number = 0; + /** 每点怪物攻击力换算的伤害 */ + readonly damagePerAtk: number; + + /** + * @param damagePerAtk 每点怪物攻击力换算的伤害 + */ + constructor(damagePerAtk: number = 2) { + this.damagePerAtk = damagePerAtk; + } + + calculate( + handler: IReadonlyEnemyHandler + ): IEnemyDamageInfoBase { + this.calls++; + return { + damage: handler.enemy.getAttribute('atk') * this.damagePerAtk, + turn: 1 + }; + } + + getCriticalLimit(): number { + return 100; + } +} + +/** + * 创建一个按怪物攻击力换算伤害的测试计算器 + * @param damagePerAtk 每点怪物攻击力换算的伤害 + */ +function createCalculator(damagePerAtk: number = 2): EnemyAttributeCalculator { + return new EnemyAttributeCalculator(damagePerAtk); +} + +interface FakeConverterShape { + /** + * 判断特殊属性是否应被转换 + * @param special 特殊属性 + */ + shouldConvert(special: { code: number }): boolean; + + /** + * 将特殊属性转换为光环视图 + */ + convert(): unknown; +} + +/** + * 创建一个可驱动光环流水线的真实怪物上下文 + * @param converter 赋予上下文的测试用光环转换器 + */ +function createEnemyContext( + converter: FakeConverterShape +): InstanceType { + const context = new modules.EnemyContext( + {} as IStateBase + ); + context.resize(3, 3); + context.registerAuraConverter(converter as never); + return context; +} + describe('DamageContext behaviour', () => { // 验证已绑定计算器与勇士时按视图返回计算器结果，并携带正确身份的 handler it('returns calculator output with an identity handler for a view', () => { @@ -503,3 +585,130 @@ describe('DamageContext critical generation', () => { expect(first.damageDiff).toBe(-10); }); }); + +describe('DamageSystem attribute linkage', () => { + // 验证 getCalculator 在未设置时返回 null，设置后返回同一计算器 + it('exposes the current calculator through getCalculator', () => { + const fixture = createFixture(); + const system = new modules.DamageSystem(fixture.context); + + expect(system.getCalculator()).toBeNull(); + + const calculator = createCalculator(3); + system.useCalculator(calculator); + + expect(system.getCalculator()).toBe(calculator); + }); + + // 验证光环改属性后伤害系统按新属性重算，且全量构建会失效缓存（D-26） + it('reflects aura-modified attributes and invalidates the cache on buildup', () => { + const context = createEnemyContext({ + shouldConvert: special => special.code === 20, + convert: () => ({ + priority: 1, + range: new modules.FullRange(), + couldApplyBase: true, + couldApplySpecial: false, + getRangeParam: () => undefined, + apply: (handler: { enemy: IEnemy }) => + handler.enemy.addAttribute('atk', 5), + applySpecial: () => null + }) + }); + const hero = new modules.HeroAttribute({ + hp: 100, + atk: 0, + def: 0 + }); + context.bindHero(hero); + const enemy = new modules.Enemy('e1', 1, { + hp: 10, + atk: 2, + def: 0 + }); + enemy.addSpecial(createSpecial(20)); + context.setEnemyAt({ x: 0, y: 0 }, enemy); + const calculator = createCalculator(2); + const system = new modules.DamageSystem(context); + system.useCalculator(calculator); + context.attachDamageSystem(system); + + context.buildup(); + + const view = context.getEnemyByLoc(0, 0)!; + const first = system.getDamageInfo(view); + + expect(first?.damage).toBe(14); + expect(calculator.calls).toBe(1); + + expect(system.getDamageInfo(view)).toBe(first); + expect(calculator.calls).toBe(1); + + // setEnemyAt 换入更高攻击的怪物并重新构建，伤害随新属性重算 + const stronger = new modules.Enemy('e2', 1, { + hp: 10, + atk: 20, + def: 0 + }); + stronger.addSpecial(createSpecial(20)); + context.setEnemyAt({ x: 0, y: 0 }, stronger); + context.buildup(); + const newView = context.getEnemyByLoc(0, 0)!; + const second = system.getDamageInfo(newView); + + expect(second).not.toBe(first); + expect(second?.damage).toBe(50); + expect(calculator.calls).toBe(2); + + // clear 会清空伤害缓存，因此再次取用不再命中旧缓存而返回 null + context.clear(); + expect(system.getDamageInfo(newView)).toBeNull(); + }); + + // 疑似 bug：重复全量构建应从原始怪物重算而非在原计算值上累加，详见 06-TEST-FINDINGS.md #06-01-4，修复后取消 skip + it.skip('recomputes a repeat buildup from the base enemy without compounding', () => { + const context = createEnemyContext({ + shouldConvert: special => special.code === 20, + convert: () => ({ + priority: 1, + range: new modules.FullRange(), + couldApplyBase: true, + couldApplySpecial: false, + getRangeParam: () => undefined, + apply: (handler: { enemy: IEnemy }) => + handler.enemy.addAttribute('atk', 5), + applySpecial: () => null + }) + }); + context.bindHero( + new modules.HeroAttribute({ hp: 100, atk: 0, def: 0 }) + ); + const enemy = new modules.Enemy('e1', 1, { + hp: 10, + atk: 2, + def: 0 + }); + enemy.addSpecial(createSpecial(20)); + context.setEnemyAt({ x: 0, y: 0 }, enemy); + context.buildup(); + context.addAura({ + priority: 2, + range: new modules.FullRange(), + couldApplyBase: true, + couldApplySpecial: false, + getRangeParam: () => undefined, + apply: (handler: { enemy: IEnemy }) => + handler.enemy.addAttribute('atk', 10), + applySpecial: () => null + } as never); + + context.buildup(); + + expect( + context + .getEnemyByLoc(0, 0)! + .getComputedEnemy() + .getAttribute('atk') + ).toBe(17); + }); +}); diff --git a/packages-user/data-system/src/combat/mapDamage.test.ts b/packages-user/data-system/src/combat/mapDamage.test.ts index a78654a..fefd671 100644 --- a/packages-user/data-system/src/combat/mapDamage.test.ts +++ b/packages-user/data-system/src/combat/mapDamage.test.ts @@ -1,4 +1,4 @@ -// 测试地图伤害：无来源伤害增删、有来源转换与合并、告警码 102/103/104、分离伤害合并与 deleteEnemy +// 测试地图伤害：无来源伤害增删、有来源转换与合并、告警码 102/103/104、分离伤害合并、deleteEnemy 与 markEnemyDirty import { beforeAll, describe, expect, it, vi } from 'vitest'; import { type IRange, @@ -170,12 +170,15 @@ class FakeConverter { /** 转换输出的伤害视图 */ readonly views: IMapDamageView[]; + /** convert 调用次数 */ + calls: number = 0; constructor(views: IMapDamageView[]) { this.views = views; } convert(): IMapDamageView[] { + this.calls++; return this.views; } } @@ -422,6 +425,37 @@ describe('MapDamage sourced conversion and reduction', () => { expect(result.info.map(v => v.code)).toContain(104); }); + // 验证已注册怪物的 markEnemyDirty 会按其视图重新转换有来源伤害 + it('refreshes sourced damage when a registered enemy is marked dirty', () => { + const fixture = createFixture(); + fixture.damage.useReducer(fixture.reducer); + fixture.damage.useConverter(fixture.converter); + expect(fixture.converter.calls).toBe(1); + + fixture.damage.markEnemyDirty(fixture.view); + + expect(fixture.converter.calls).toBe(2); + expect( + [...fixture.damage.getSeparatedDamage(fixture.locator)][0].damage + ).toBe(7); + }); + + // 验证删除未注册怪物不产生任何有来源伤害变化 + it('ignores deleting an enemy without sourced damage', () => { + const fixture = createFixture(); + fixture.damage.useReducer(fixture.reducer); + fixture.damage.useConverter(fixture.converter); + const before = [ + ...fixture.damage.getSeparatedDamage(fixture.locator) + ].length; + + fixture.damage.deleteEnemy(createUnknownView(fixture)); + + expect( + [...fixture.damage.getSeparatedDamage(fixture.locator)] + ).toHaveLength(before); + }); + // 疑似 bug：deleteEnemy 应移除该怪物带来的有来源地图伤害，详见 06-TEST-FINDINGS.md #06-01-2，修复后取消 skip it.skip('removes enemy-sourced damage when the enemy is deleted', () => { const fixture = createFixture();