683 lines
32 KiB
TypeScript
683 lines
32 KiB
TypeScript
import { beforeEach, describe, expect, it } from "vitest";
|
|
import { useCombatStore } from "./combatStore";
|
|
import { clearMobRuntimeRegistry, setMobPosition } from "./mobRuntimeRegistry";
|
|
import {
|
|
clearPartyRuntimeRegistry,
|
|
registerPartyRuntimePosition,
|
|
updatePartyRuntimeAttackCorridor,
|
|
updatePartyRuntimeTargetVisibility,
|
|
beginPartyRuntimeRejoin,
|
|
finishPartyRuntimeRejoin,
|
|
} from "./partyRuntimeRegistry";
|
|
import {
|
|
activePartyTargetId,
|
|
advanceDungeonPartyCombat,
|
|
applyHealerSupport,
|
|
partyAttackDamage,
|
|
partyCombatRangeBand,
|
|
partyCommandTargetId,
|
|
partyUsesRangedAttacks,
|
|
resetPartyRuntimeClock,
|
|
} from "./partyRuntime";
|
|
import { createConfiguredPartyMember, usePartyStore } from "./partyStore";
|
|
import { EMPTY_ITEM_STATS } from "./itemStats";
|
|
import { subscribeCombatPresentation, type CombatPresentationEvent } from "./combatPresentation";
|
|
import { subscribeCombatEvents, type StructuredCombatEvent } from "./combatEvents";
|
|
import { abilitiesForClass } from "./abilityCatalog";
|
|
import { runtimePartyTalentRanksForLevel } from "./partyTalentRuntime";
|
|
import { baseClassFor } from "../app/characterCatalog";
|
|
|
|
function registerEngagedMob(id = "pack:a", maxHealth = 200): void {
|
|
useCombatStore.getState().registerMob(id, { name: id, maxHealth, xpReward: 0 });
|
|
setMobPosition(id, [2, 0, 0]);
|
|
useCombatStore.getState().damageMob(id, 1, 100);
|
|
for (const member of usePartyStore.getState().members) {
|
|
updatePartyRuntimeTargetVisibility(member.id, id, true);
|
|
}
|
|
}
|
|
|
|
describe("party combat runtime", () => {
|
|
beforeEach(() => {
|
|
clearMobRuntimeRegistry();
|
|
clearPartyRuntimeRegistry();
|
|
resetPartyRuntimeClock();
|
|
useCombatStore.getState().initializeCharacter({ classId: "priest", level: 5 });
|
|
usePartyStore.getState().initializeParty("runtime-party", 5, useCombatStore.getState().health);
|
|
});
|
|
|
|
it("prefers the selected engaged target, then a living engaged pack member", () => {
|
|
registerEngagedMob("pack:a");
|
|
registerEngagedMob("pack:b");
|
|
const mobs = useCombatStore.getState().mobs;
|
|
expect(activePartyTargetId(mobs, "pack:b")).toBe("pack:b");
|
|
expect(activePartyTargetId(mobs, null)).toBe("pack:a");
|
|
});
|
|
|
|
it("maintains HoTs on separate injured allies without resetting pending ticks", () => {
|
|
useCombatStore.getState().initializeCharacter({ classId: "mage", role: "damage", level: 8 });
|
|
usePartyStore.getState().initializeParty("party-hot-coverage", 8, useCombatStore.getState().health, "damage");
|
|
const healer = usePartyStore.getState().members.find(member => member.role === "healer")!;
|
|
const abilities = abilitiesForClass("druid");
|
|
const hot = abilities.find(ability => ability.name === "Rejuvenation")!;
|
|
usePartyStore.setState(state => ({ members: state.members.map(member => member.id === healer.id
|
|
? { ...member, classId: "druid", resourceType: "mana", resource: 10_000, maxResource: 10_000,
|
|
resourcePools: { mana: 10_000 }, talentRanks: {}, cooldowns: Object.fromEntries(abilities.filter(a => a.id !== hot.id).map(a => [a.id, 60_000])) }
|
|
: { ...member, health: member.maxHealth * .5 }) }));
|
|
for (const member of usePartyStore.getState().members) registerPartyRuntimePosition(member.id, [0, 0, 0]);
|
|
useCombatStore.getState().synchronizeActors();
|
|
registerEngagedMob("hot-boss", 100_000);
|
|
advanceDungeonPartyCombat(1_000);
|
|
const first = useCombatStore.getState().effects.find(effect => effect.kind === "hot" && effect.sourceActorId === healer.id)!;
|
|
expect(first).toBeDefined();
|
|
advanceDungeonPartyCombat(3_000);
|
|
const effects = useCombatStore.getState().effects.filter(effect => effect.kind === "hot" && effect.sourceActorId === healer.id);
|
|
expect(new Set(effects.map(effect => effect.targetId)).size).toBe(2);
|
|
expect(effects.find(effect => effect.targetId === first.targetId)?.nextTickAt).toBe(first.nextTickAt);
|
|
});
|
|
|
|
it("precasts Earth Shield on the tank while the Restoration Shaman is at full health", () => {
|
|
useCombatStore.getState().initializeCharacter({ classId: "mage", role: "damage", level: 80 });
|
|
const tank = createConfiguredPartyMember({
|
|
name: "Tank",
|
|
classId: "warrior",
|
|
specialization: "Protection",
|
|
specializationId: "warrior:protection",
|
|
talentTreeId: "warrior-protection",
|
|
role: "tank",
|
|
}, 80, 0, "earth-shield-runtime");
|
|
const healer = createConfiguredPartyMember({
|
|
name: "Healer",
|
|
classId: "shaman",
|
|
specialization: "Restoration",
|
|
specializationId: "shaman:restoration",
|
|
talentTreeId: "shaman-restoration",
|
|
role: "healer",
|
|
}, 80, 1, "earth-shield-runtime");
|
|
usePartyStore.getState().initializeParty("earth-shield-runtime", 80, useCombatStore.getState().health, "damage");
|
|
usePartyStore.setState({ members: [tank, healer] });
|
|
registerPartyRuntimePosition(tank.id, [0, 0, 0]);
|
|
registerPartyRuntimePosition(healer.id, [-12, 0, 0]);
|
|
useCombatStore.getState().synchronizeActors();
|
|
useCombatStore.getState().registerMob("earth-shield-boss", {
|
|
name: "Earth Shield boss", boss: true, maxHealth: 100_000, xpReward: 0,
|
|
});
|
|
setMobPosition("earth-shield-boss", [2, 0, 0]);
|
|
useCombatStore.getState().damageMob("earth-shield-boss", 1, 100);
|
|
updatePartyRuntimeTargetVisibility(tank.id, "earth-shield-boss", true);
|
|
updatePartyRuntimeTargetVisibility(healer.id, "earth-shield-boss", true);
|
|
|
|
for (const now of [1_000, 2_500, 4_000]) advanceDungeonPartyCombat(now);
|
|
|
|
expect(useCombatStore.getState().auras.some((aura) => (
|
|
aura.sourceId === healer.id
|
|
&& aura.targetId === tank.id
|
|
&& aura.definition.exclusiveGroup === "shaman:earth-shield"
|
|
))).toBe(true);
|
|
});
|
|
|
|
it("turns Feral Spirit into two live Enhancement summons against a boss", () => {
|
|
useCombatStore.getState().initializeCharacter({ classId: "mage", role: "damage", level: 80 });
|
|
const shaman = createConfiguredPartyMember({
|
|
name: "Enhancement",
|
|
classId: "shaman",
|
|
specialization: "Enhancement",
|
|
specializationId: "shaman:enhancement",
|
|
talentTreeId: "shaman-enhancement",
|
|
role: "damage",
|
|
}, 80, 0, "feral-spirit-runtime");
|
|
usePartyStore.getState().initializeParty("feral-spirit-runtime", 80, useCombatStore.getState().health, "damage");
|
|
usePartyStore.setState({ members: [shaman] });
|
|
registerPartyRuntimePosition(shaman.id, [0, 0, 0]);
|
|
useCombatStore.getState().synchronizeActors();
|
|
useCombatStore.getState().registerMob("feral-spirit-boss", {
|
|
name: "Feral Spirit boss", boss: true, maxHealth: 100_000, xpReward: 0,
|
|
});
|
|
setMobPosition("feral-spirit-boss", [2, 0, 0]);
|
|
useCombatStore.getState().damageMob("feral-spirit-boss", 1, 100);
|
|
updatePartyRuntimeTargetVisibility(shaman.id, "feral-spirit-boss", true);
|
|
for (const now of [1_000, 2_500, 4_000, 5_500, 7_000]) advanceDungeonPartyCombat(now);
|
|
|
|
const feralSpirit = abilitiesForClass("shaman").find((ability) => ability.name === "Feral Spirit")!;
|
|
expect(useCombatStore.getState().summons.filter((summon) => (
|
|
summon.ownerActorId === shaman.id && summon.sourceAbilityId === feralSpirit.id
|
|
))).toHaveLength(2);
|
|
const beforeSummonAttack = useCombatStore.getState().mobs["feral-spirit-boss"].health;
|
|
useCombatStore.getState().tick(0.1, 10_000);
|
|
expect(useCombatStore.getState().mobs["feral-spirit-boss"].health).toBeLessThan(beforeSummonAttack);
|
|
});
|
|
|
|
it("lets an Assassination companion stack poisons and scale Envenom from them", () => {
|
|
useCombatStore.getState().initializeCharacter({ classId: "mage", role: "damage", level: 80 });
|
|
const rogue = createConfiguredPartyMember({
|
|
name: "Assassination",
|
|
classId: "rogue",
|
|
specialization: "Assassination",
|
|
specializationId: "rogue:assassination",
|
|
talentTreeId: "rogue-assassination",
|
|
talentRanks: runtimePartyTalentRanksForLevel("rogue", "Assassination", 80),
|
|
role: "damage",
|
|
}, 80, 0, "assassination-poison-runtime");
|
|
usePartyStore.getState().initializeParty(
|
|
"assassination-poison-runtime",
|
|
80,
|
|
useCombatStore.getState().health,
|
|
"damage",
|
|
);
|
|
usePartyStore.setState({ members: [rogue] });
|
|
registerPartyRuntimePosition(rogue.id, [0, 0, 0]);
|
|
useCombatStore.getState().synchronizeActors();
|
|
useCombatStore.getState().applyPrecombatPreparation(500);
|
|
expect(useCombatStore.getState().auras.filter((aura) => (
|
|
aura.targetId === rogue.id && aura.definition.utilityTags?.includes("weapon-enchant")
|
|
))).toHaveLength(2);
|
|
|
|
registerEngagedMob("poison-runtime-boss", 10_000_000);
|
|
const events: StructuredCombatEvent[] = [];
|
|
const stop = subscribeCombatEvents((event) => events.push(event));
|
|
for (let now = 1_000; now <= 60_000; now += 100) {
|
|
useCombatStore.getState().tick(0.1, now);
|
|
advanceDungeonPartyCombat(now);
|
|
}
|
|
stop();
|
|
|
|
expect(events.some((event) => (
|
|
event.sourceActorId === rogue.id && event.abilityId === "rogue-instant-poison"
|
|
))).toBe(true);
|
|
expect(events.some((event) => (
|
|
event.sourceActorId === rogue.id && event.abilityId === "rogue-deadly-poison"
|
|
))).toBe(true);
|
|
expect(events.some((event) => (
|
|
event.sourceActorId === rogue.id
|
|
&& event.abilityId === "wow335-rogue-envenom"
|
|
&& event.school === "nature"
|
|
&& event.effectiveAmount > 0
|
|
))).toBe(true);
|
|
expect(events.some((event) => (
|
|
event.sourceActorId === rogue.id && event.abilityId === "wow335-rogue-shiv"
|
|
))).toBe(true);
|
|
expect(events.some((event) => (
|
|
event.sourceActorId === rogue.id && event.abilityId === "wow335-rogue-rupture"
|
|
))).toBe(false);
|
|
expect(useCombatStore.getState().auras.find((aura) => (
|
|
aura.sourceId === rogue.id
|
|
&& aura.targetId === "poison-runtime-boss"
|
|
&& aura.definition.utilityTags?.includes("rogue-deadly-poison-dose")
|
|
))?.stacks).toBe(5);
|
|
});
|
|
|
|
it("gives companion Hunter and Warlock pets a hostile target when summoned from self", () => {
|
|
useCombatStore.getState().initializeCharacter({ classId: "mage", role: "damage", level: 80 });
|
|
const hunter = createConfiguredPartyMember({
|
|
name: "Beast Mastery",
|
|
classId: "hunter",
|
|
specialization: "Beast Mastery",
|
|
specializationId: "hunter:beast-mastery",
|
|
talentTreeId: "hunter-beast-mastery",
|
|
role: "damage",
|
|
}, 80, 0, "pet-target-runtime");
|
|
const warlock = createConfiguredPartyMember({
|
|
name: "Demonology",
|
|
classId: "warlock",
|
|
specialization: "Demonology",
|
|
specializationId: "warlock:demonology",
|
|
talentTreeId: "warlock-demonology",
|
|
talentRanks: runtimePartyTalentRanksForLevel("warlock", "Demonology", 80),
|
|
role: "damage",
|
|
}, 80, 1, "pet-target-runtime");
|
|
usePartyStore.getState().initializeParty("pet-target-runtime", 80, useCombatStore.getState().health, "damage");
|
|
usePartyStore.setState({ members: [hunter, warlock] });
|
|
for (const member of usePartyStore.getState().members) registerPartyRuntimePosition(member.id, [-14.5, 0, 0]);
|
|
useCombatStore.getState().synchronizeActors();
|
|
registerEngagedMob("pet-runtime-boss", 100_000);
|
|
const events: StructuredCombatEvent[] = [];
|
|
const stop = subscribeCombatEvents((event) => events.push(event));
|
|
for (let now = 1_000; now <= 30_000; now += 100) {
|
|
useCombatStore.getState().tick(0.1, now);
|
|
advanceDungeonPartyCombat(now);
|
|
}
|
|
stop();
|
|
|
|
const pets = useCombatStore.getState().summons.filter((summon) => (
|
|
summon.ownerActorId === hunter.id || summon.ownerActorId === warlock.id
|
|
));
|
|
expect(new Set(pets.map((summon) => summon.ownerActorId))).toEqual(new Set([hunter.id, warlock.id]));
|
|
expect(pets.every((summon) => summon.targetId === "pet-runtime-boss")).toBe(true);
|
|
expect(events.filter((event) => event.kind === "damage"
|
|
&& [hunter.id, warlock.id].includes(event.sourceActorId))).toEqual(expect.arrayContaining([
|
|
expect.objectContaining({ abilityId: "wow335-hunter-call-pet" }),
|
|
expect.objectContaining({ abilityId: "wow335-warlock-summon-felguard" }),
|
|
]));
|
|
});
|
|
|
|
it("casts Power Word: Shield on an injured ally and grants absorb capacity", () => {
|
|
useCombatStore.getState().initializeCharacter({ classId: "mage", role: "damage", level: 80 });
|
|
const tank = createConfiguredPartyMember({
|
|
name: "Tank",
|
|
classId: "warrior",
|
|
specialization: "Protection",
|
|
specializationId: "warrior:protection",
|
|
talentTreeId: "warrior-protection",
|
|
role: "tank",
|
|
}, 80, 0, "discipline-shield-runtime");
|
|
const healer = createConfiguredPartyMember({
|
|
name: "Discipline",
|
|
classId: "priest",
|
|
specialization: "Discipline",
|
|
specializationId: "priest:discipline",
|
|
talentTreeId: "priest-discipline",
|
|
role: "healer",
|
|
}, 80, 1, "discipline-shield-runtime");
|
|
const priestAbilities = abilitiesForClass("priest");
|
|
const shield = priestAbilities.find((ability) => ability.name === "Power Word: Shield")!;
|
|
usePartyStore.getState().initializeParty("discipline-shield-runtime", 80, useCombatStore.getState().health, "damage");
|
|
usePartyStore.setState({
|
|
members: [
|
|
{ ...tank, health: Math.round(tank.maxHealth * 0.5) },
|
|
{
|
|
...healer,
|
|
resource: 100_000,
|
|
maxResource: 100_000,
|
|
resourcePools: { mana: 100_000 },
|
|
cooldowns: Object.fromEntries(priestAbilities.filter((ability) => ability.id !== shield.id)
|
|
.map((ability) => [ability.id, 60_000])),
|
|
},
|
|
],
|
|
});
|
|
for (const member of usePartyStore.getState().members) registerPartyRuntimePosition(member.id, [0, 0, 0]);
|
|
useCombatStore.getState().synchronizeActors();
|
|
registerEngagedMob("discipline-shield-boss", 100_000);
|
|
|
|
advanceDungeonPartyCombat(1_000);
|
|
|
|
const applied = useCombatStore.getState().auras.find((aura) => (
|
|
aura.sourceId === healer.id
|
|
&& aura.targetId === tank.id
|
|
&& aura.definition.name.includes("Power Word: Shield")
|
|
));
|
|
expect(applied?.absorbs.reduce((total, absorb) => total + absorb.remaining, 0)).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("casts Inner Focus before an emergency direct heal and makes that heal free", () => {
|
|
useCombatStore.getState().initializeCharacter({ classId: "mage", role: "damage", level: 80 });
|
|
const tank = createConfiguredPartyMember({
|
|
name: "Tank",
|
|
classId: "warrior",
|
|
specialization: "Protection",
|
|
specializationId: "warrior:protection",
|
|
talentTreeId: "warrior-protection",
|
|
role: "tank",
|
|
}, 80, 0, "inner-focus-runtime");
|
|
const healer = createConfiguredPartyMember({
|
|
name: "Discipline",
|
|
classId: "priest",
|
|
specialization: "Discipline",
|
|
specializationId: "priest:discipline",
|
|
talentTreeId: "priest-discipline",
|
|
talentRanks: runtimePartyTalentRanksForLevel("priest", "Discipline", 80),
|
|
role: "healer",
|
|
}, 80, 1, "inner-focus-runtime");
|
|
const priestAbilities = abilitiesForClass("priest");
|
|
const innerFocus = priestAbilities.find((ability) => ability.name === "Inner Focus")!;
|
|
const greaterHeal = priestAbilities.find((ability) => ability.name === "Greater Heal")!;
|
|
const startingHealth = Math.round(tank.maxHealth * 0.3);
|
|
usePartyStore.getState().initializeParty("inner-focus-runtime", 80, useCombatStore.getState().health, "damage");
|
|
usePartyStore.setState({
|
|
members: [
|
|
{ ...tank, health: startingHealth },
|
|
{
|
|
...healer,
|
|
resource: 0,
|
|
maxResource: 0,
|
|
resourcePools: { mana: 0 },
|
|
cooldowns: Object.fromEntries(priestAbilities
|
|
.filter((ability) => ![innerFocus.id, greaterHeal.id].includes(ability.id))
|
|
.map((ability) => [ability.id, 60_000])),
|
|
},
|
|
],
|
|
});
|
|
for (const member of usePartyStore.getState().members) registerPartyRuntimePosition(member.id, [0, 0, 0]);
|
|
useCombatStore.getState().synchronizeActors();
|
|
registerEngagedMob("inner-focus-boss", 100_000);
|
|
const events: CombatPresentationEvent[] = [];
|
|
const stop = subscribeCombatPresentation((message) => {
|
|
if (message.kind === "event" && message.event.sourceActorId === healer.id) events.push(message.event);
|
|
});
|
|
|
|
for (const now of [1_000, 2_500, 6_000]) advanceDungeonPartyCombat(now);
|
|
stop();
|
|
|
|
const releases = events.filter((event) => event.phase === "release").map((event) => event.name);
|
|
expect(releases).toEqual(expect.arrayContaining(["Inner Focus", "Greater Heal"]));
|
|
expect(releases.indexOf("Inner Focus")).toBeLessThan(releases.indexOf("Greater Heal"));
|
|
expect(usePartyStore.getState().members.find((member) => member.id === healer.id)?.resource).toBe(0);
|
|
expect(usePartyStore.getState().members.find((member) => member.id === tank.id)?.health)
|
|
.toBeGreaterThan(startingHealth);
|
|
});
|
|
|
|
it("lets a resurrected tank rejoin independently instead of taunting or casting from its checkpoint", () => {
|
|
registerEngagedMob();
|
|
const tank = usePartyStore.getState().members.find((member) => member.role === "tank")!;
|
|
for (const member of usePartyStore.getState().members) registerPartyRuntimePosition(member.id, [0, 0, 0]);
|
|
beginPartyRuntimeRejoin(tank.id, [1_000, 0, 0]);
|
|
const beforeHealth = useCombatStore.getState().mobs["pack:a"].health;
|
|
advanceDungeonPartyCombat(1_000);
|
|
expect(usePartyStore.getState().members.find((member) => member.id === tank.id))
|
|
.toMatchObject({ status: "advancing", activeCast: null, activeCastTargetId: null });
|
|
expect(usePartyStore.getState().memberTargetIds[tank.id]).toBeUndefined();
|
|
expect(useCombatStore.getState().mobs["pack:a"].forcedTarget?.actorId).not.toBe(tank.id);
|
|
expect(useCombatStore.getState().mobs["pack:a"].health).toBeLessThan(beforeHealth);
|
|
finishPartyRuntimeRejoin(tank.id);
|
|
registerPartyRuntimePosition(tank.id, [0, 0, 0]);
|
|
advanceDungeonPartyCombat(2_000);
|
|
expect(usePartyStore.getState().memberTargetIds[tank.id]).toBe("pack:a");
|
|
});
|
|
|
|
it("keeps returning teammates advancing during Stop, then resumes the party order when they arrive", () => {
|
|
const tank = usePartyStore.getState().members.find((member) => member.role === "tank")!;
|
|
usePartyStore.getState().setCommand("stop");
|
|
beginPartyRuntimeRejoin(tank.id, [0, 0, 0]);
|
|
advanceDungeonPartyCombat(1_000);
|
|
expect(usePartyStore.getState().members.find((member) => member.id === tank.id)?.status).toBe("advancing");
|
|
finishPartyRuntimeRejoin(tank.id);
|
|
advanceDungeonPartyCombat(2_000);
|
|
expect(usePartyStore.getState().command).toBe("stop");
|
|
expect(usePartyStore.getState().members.find((member) => member.id === tank.id)?.status).toBe("holding");
|
|
});
|
|
|
|
it("has the tank taunt the active mob while all damage allies attack it", () => {
|
|
registerEngagedMob();
|
|
for (const member of usePartyStore.getState().members) {
|
|
registerPartyRuntimePosition(member.id, [0, 0, 0]);
|
|
}
|
|
const beforeMobHealth = useCombatStore.getState().mobs["pack:a"].health;
|
|
const fullPlayerHealth = useCombatStore.getState().health;
|
|
const events: CombatPresentationEvent[] = [];
|
|
const unsubscribe = subscribeCombatPresentation((message) => {
|
|
if (message.kind === "event" && message.event.actorGroup === "party") events.push(message.event);
|
|
});
|
|
advanceDungeonPartyCombat(1_000);
|
|
|
|
const party = usePartyStore.getState();
|
|
const tank = party.members.find((member) => member.role === "tank")!;
|
|
expect(useCombatStore.getState().mobs["pack:a"]).toMatchObject({
|
|
targetActorId: tank.id,
|
|
forcedTarget: { actorId: tank.id, endsAt: 4_000 },
|
|
});
|
|
expect(party.memberTargetIds[tank.id]).toBe("pack:a");
|
|
expect(useCombatStore.getState().mobs["pack:a"].health).toBeLessThan(beforeMobHealth);
|
|
expect(party.members.filter((member) => member.nextActionAt > 1_000)).toHaveLength(4);
|
|
|
|
useCombatStore.getState().advanceMobCombat(3_000);
|
|
const woundedTank = usePartyStore.getState().members.find((member) => member.id === tank.id)!;
|
|
expect(woundedTank.health).toBeLessThan(woundedTank.maxHealth);
|
|
expect(useCombatStore.getState().health).toBe(fullPlayerHealth);
|
|
const instantReleases = events.filter((event) => event.phase === "release" && event.instantCast);
|
|
expect(instantReleases.length).toBeGreaterThan(0);
|
|
expect(instantReleases.every((event) => (
|
|
events.some((impact) => (
|
|
impact.phase === "impact"
|
|
&& impact.sourceActorId === event.sourceActorId
|
|
&& impact.abilityId === event.abilityId
|
|
&& impact.instantCast
|
|
))
|
|
))).toBe(true);
|
|
|
|
const actionRevisions = party.members.map((member) => member.nextActionAt);
|
|
advanceDungeonPartyCombat(1_100);
|
|
expect(usePartyStore.getState().members.map((member) => member.nextActionAt)).toEqual(actionRevisions);
|
|
unsubscribe();
|
|
});
|
|
|
|
it("keeps living companions in the fight while the player waits for resurrection", () => {
|
|
registerEngagedMob();
|
|
for (const member of usePartyStore.getState().members) {
|
|
registerPartyRuntimePosition(member.id, [0, 0, 0]);
|
|
}
|
|
useCombatStore.getState().damagePlayer(useCombatStore.getState().maxHealth * 10);
|
|
const beforeMobHealth = useCombatStore.getState().mobs["pack:a"].health;
|
|
|
|
advanceDungeonPartyCombat(1_000);
|
|
|
|
expect(useCombatStore.getState().health).toBe(0);
|
|
expect(useCombatStore.getState().mobs["pack:a"].health).toBeLessThan(beforeMobHealth);
|
|
});
|
|
|
|
it("assigns the tank to a loose mob attacking the healer before one attacking DPS", () => {
|
|
const party = usePartyStore.getState();
|
|
const tank = party.members.find((member) => member.role === "tank")!;
|
|
const healerId = "__player__";
|
|
const damage = party.members.find((member) => member.role === "damage")!;
|
|
for (const member of party.members) registerPartyRuntimePosition(member.id, [0, 0, 0]);
|
|
|
|
useCombatStore.getState().registerMob("loose:dps", { name: "DPS add", maxHealth: 200, xpReward: 0 });
|
|
useCombatStore.getState().registerMob("loose:healer", { name: "Healer add", maxHealth: 200, xpReward: 0 });
|
|
setMobPosition("loose:dps", [8, 0, 0]);
|
|
setMobPosition("loose:healer", [9, 0, 0]);
|
|
useCombatStore.getState().damageMob(
|
|
"loose:dps",
|
|
2,
|
|
100,
|
|
{ actorId: damage.id, role: "damage" },
|
|
);
|
|
useCombatStore.getState().damageMob(
|
|
"loose:healer",
|
|
2,
|
|
100,
|
|
{ actorId: healerId, role: "healer" },
|
|
);
|
|
for (const member of party.members) {
|
|
updatePartyRuntimeTargetVisibility(member.id, "loose:dps", true);
|
|
updatePartyRuntimeTargetVisibility(member.id, "loose:healer", true);
|
|
}
|
|
useCombatStore.getState().advanceMobCombat(200);
|
|
|
|
advanceDungeonPartyCombat(1_000);
|
|
|
|
expect(usePartyStore.getState().memberTargetIds[tank.id]).toBe("loose:healer");
|
|
expect(useCombatStore.getState().mobs["loose:healer"].forcedTarget).toMatchObject({
|
|
actorId: tank.id,
|
|
});
|
|
});
|
|
|
|
it("shares an eight-second tank taunt cooldown across loose mobs", () => {
|
|
const party = usePartyStore.getState();
|
|
const tank = party.members.find((member) => member.role === "tank")!;
|
|
const damages = party.members.filter((member) => member.role === "damage");
|
|
for (const member of party.members) registerPartyRuntimePosition(member.id, [0, 0, 0]);
|
|
for (const [index, id] of ["cooldown-a", "cooldown-b"].entries()) {
|
|
useCombatStore.getState().registerMob(id, { name: id, maxHealth: 200, xpReward: 0 });
|
|
setMobPosition(id, [10 + index, 0, 0]);
|
|
useCombatStore.getState().damageMob(id, 2, 100, {
|
|
actorId: damages[index].id,
|
|
role: "damage",
|
|
});
|
|
}
|
|
useCombatStore.getState().advanceMobCombat(200);
|
|
for (const member of party.members) updatePartyRuntimeTargetVisibility(member.id, "cooldown-a", true);
|
|
|
|
advanceDungeonPartyCombat(1_000);
|
|
const firstTarget = usePartyStore.getState().memberTargetIds[tank.id];
|
|
const otherTarget = firstTarget === "cooldown-a" ? "cooldown-b" : "cooldown-a";
|
|
expect(useCombatStore.getState().mobs[firstTarget].forcedTarget?.actorId).toBe(tank.id);
|
|
|
|
for (const member of party.members) updatePartyRuntimeTargetVisibility(member.id, otherTarget, true);
|
|
advanceDungeonPartyCombat(4_100);
|
|
expect(usePartyStore.getState().memberTargetIds[tank.id]).toBe(otherTarget);
|
|
expect(useCombatStore.getState().mobs[otherTarget].forcedTarget).toBeNull();
|
|
expect(usePartyStore.getState().members.find((member) => member.id === tank.id)?.tauntReadyAt).toBe(9_000);
|
|
});
|
|
|
|
it("gives damage dealers a higher baseline hit than the tank", () => {
|
|
const [tank, damage] = usePartyStore.getState().members;
|
|
expect(partyAttackDamage(damage)).toBeGreaterThan(partyAttackDamage(tank));
|
|
const attackStat = baseClassFor(damage.classId) === "mage"
|
|
? { spellPower: 126 }
|
|
: baseClassFor(damage.classId) === "hunter"
|
|
? { rangedAttackPower: 126 }
|
|
: { attackPower: 126 };
|
|
expect(partyAttackDamage({
|
|
...damage,
|
|
gearStats: { ...EMPTY_ITEM_STATS, ...attackStat },
|
|
})).toBeGreaterThan(partyAttackDamage(damage));
|
|
});
|
|
|
|
it("lets a dedicated healer restore the lowest-health target on a cooldown", () => {
|
|
usePartyStore.getState().initializeParty("healer-runtime", 20, 100, "damage");
|
|
const members = usePartyStore.getState().members;
|
|
const healer = members.find((member) => member.role === "healer")!;
|
|
const tank = members.find((member) => member.role === "tank")!;
|
|
const wounded = members.map((member) => member.id === tank.id
|
|
? { ...member, health: Math.round(member.maxHealth * 0.25) }
|
|
: member);
|
|
|
|
const first = applyHealerSupport(wounded, 80, 100, 1_000);
|
|
expect(first.targetId).toBe(tank.id);
|
|
expect(first.members.find((member) => member.id === tank.id)!.health).toBeGreaterThan(
|
|
wounded.find((member) => member.id === tank.id)!.health,
|
|
);
|
|
expect(first.members.find((member) => member.id === healer.id)).toMatchObject({
|
|
status: "healing",
|
|
nextActionAt: 3_000,
|
|
});
|
|
const geared = applyHealerSupport(wounded.map((member) => member.id === healer.id
|
|
? { ...member, gearStats: { ...member.gearStats, spellPower: member.gearStats.spellPower + 1_000 } }
|
|
: member), 80, 100, 1_000);
|
|
expect(geared.effectiveHealing).toBeGreaterThan(first.effectiveHealing);
|
|
|
|
const coolingDown = applyHealerSupport(first.members, 50, 100, 2_000);
|
|
expect(coolingDown.playerHealing).toBe(0);
|
|
expect(coolingDown.targetId).toBeNull();
|
|
});
|
|
|
|
it("uses an unlocked party resurrection instead of treating a defeated player as a heal target", () => {
|
|
usePartyStore.getState().initializeParty("resurrection-runtime", 80, 100, "damage");
|
|
const support = applyHealerSupport(usePartyStore.getState().members, 0, 100, 1_000);
|
|
|
|
expect(support).toMatchObject({
|
|
action: "resurrection",
|
|
targetId: "__player__",
|
|
playerHealing: 0,
|
|
});
|
|
expect(support.playerResurrectionPercent).toBeGreaterThan(0);
|
|
expect(support.presentation?.name.toLowerCase()).toMatch(/rebirth|redemption|resurrect|ancestral|revive/);
|
|
});
|
|
|
|
it("lets the party raise the player in place while combat remains active", () => {
|
|
useCombatStore.getState().initializeCharacter({ classId: "mage", level: 80 });
|
|
usePartyStore.getState().initializeParty("resurrection-runtime", 80, useCombatStore.getState().health, "damage");
|
|
useCombatStore.getState().damagePlayer(useCombatStore.getState().maxHealth * 10);
|
|
expect(useCombatStore.getState().health).toBe(0);
|
|
|
|
advanceDungeonPartyCombat(1_000);
|
|
|
|
expect(useCombatStore.getState().health).toBeGreaterThan(0);
|
|
expect(useCombatStore.getState().feedback?.message).toContain("Resurrected");
|
|
});
|
|
|
|
it("classifies ranged classes and elemental shaman into a stand-off range band", () => {
|
|
const ranged = [
|
|
{ classId: "hunter", specialization: "Marksmanship", role: "damage" },
|
|
{ classId: "mage", specialization: "Frost", role: "damage" },
|
|
{ classId: "warlock", specialization: "Affliction", role: "damage" },
|
|
{ classId: "priest", specialization: "Shadow", role: "damage" },
|
|
{ classId: "shaman", specialization: "Elemental", role: "damage" },
|
|
] as const;
|
|
for (const member of ranged) {
|
|
expect(partyUsesRangedAttacks(member)).toBe(true);
|
|
expect(partyCombatRangeBand(member)).toEqual({
|
|
minimum: 10,
|
|
preferred: 14.5,
|
|
maximum: 18.1,
|
|
});
|
|
}
|
|
expect(partyUsesRangedAttacks({
|
|
classId: "shaman",
|
|
specialization: "Enhancement",
|
|
role: "damage",
|
|
})).toBe(false);
|
|
});
|
|
|
|
it("acquires nearby idle enemies only while commanded to attack", () => {
|
|
useCombatStore.getState().registerMob("idle-add", { name: "Idle add", maxHealth: 100, xpReward: 0 });
|
|
setMobPosition("idle-add", [4, 0, 0]);
|
|
updatePartyRuntimeAttackCorridor([0, 0, 0], [[10, 0, 0]], 0);
|
|
const combat = useCombatStore.getState();
|
|
|
|
expect(partyCommandTargetId("defend", combat.mobs, null, null, [0, 0, 0])).toBeNull();
|
|
expect(partyCommandTargetId("stop", combat.mobs, "idle-add", null, [0, 0, 0])).toBeNull();
|
|
expect(partyCommandTargetId("attack", combat.mobs, null, null, [0, 0, 0])).toBe("idle-add");
|
|
|
|
const before = combat.mobs["idle-add"].health;
|
|
usePartyStore.getState().setCommand("attack");
|
|
for (const member of usePartyStore.getState().members) {
|
|
updatePartyRuntimeTargetVisibility(member.id, "idle-add", true);
|
|
}
|
|
advanceDungeonPartyCombat(1_000);
|
|
expect(useCombatStore.getState().mobs["idle-add"].health).toBeLessThan(before);
|
|
});
|
|
|
|
it("ignores idle enemies on a side branch outside the approved Attack corridor", () => {
|
|
useCombatStore.getState().registerMob("road-add", { name: "Road add", maxHealth: 100, xpReward: 0 });
|
|
useCombatStore.getState().registerMob("side-add", { name: "Side add", maxHealth: 100, xpReward: 0 });
|
|
setMobPosition("road-add", [12, 0, 2]);
|
|
setMobPosition("side-add", [4, 0, 16]);
|
|
updatePartyRuntimeAttackCorridor([0, 0, 0], [[20, 0, 0]], 0);
|
|
|
|
expect(partyCommandTargetId(
|
|
"attack",
|
|
useCombatStore.getState().mobs,
|
|
null,
|
|
null,
|
|
[0, 0, 0],
|
|
)).toBe("road-add");
|
|
});
|
|
|
|
it("keeps a corridor-authorized add while the party switches to its pursuit route", () => {
|
|
useCombatStore.getState().registerMob("road-add", { name: "Road add", maxHealth: 100, xpReward: 0 });
|
|
setMobPosition("road-add", [12, 0, 2]);
|
|
updatePartyRuntimeAttackCorridor([0, 0, 0], [[20, 0, 0]], 0);
|
|
const mobs = useCombatStore.getState().mobs;
|
|
const acquired = partyCommandTargetId("attack", mobs, null, null, [0, 0, 0]);
|
|
clearPartyRuntimeRegistry();
|
|
setMobPosition("road-add", [12, 0, 2]);
|
|
|
|
expect(partyCommandTargetId("attack", mobs, null, acquired, [0, 0, 0])).toBe("road-add");
|
|
});
|
|
|
|
it("does not attack while stopped, even when a mob is engaged", () => {
|
|
registerEngagedMob();
|
|
const before = useCombatStore.getState().mobs["pack:a"].health;
|
|
usePartyStore.getState().setCommand("stop");
|
|
advanceDungeonPartyCombat(1_000);
|
|
|
|
expect(useCombatStore.getState().mobs["pack:a"].health).toBe(before);
|
|
expect(usePartyStore.getState().members.every((member) => member.status === "holding")).toBe(true);
|
|
});
|
|
|
|
it("waits to deal damage until party members are in their attack range", () => {
|
|
registerEngagedMob();
|
|
for (const member of usePartyStore.getState().members) {
|
|
registerPartyRuntimePosition(member.id, [80, 0, 0]);
|
|
}
|
|
const before = useCombatStore.getState().mobs["pack:a"].health;
|
|
advanceDungeonPartyCombat(1_000);
|
|
|
|
expect(useCombatStore.getState().mobs["pack:a"].health).toBe(before);
|
|
expect(usePartyStore.getState().members.every((member) => (
|
|
member.status === "advancing"
|
|
|| ((member.status === "attacking" || member.status === "guarding") && member.nextActionAt > 1_000)
|
|
))).toBe(true);
|
|
});
|
|
|
|
it("does not deal remote damage when a target has no world position", () => {
|
|
useCombatStore.getState().registerMob("missing", { name: "Missing", maxHealth: 100, xpReward: 0 });
|
|
useCombatStore.getState().damageMob("missing", 1, 100);
|
|
for (const member of usePartyStore.getState().members) {
|
|
updatePartyRuntimeTargetVisibility(member.id, "missing", true);
|
|
}
|
|
const before = useCombatStore.getState().mobs.missing.health;
|
|
advanceDungeonPartyCombat(1_000);
|
|
expect(useCombatStore.getState().mobs.missing.health).toBe(before);
|
|
});
|
|
});
|