Release Healer Man 0.1.36

src/game/dungeonWallCombat.test.ts

@@ -0,0 +1,139 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { useCombatStore } from "./combatStore";
+import { registerCombatSpatialProvider, resetCombatSpatialProvider } from "./combatSpatial";
+import { clearMobRuntimeRegistry, setMobPosition } from "./mobRuntimeRegistry";
+import { clearPartyRuntimeRegistry } from "./partyRuntimeRegistry";
+import { usePartyStore } from "./partyStore";
+import { advanceDungeonPartyCombat, resetPartyRuntimeClock } from "./partyRuntime";
+import { registerPartyRuntimePosition, updatePartyRuntimeTargetVisibility } from "./partyRuntimeRegistry";
+import { DEFAULT_ENEMY_ATTACK, type EnemyAttackDefinition } from "./enemyAttacks";
+import { createMobPursuit } from "./mobPursuit";
+import { subscribeCombatPresentation, type CombatPresentationEvent } from "./combatPresentation";
+
+let visible = true;
+const melee = { ...DEFAULT_ENEMY_ATTACK, id: "swing", range: 4, initialCooldownMs: [0, 0] as const };
+const spell: EnemyAttackDefinition = { ...melee, id: "bolt", range: 30, school: "shadow", animation: "cast", castTimeMs: 1_000 };
+function register(id = "enemy", attacks: readonly EnemyAttackDefinition[] = [melee]) {
+  setMobPosition(id, [2, 0, 0]);
+  useCombatStore.getState().registerMob(id, { name: id, attacks, maxHealth: 1_000, xpReward: 0 });
+  useCombatStore.getState().damageMob(id, 1, 1_000);
+}
+
+describe("dungeon wall combat authorization", () => {
+  beforeEach(() => {
+    resetCombatSpatialProvider(); clearMobRuntimeRegistry(); clearPartyRuntimeRegistry(); resetPartyRuntimeClock();
+    useCombatStore.getState().initializeCharacter({ classId: "priest", level: 20 });
+    useCombatStore.getState().setPlayerPosition([0, 0, 0]);
+    usePartyStore.getState().initializeParty("walls", 20, useCombatStore.getState().health);
+    visible = true;
+    registerCombatSpatialProvider({ actor: () => null, hasLineOfSight: () => visible, projectGroundPoint: (point) => point });
+  });
+  afterEach(resetCombatSpatialProvider);
+
+  it("does not swing or consume an attack cooldown through a wall despite melee distance", () => {
+    register(); visible = false;
+    const health = useCombatStore.getState().health;
+    const events: CombatPresentationEvent[] = [];
+    const unsubscribe = subscribeCombatPresentation((message) => { if (message.kind === "event") events.push(message.event); });
+    expect(useCombatStore.getState().advanceMobCombat(2_000)).toBe(0);
+    expect(useCombatStore.getState().mobs.enemy).toMatchObject({ combatPhase: "chasing", attackRevision: 0 });
+    expect(useCombatStore.getState().health).toBe(health);
+    expect(events.filter((event) => event.sourceActorId === "enemy")).toHaveLength(0);
+    visible = true;
+    expect(useCombatStore.getState().advanceMobCombat(2_100)).toBeGreaterThan(0);
+    expect(useCombatStore.getState().mobs.enemy.combatPhase).toBe("attacking");
+    unsubscribe();
+  });
+
+  it("does not start an obstructed cast and cancels a pending cast when sight is lost", () => {
+    register("enemy", [spell]); visible = false;
+    useCombatStore.getState().advanceMobCombat(1_000);
+    expect(useCombatStore.getState().mobs.enemy.activeCast).toBeNull();
+    visible = true;
+    useCombatStore.getState().advanceMobCombat(1_100);
+    expect(useCombatStore.getState().mobs.enemy.activeCast).not.toBeNull();
+    const health = useCombatStore.getState().health;
+    visible = false;
+    expect(useCombatStore.getState().advanceMobCombat(1_200)).toBe(0);
+    expect(useCombatStore.getState().mobs.enemy).toMatchObject({ activeCast: null, combatPhase: "chasing", attackRevision: 0 });
+    expect(useCombatStore.getState().health).toBe(health);
+  });
+
+  it("does not let a self buff keep a wall-blocked melee mob in attack mode", () => {
+    register("enemy", [melee, { ...melee, id: "buff", target: "self", effect: { kind: "aura", aura: "enrage", durationMs: 10_000 } }]);
+    visible = false;
+    useCombatStore.getState().advanceMobCombat(2_000);
+    expect(useCombatStore.getState().mobs.enemy.combatPhase).toBe("chasing");
+  });
+
+  it("does not proximity-pull a visible-distance mob through a wall", () => {
+    setMobPosition("idle", [2, 0, 0]);
+    useCombatStore.getState().registerMob("idle", { name: "idle", attacks: [melee] });
+    visible = false;
+    expect(useCombatStore.getState().engageNearbyMobs(1_000)).toBe(0);
+    visible = true;
+    expect(useCombatStore.getState().engageNearbyMobs(1_001)).toBe(1);
+  });
+
+  it("resets only the stuck living mob, clears its threat/cast, restores health, and delays repulls", () => {
+    register("enemy", [spell]); register("other");
+    useCombatStore.getState().advanceMobCombat(1_000);
+    const other = useCombatStore.getState().mobs.other;
+    expect(useCombatStore.getState().resetMobForNavigation("enemy", true, 2_000)).toBe(true);
+    expect(useCombatStore.getState().mobs.enemy).toMatchObject({ health: 1_000, engaged: false,
+      combatPhase: "idle", activeCast: null, targetActorId: null, threatByActor: {}, navigationEvadeUntil: 12_000,
+      dead: false, experienceGranted: false });
+    expect(useCombatStore.getState().mobs.other).toBe(other);
+    expect(useCombatStore.getState().engageNearbyMobs(11_999)).toBe(0);
+    expect(useCombatStore.getState().engageNearbyMobs(12_000)).toBe(1);
+  });
+
+  it("does not recover or resurrect a dead mob", () => {
+    register();
+    useCombatStore.getState().damageMob("enemy", 10_000, 2_000);
+    expect(useCombatStore.getState().resetMobForNavigation("enemy", true, 3_000)).toBe(false);
+    expect(useCombatStore.getState().mobs.enemy.dead).toBe(true);
+  });
+
+  it("rejects damage against a navigation-reset mob during its evade cooldown", () => {
+    register();
+    useCombatStore.getState().resetMobForNavigation("enemy", true, 2_000);
+    expect(useCombatStore.getState().damageMob("enemy", 500, 3_000).amount).toBe(0);
+    expect(useCombatStore.getState().tauntMob("enemy", { actorId: "__player__", role: "healer" }, 3_000, 3_000)).toBe(false);
+    expect(useCombatStore.getState().mobs.enemy.health).toBe(1_000);
+  });
+
+  it("cancels an NPC teammate's hostile cast immediately on lost sight so it can pursue", () => {
+    register();
+    const member = usePartyStore.getState().members[0];
+    registerPartyRuntimePosition(member.id, [0, 0, 0]);
+    updatePartyRuntimeTargetVisibility(member.id, "enemy", true);
+    usePartyStore.setState((state) => ({ members: state.members.map((candidate) => candidate.id === member.id
+      ? { ...candidate, activeCastTargetId: "enemy", activeCast: {
+        abilityId: "mage-frostbolt", school: "frost", mode: "cast", startedAt: 1_000,
+        completesAt: 5_000, originalDurationMs: 4_000, pushbackHits: 0,
+        origin: [0, 0, 0] as const, targetId: "enemy",
+      } } : candidate) }));
+    visible = false;
+    advanceDungeonPartyCombat(1_100);
+    expect(usePartyStore.getState().members[0]).toMatchObject({ activeCast: null, status: "advancing" });
+  });
+
+  it("nearby teleport recovery leaves mob health, threat, target, and other mobs unchanged", () => {
+    register(); register("other");
+    const before = useCombatStore.getState().mobs;
+    const navigator = createMobPursuit({ graph: () => null, hasLineOfSight: (from) => from[0] > 2,
+      directAllowed: () => false, routeAllowed: () => true, validateLanding: (point) => point });
+    const position: [number, number, number] = [0, 0, 0];
+    const sample = { id: "enemy", targetId: "tank", position, target: [4, 0, 0] as const,
+      home: [0, 0, 0] as const, phase: "chasing" as const, health: before.enemy.health,
+      engaged: true, active: true, casting: false, controlled: false, attackRange: 1.5,
+      leashRange: 40, maximumStep: 0, nowMs: 0 };
+    navigator.step(sample);
+    navigator.step({ ...sample, nowMs: 2_000 });
+    expect(navigator.step({ ...sample, nowMs: 5_000 })).toBe("teleported");
+    expect(position[0]).toBeGreaterThan(2);
+    expect(useCombatStore.getState().mobs.enemy).toBe(before.enemy);
+    expect(useCombatStore.getState().mobs.other).toBe(before.other);
+  });
+});