796 lines
34 KiB
TypeScript
796 lines
34 KiB
TypeScript
import { beforeEach, describe, expect, it } from "vitest";
|
|
import { clearMobRuntimeRegistry, setMobPosition } from "./mobRuntimeRegistry";
|
|
import { clearPartyRuntimeRegistry, updatePartyRuntimePosition } from "./partyRuntimeRegistry";
|
|
import { characterCombatDefender, PLAYER_AURA_ENTITY_ID, useCombatStore } from "./combatStore";
|
|
import { usePartyStore } from "./partyStore";
|
|
import { abilityTalentNodeId, preloadAbilityCatalogsForClasses } from "./abilityCatalog";
|
|
import { applyAura } from "./combatAuras";
|
|
import { EMPTY_ITEM_STATS } from "./itemStats";
|
|
import { WOW335_TALENT_NODES } from "./wow335Talents.generated";
|
|
|
|
function abilityId(name: string): string {
|
|
const ability = useCombatStore.getState().abilities.find((candidate) => candidate.name === name);
|
|
expect(ability, name).toBeDefined();
|
|
return ability!.id;
|
|
}
|
|
|
|
function unlockTalentAbility(name: string): string {
|
|
const ability = useCombatStore.getState().abilities.find((candidate) => candidate.name === name);
|
|
expect(ability, name).toBeDefined();
|
|
const nodeId = abilityTalentNodeId(ability!);
|
|
expect(nodeId, name).toBeTruthy();
|
|
useCombatStore.setState((state) => ({ talentRanks: { ...state.talentRanks, [nodeId!]: 1 } }));
|
|
return ability!.id;
|
|
}
|
|
|
|
function setTalentRank(name: string, rank: number): void {
|
|
const talent = WOW335_TALENT_NODES.find((candidate) => candidate.name === name);
|
|
expect(talent, name).toBeDefined();
|
|
useCombatStore.setState((state) => ({
|
|
talentRanks: { ...state.talentRanks, [talent!.id]: rank },
|
|
}));
|
|
}
|
|
|
|
describe("WoW 3.3.5 Paladin source-backed runtime mechanics", () => {
|
|
beforeEach(async () => {
|
|
clearMobRuntimeRegistry();
|
|
clearPartyRuntimeRegistry();
|
|
await preloadAbilityCatalogsForClasses(["paladin"]);
|
|
useCombatStore.getState().initializeCharacter({ classId: "paladin", level: 80 });
|
|
useCombatStore.getState().resetSettings();
|
|
useCombatStore.getState().setPlayerPosition([0, 0, 0]);
|
|
usePartyStore.getState().initializeParty("wow335-paladin-runtime-tests", 80, useCombatStore.getState().health);
|
|
useCombatStore.setState((state) => ({
|
|
resource: state.maxResource,
|
|
resourcePools: { ...state.resourcePools, mana: state.maxResourcePools.mana },
|
|
}));
|
|
});
|
|
|
|
it("blocks silence with Aura Mastery for its sourced 10-second window, then allows silence after expiry", () => {
|
|
const mobId = "paladin-aura-mastery-silence";
|
|
useCombatStore.getState().registerMob(mobId, {
|
|
name: "Silence attacker",
|
|
maxHealth: 10_000,
|
|
attacks: [{
|
|
id: "silence",
|
|
name: "Silence",
|
|
delivery: "area",
|
|
target: "primary",
|
|
school: "shadow",
|
|
animation: "cast",
|
|
castTimeMs: 0,
|
|
range: 30,
|
|
cooldownMs: 10_000,
|
|
initialCooldownMs: [0, 0],
|
|
repeatCooldownMs: [10_000, 10_000],
|
|
damageMultiplier: 0,
|
|
effect: { kind: "control", mechanic: "silence", durationMs: 3_000 },
|
|
}],
|
|
});
|
|
setMobPosition(mobId, [2, 0, 0]);
|
|
useCombatStore.getState().selectMob(mobId);
|
|
useCombatStore.getState().damageMob(mobId, 1, 1_000);
|
|
|
|
const activate = useCombatStore.getState().castAbility(unlockTalentAbility("Aura Mastery"), undefined, 1_000);
|
|
expect(activate).toMatchObject({ ok: true });
|
|
expect(useCombatStore.getState().auras.some((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.controlImmunities?.includes("silence")
|
|
&& aura.expiresAt === 11_000
|
|
))).toBe(true);
|
|
const partyMember = usePartyStore.getState().members[0]!;
|
|
expect(useCombatStore.getState().auras.some((aura) => (
|
|
aura.targetId === partyMember.id
|
|
&& aura.definition.controlImmunities?.includes("silence")
|
|
&& aura.expiresAt === 11_000
|
|
))).toBe(true);
|
|
|
|
useCombatStore.getState().advanceMobCombat(1_450);
|
|
expect(useCombatStore.getState().controlMechanic).toBeNull();
|
|
expect(useCombatStore.getState().schoolLockedUntil).toEqual({});
|
|
|
|
useCombatStore.getState().tick(0.1, 11_001);
|
|
expect(useCombatStore.getState().auras.some((aura) => (
|
|
aura.definition.controlImmunities?.includes("silence")
|
|
))).toBe(false);
|
|
useCombatStore.getState().advanceMobCombat(11_450);
|
|
expect(useCombatStore.getState().controlMechanic).toBe("silence");
|
|
expect(useCombatStore.getState().controlledUntil).toBe(14_450);
|
|
});
|
|
|
|
it("makes Aura Mastery immune to incoming interrupts while a spell is casting", () => {
|
|
const mobId = "paladin-aura-mastery-interrupt";
|
|
useCombatStore.getState().registerMob(mobId, {
|
|
name: "Interrupt attacker",
|
|
maxHealth: 10_000,
|
|
attacks: [{
|
|
id: "interrupt",
|
|
name: "Interrupt",
|
|
delivery: "area",
|
|
target: "primary",
|
|
school: "shadow",
|
|
animation: "cast",
|
|
castTimeMs: 0,
|
|
range: 30,
|
|
cooldownMs: 10_000,
|
|
initialCooldownMs: [0, 0],
|
|
repeatCooldownMs: [10_000, 10_000],
|
|
damageMultiplier: 0,
|
|
effect: { kind: "control", mechanic: "interrupt", durationMs: 3_000 },
|
|
}],
|
|
});
|
|
setMobPosition(mobId, [2, 0, 0]);
|
|
useCombatStore.getState().selectMob(mobId);
|
|
useCombatStore.getState().damageMob(mobId, 1, 1_000);
|
|
|
|
const activate = useCombatStore.getState().castAbility(unlockTalentAbility("Aura Mastery"), undefined, 1_000);
|
|
expect(activate).toMatchObject({ ok: true });
|
|
const playerAura = useCombatStore.getState().auras.find((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.controlImmunities?.includes("interrupt")
|
|
));
|
|
expect(playerAura).toBeDefined();
|
|
|
|
const member = usePartyStore.getState().members[0]!;
|
|
updatePartyRuntimePosition(member.id, 4, 0, 0);
|
|
useCombatStore.getState().synchronizeActors();
|
|
const holyLight = useCombatStore.getState().castAbility(abilityId("Holy Light"), {
|
|
targetActorId: member.id,
|
|
now: 2_500,
|
|
});
|
|
expect(holyLight).toMatchObject({ ok: true });
|
|
expect(useCombatStore.getState().activeCast).not.toBeNull();
|
|
|
|
useCombatStore.getState().advanceMobCombat(2_600);
|
|
expect(useCombatStore.getState().controlMechanic).toBeNull();
|
|
expect(useCombatStore.getState().activeCast).not.toBeNull();
|
|
});
|
|
|
|
it("doubles the active Paladin aura on each Aura Mastery recipient for the generated spell duration", () => {
|
|
const armor = () => characterCombatDefender(useCombatStore.getState()).armor ?? 0;
|
|
const baseArmor = armor();
|
|
expect(useCombatStore.getState().castAbility(abilityId("Devotion Aura"), undefined, 1_000))
|
|
.toMatchObject({ ok: true });
|
|
expect(armor() - baseArmor).toBe(1_205);
|
|
|
|
const mastery = useCombatStore.getState().castAbility(
|
|
unlockTalentAbility("Aura Mastery"),
|
|
undefined,
|
|
2_500,
|
|
);
|
|
expect(mastery).toMatchObject({ ok: true });
|
|
|
|
const partyMember = usePartyStore.getState().members[0]!;
|
|
const masteryAuras = useCombatStore.getState().auras.filter((aura) => (
|
|
aura.definition.utilityTags?.includes("wow335-aura-mastery-aura-effectiveness")
|
|
));
|
|
for (const targetId of [PLAYER_AURA_ENTITY_ID, partyMember.id]) {
|
|
expect(masteryAuras.some((aura) => aura.targetId === targetId && aura.expiresAt === 12_500)).toBe(true);
|
|
}
|
|
expect(armor() - baseArmor).toBe(2_410);
|
|
|
|
useCombatStore.getState().tick(0.1, 12_501);
|
|
expect(armor() - baseArmor).toBe(1_205);
|
|
});
|
|
|
|
it("lets Redemption target and revive a defeated party member at the rank's source health", () => {
|
|
const member = usePartyStore.getState().members[0]!;
|
|
usePartyStore.setState((party) => ({
|
|
members: party.members.map((candidate) => candidate.id === member.id
|
|
? { ...candidate, health: 0, status: "down" as const }
|
|
: candidate),
|
|
}));
|
|
updatePartyRuntimePosition(member.id, 4, 0, 0);
|
|
usePartyStore.getState().selectMember(member.id);
|
|
|
|
const cast = useCombatStore.getState().castAbility(abilityId("Redemption"), undefined, 1_000);
|
|
expect(cast).toMatchObject({ ok: true });
|
|
const activeCast = useCombatStore.getState().activeCast;
|
|
expect(activeCast?.targetId).toBe(member.id);
|
|
useCombatStore.getState().tick(0.1, activeCast!.completesAt);
|
|
|
|
expect(usePartyStore.getState().members.find((candidate) => candidate.id === member.id)?.health).toBe(1_760);
|
|
expect(useCombatStore.getState().combatEvents.some((event) => (
|
|
event.kind === "resurrection" && event.targetActorId === member.id
|
|
))).toBe(true);
|
|
});
|
|
|
|
it("blocks Redemption while any living enemy is engaged", () => {
|
|
const member = usePartyStore.getState().members[0]!;
|
|
usePartyStore.setState((party) => ({
|
|
members: party.members.map((candidate) => candidate.id === member.id
|
|
? { ...candidate, health: 0, status: "down" as const }
|
|
: candidate),
|
|
}));
|
|
updatePartyRuntimePosition(member.id, 4, 0, 0);
|
|
usePartyStore.getState().selectMember(member.id);
|
|
|
|
const targetId = "paladin-redemption-combat-gate";
|
|
useCombatStore.getState().registerMob(targetId, { name: "Engaged enemy", maxHealth: 10_000 });
|
|
setMobPosition(targetId, [4, 0, 0]);
|
|
useCombatStore.setState((state) => ({
|
|
mobs: { ...state.mobs, [targetId]: { ...state.mobs[targetId]!, engaged: true } },
|
|
}));
|
|
|
|
const result = useCombatStore.getState().castAbility(abilityId("Redemption"), undefined, 1_000);
|
|
expect(result).toMatchObject({ ok: false, reason: "condition-not-met" });
|
|
expect(useCombatStore.getState().activeCast).toBeNull();
|
|
expect(usePartyStore.getState().members.find((candidate) => candidate.id === member.id)?.health).toBe(0);
|
|
});
|
|
|
|
it("enforces Hammer of Wrath's 20% execute gate", () => {
|
|
const targetId = "paladin-hammer-gate-target";
|
|
useCombatStore.getState().registerMob(targetId, { name: "Target", maxHealth: 10_000 });
|
|
setMobPosition(targetId, [4, 0, 0]);
|
|
useCombatStore.setState((state) => ({
|
|
mobs: { ...state.mobs, [targetId]: { ...state.mobs[targetId]!, health: 2_001 } },
|
|
selectedTargetId: targetId,
|
|
}));
|
|
|
|
const result = useCombatStore.getState().castAbility(abilityId("Hammer of Wrath"), undefined, 1_000);
|
|
expect(result).toMatchObject({ ok: false, reason: "condition-not-met" });
|
|
});
|
|
|
|
it("requires a shield before Holy Shield can be activated", () => {
|
|
useCombatStore.setState({ equipment: {}, inventory: [] });
|
|
expect(useCombatStore.getState().abilities.find((candidate) => candidate.name === "Holy Shield")?.target).toBe("self");
|
|
const result = useCombatStore.getState().castAbility(unlockTalentAbility("Holy Shield"), undefined, 1_000);
|
|
expect(result).toMatchObject({ ok: false, reason: "condition-not-met" });
|
|
});
|
|
|
|
it("adds Redoubt's generated shield block chance only while a shield is equipped", () => {
|
|
setTalentRank("Redoubt", 2);
|
|
const withoutShield = characterCombatDefender(useCombatStore.getState()).blockPercent ?? 0;
|
|
const shieldId = "paladin-redoubt-block-test";
|
|
const shield = {
|
|
instanceId: shieldId,
|
|
itemId: 1,
|
|
itemKey: shieldId,
|
|
name: "Redoubt Test Shield",
|
|
quality: "uncommon" as const,
|
|
inventorySlot: "off-hand",
|
|
armorType: "shield",
|
|
weaponType: null,
|
|
itemLevel: 1,
|
|
sourceItemLevel: 1,
|
|
stats: { ...EMPTY_ITEM_STATS, blockValue: 40 },
|
|
quantity: 1,
|
|
sourceBossKey: "test",
|
|
sourceBossName: "Test",
|
|
acquiredAt: 1,
|
|
};
|
|
useCombatStore.setState((state) => ({
|
|
inventory: [shield],
|
|
equipment: { player: { "off-hand": shieldId } },
|
|
gearStats: { ...state.gearStats, blockValue: 40 },
|
|
}));
|
|
const withShield = characterCombatDefender(useCombatStore.getState()).blockPercent ?? 0;
|
|
|
|
expect(withShield - withoutShield).toBe(12);
|
|
});
|
|
|
|
it("procs Redoubt from a shield block with the generated rank values and duration", () => {
|
|
setTalentRank("Redoubt", 3);
|
|
const shieldId = "paladin-redoubt-proc-test";
|
|
const shield = {
|
|
instanceId: shieldId,
|
|
itemId: 1,
|
|
itemKey: shieldId,
|
|
name: "Redoubt Proc Shield",
|
|
quality: "uncommon" as const,
|
|
inventorySlot: "off-hand",
|
|
armorType: "shield",
|
|
weaponType: null,
|
|
itemLevel: 1,
|
|
sourceItemLevel: 1,
|
|
stats: { ...EMPTY_ITEM_STATS, blockRating: 1_000_000, blockValue: 40 },
|
|
quantity: 1,
|
|
sourceBossKey: "test",
|
|
sourceBossName: "Test",
|
|
acquiredAt: 1,
|
|
};
|
|
useCombatStore.setState((state) => ({
|
|
inventory: [shield],
|
|
equipment: { player: { "off-hand": shieldId } },
|
|
gearStats: { ...state.gearStats, blockRating: 1_000_000, blockValue: 40 },
|
|
}));
|
|
const mobId = "paladin-redoubt-proc-attacker";
|
|
useCombatStore.getState().registerMob(mobId, {
|
|
name: "Redoubt attacker",
|
|
level: 80,
|
|
maxHealth: 100_000,
|
|
attacks: [{
|
|
id: "redoubt-proc-melee",
|
|
name: "Melee attack",
|
|
delivery: "melee",
|
|
target: "primary",
|
|
school: "physical",
|
|
animation: "attack",
|
|
castTimeMs: 0,
|
|
range: 8,
|
|
cooldownMs: 500,
|
|
initialCooldownMs: [0, 0],
|
|
repeatCooldownMs: [500, 500],
|
|
damageMultiplier: 0.1,
|
|
}],
|
|
});
|
|
setMobPosition(mobId, [2, 0, 0]);
|
|
useCombatStore.getState().damageMob(mobId, 1, 1_000);
|
|
|
|
let redoubt = undefined as ReturnType<typeof useCombatStore.getState>["auras"][number] | undefined;
|
|
for (let now = 1_450; now <= 30_000; now += 250) {
|
|
useCombatStore.getState().advanceMobCombat(now);
|
|
redoubt = useCombatStore.getState().auras.find((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.utilityTags?.includes("wow335-paladin-redoubt")
|
|
));
|
|
if (redoubt) break;
|
|
}
|
|
|
|
expect(useCombatStore.getState().combatEvents.some((event) => (
|
|
event.kind === "damage" && event.targetActorId === PLAYER_AURA_ENTITY_ID && event.outcome === "block"
|
|
))).toBe(true);
|
|
expect(redoubt).toBeDefined();
|
|
expect(redoubt?.expiresAt).toBe(redoubt!.appliedAt + 10_000);
|
|
expect(redoubt?.definition.modifiers).toContainEqual({
|
|
kind: "damage", direction: "taken", operation: "percent", value: -0.06,
|
|
});
|
|
expect(redoubt?.definition.modifiers).toContainEqual({
|
|
kind: "stat", stat: "strength", operation: "percent", value: 0.1,
|
|
});
|
|
});
|
|
|
|
it("spends Holy Shield's eight source-defined charges on successful blocks", () => {
|
|
const shieldId = "paladin-holy-shield-charge-test";
|
|
const shield = {
|
|
instanceId: shieldId,
|
|
itemId: 1,
|
|
itemKey: shieldId,
|
|
name: "Test Shield",
|
|
quality: "uncommon" as const,
|
|
inventorySlot: "off-hand",
|
|
armorType: "shield",
|
|
weaponType: null,
|
|
itemLevel: 1,
|
|
sourceItemLevel: 1,
|
|
stats: { ...EMPTY_ITEM_STATS, blockRating: 1_000_000, blockValue: 40 },
|
|
quantity: 1,
|
|
sourceBossKey: "test",
|
|
sourceBossName: "Test",
|
|
acquiredAt: 1,
|
|
};
|
|
useCombatStore.setState((state) => ({
|
|
inventory: [shield],
|
|
equipment: { player: { "off-hand": shieldId } },
|
|
gearStats: { ...state.gearStats, blockRating: 1_000_000, blockValue: 40 },
|
|
}));
|
|
|
|
const targetId = "paladin-holy-shield-charge-target";
|
|
useCombatStore.getState().registerMob(targetId, {
|
|
name: "Melee attacker",
|
|
level: 80,
|
|
maxHealth: 100_000,
|
|
attacks: [{
|
|
id: "holy-shield-charge-melee",
|
|
name: "Melee attack",
|
|
delivery: "melee",
|
|
target: "primary",
|
|
school: "physical",
|
|
animation: "attack",
|
|
castTimeMs: 0,
|
|
range: 8,
|
|
cooldownMs: 500,
|
|
initialCooldownMs: [0, 0],
|
|
repeatCooldownMs: [500, 500],
|
|
damageMultiplier: 0.1,
|
|
}],
|
|
});
|
|
setMobPosition(targetId, [2, 0, 0]);
|
|
useCombatStore.getState().damageMob(targetId, 1, 1_000);
|
|
|
|
const holyShieldId = unlockTalentAbility("Holy Shield");
|
|
const cast = useCombatStore.getState().castAbility(holyShieldId, undefined, 1_000);
|
|
expect(cast, JSON.stringify(cast)).toMatchObject({ ok: true });
|
|
const findHolyShieldProc = () => useCombatStore.getState().auras.find((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.procs?.some((proc) => proc.id.endsWith(":holy-shield"))
|
|
));
|
|
expect(findHolyShieldProc()?.procStates[0]?.remainingCharges).toBe(8);
|
|
|
|
for (let now = 1_450; now <= 10_000; now += 250) {
|
|
useCombatStore.getState().advanceMobCombat(now);
|
|
if (findHolyShieldProc()?.procStates[0]?.remainingCharges === 0) break;
|
|
}
|
|
|
|
expect(findHolyShieldProc()?.procStates[0]?.remainingCharges).toBe(0);
|
|
});
|
|
|
|
it("procs three 8-second Reckoning charges from melee hits and adds one landed autoattack per charge", () => {
|
|
setTalentRank("Reckoning", 5);
|
|
const mobId = "paladin-reckoning-trigger";
|
|
useCombatStore.getState().registerMob(mobId, {
|
|
name: "Reckoning attacker",
|
|
level: 80,
|
|
maxHealth: 100_000,
|
|
attacks: [{
|
|
id: "reckoning-melee",
|
|
name: "Melee attack",
|
|
delivery: "melee",
|
|
target: "primary",
|
|
school: "physical",
|
|
animation: "attack",
|
|
castTimeMs: 0,
|
|
range: 8,
|
|
cooldownMs: 500,
|
|
initialCooldownMs: [0, 0],
|
|
repeatCooldownMs: [500, 500],
|
|
damageMultiplier: 0.1,
|
|
}],
|
|
});
|
|
setMobPosition(mobId, [2, 0, 0]);
|
|
useCombatStore.getState().damageMob(mobId, 1, 1_000);
|
|
const ensureMeleeHit = applyAura(useCombatStore.getState().auras, {
|
|
definition: {
|
|
id: "test:ensure-reckoning-melee-hit",
|
|
name: "Ensure incoming melee hit",
|
|
disposition: "buff",
|
|
durationMs: null,
|
|
modifiers: [{ kind: "stat", stat: "incoming-melee-hit", operation: "flat", value: 100 }],
|
|
},
|
|
sourceId: mobId,
|
|
targetId: PLAYER_AURA_ENTITY_ID,
|
|
now: 1_000,
|
|
}).auras;
|
|
useCombatStore.setState((state) => ({ auras: [...ensureMeleeHit] }));
|
|
|
|
let procAt: number | null = null;
|
|
for (let now = 1_450; now <= 30_000; now += 250) {
|
|
useCombatStore.getState().advanceMobCombat(now);
|
|
if (useCombatStore.getState().auras.some((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.utilityTags?.includes("wow335-paladin-reckoning")
|
|
))) {
|
|
procAt = now;
|
|
break;
|
|
}
|
|
}
|
|
expect(procAt).not.toBeNull();
|
|
const reckoning = useCombatStore.getState().auras.find((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.utilityTags?.includes("wow335-paladin-reckoning")
|
|
));
|
|
expect(reckoning).toMatchObject({ stacks: 3, expiresAt: procAt! + 8_000 });
|
|
|
|
useCombatStore.setState((state) => ({
|
|
autoAttackTargetId: mobId,
|
|
nextAutoAttackAt: procAt! + 100,
|
|
gearStats: { ...state.gearStats, hitRating: 1_000_000, expertiseRating: 1_000_000 },
|
|
}));
|
|
let autoAttackAt = procAt! + 100;
|
|
for (let charge = 2; charge >= 0; charge -= 1) {
|
|
useCombatStore.getState().tick(0.1, autoAttackAt);
|
|
const swingEvents = useCombatStore.getState().combatEvents.filter((event) => (
|
|
event.kind === "damage"
|
|
&& event.sourceActorId === PLAYER_AURA_ENTITY_ID
|
|
&& event.targetActorId === mobId
|
|
&& event.occurredAt === autoAttackAt
|
|
));
|
|
expect(swingEvents).toHaveLength(2);
|
|
const remaining = useCombatStore.getState().auras.find((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.utilityTags?.includes("wow335-paladin-reckoning")
|
|
));
|
|
if (charge > 0) expect(remaining?.stacks).toBe(charge);
|
|
else expect(remaining).toBeUndefined();
|
|
autoAttackAt = useCombatStore.getState().nextAutoAttackAt;
|
|
}
|
|
});
|
|
|
|
it("reflects the sourced rank percentage of incoming critical damage with Eye for an Eye", () => {
|
|
const mobId = "paladin-eye-for-an-eye-crit";
|
|
useCombatStore.getState().registerMob(mobId, {
|
|
name: "Critical attacker",
|
|
level: 80,
|
|
maxHealth: 100_000,
|
|
damageMultiplier: 1,
|
|
attacks: [{
|
|
id: "eye-crit-18",
|
|
name: "Critical attack",
|
|
delivery: "area",
|
|
target: "primary",
|
|
school: "fire",
|
|
animation: "cast",
|
|
castTimeMs: 0,
|
|
range: 30,
|
|
cooldownMs: 10_000,
|
|
initialCooldownMs: [0, 0],
|
|
repeatCooldownMs: [10_000, 10_000],
|
|
damageMultiplier: 1,
|
|
}],
|
|
});
|
|
setMobPosition(mobId, [2, 0, 0]);
|
|
useCombatStore.getState().selectMob(mobId);
|
|
useCombatStore.getState().damageMob(mobId, 1, 1_000);
|
|
|
|
const ensureSpellHit = applyAura([], {
|
|
definition: {
|
|
id: "test:ensure-incoming-spell-hit",
|
|
name: "Ensure incoming spell hit",
|
|
disposition: "buff",
|
|
durationMs: null,
|
|
modifiers: [{ kind: "stat", stat: "incoming-spell-hit", operation: "flat", value: 100 }],
|
|
},
|
|
sourceId: mobId,
|
|
targetId: PLAYER_AURA_ENTITY_ID,
|
|
now: 1_000,
|
|
}).auras;
|
|
useCombatStore.setState((state) => ({
|
|
talentRanks: { ...state.talentRanks, "talent-1632": 3 },
|
|
auras: [...state.auras, ...ensureSpellHit],
|
|
}));
|
|
|
|
// This seeded instant spell attack rolls inside the crit slice of the
|
|
// equal-level attack table, so the test does not rely on chance.
|
|
useCombatStore.getState().advanceMobCombat(1_450);
|
|
useCombatStore.getState().advanceMobCombat(3_100);
|
|
const events = useCombatStore.getState().combatEvents;
|
|
const incoming = events.find((event) => event.kind === "damage"
|
|
&& event.sourceActorId === mobId && event.targetActorId === PLAYER_AURA_ENTITY_ID);
|
|
expect(incoming?.critical, JSON.stringify(incoming)).toBe(true);
|
|
const reflected = events.find((event) => event.kind === "damage"
|
|
&& event.targetActorId === mobId && event.abilityId === "talent-1632");
|
|
expect(reflected?.rawAmount).toBe(Math.round((incoming?.effectiveAmount ?? 0) * 0.15));
|
|
});
|
|
|
|
it("bounces Avenger's Shield to three total targets without damage falloff", () => {
|
|
const shieldId = unlockTalentAbility("Avenger's Shield");
|
|
const targetIds = [
|
|
"paladin-avenger-target",
|
|
"paladin-avenger-bounce-a",
|
|
"paladin-avenger-bounce-b",
|
|
"paladin-avenger-bounce-c",
|
|
"paladin-avenger-out-of-range",
|
|
];
|
|
for (const id of targetIds) {
|
|
useCombatStore.getState().registerMob(id, { name: id, maxHealth: 1_000_000 });
|
|
}
|
|
setMobPosition(targetIds[0]!, [4, 0, 0]);
|
|
setMobPosition(targetIds[1]!, [10, 0, 0]);
|
|
setMobPosition(targetIds[2]!, [16, 0, 0]);
|
|
setMobPosition(targetIds[3]!, [22, 0, 0]);
|
|
setMobPosition(targetIds[4]!, [10, 0, 12]);
|
|
useCombatStore.getState().selectMob(targetIds[0]!);
|
|
|
|
const result = useCombatStore.getState().castAbility(shieldId, undefined, 1_000);
|
|
expect(result, JSON.stringify(result)).toMatchObject({ ok: true });
|
|
expect(result.affectedMobIds).toEqual(targetIds.slice(0, 3));
|
|
expect(result.affectedMobIds).not.toContain(targetIds[3]);
|
|
expect(result.affectedMobIds).not.toContain(targetIds[4]);
|
|
|
|
const damageEvents = useCombatStore.getState().combatEvents.filter((event) => (
|
|
event.kind === "damage" && event.abilityId === shieldId
|
|
&& result.affectedMobIds.includes(event.targetActorId)
|
|
));
|
|
expect(damageEvents).toHaveLength(3);
|
|
const normalizedRawDamage = damageEvents.map((event) => Math.round(event.rawAmount / (event.critical ? 2 : 1)));
|
|
expect(new Set(normalizedRawDamage).size).toBe(1);
|
|
});
|
|
|
|
it("applies a Greater Blessing to the selected ally's class group", () => {
|
|
const members = usePartyStore.getState().members;
|
|
const target = members[0]!;
|
|
usePartyStore.setState((party) => ({
|
|
members: party.members.map((candidate, index) => ({
|
|
...candidate,
|
|
classId: index < 2 ? "mage" : "priest",
|
|
})),
|
|
}));
|
|
for (const member of members) updatePartyRuntimePosition(member.id, 1, 0, 0);
|
|
usePartyStore.getState().selectMember(target.id);
|
|
|
|
const result = useCombatStore.getState().castAbility(abilityId("Greater Blessing of Kings"), undefined, 1_000);
|
|
expect(result).toMatchObject({ ok: true });
|
|
|
|
const blessedIds = new Set(useCombatStore.getState().auras
|
|
.filter((aura) => aura.definition.name.includes("Greater Blessing of Kings"))
|
|
.map((aura) => aura.targetId));
|
|
expect(blessedIds).toEqual(new Set([target.id, members[1]!.id]));
|
|
expect(blessedIds.has(PLAYER_AURA_ENTITY_ID)).toBe(false);
|
|
});
|
|
|
|
it("heals at most three party actors from Divine Storm damage", () => {
|
|
const members = usePartyStore.getState().members;
|
|
usePartyStore.setState((party) => ({
|
|
members: party.members.map((member) => ({ ...member, health: 1 })),
|
|
}));
|
|
members.forEach((member, index) => updatePartyRuntimePosition(member.id, index + 1, 0, 0));
|
|
useCombatStore.setState((state) => ({ health: Math.max(1, Math.round(state.maxHealth * 0.1)) }));
|
|
|
|
const targetId = "paladin-divine-storm-target";
|
|
const nearbyTargetId = "paladin-divine-storm-nearby-target";
|
|
const distantTargetId = "paladin-divine-storm-distant-target";
|
|
useCombatStore.getState().registerMob(targetId, { name: "Target", maxHealth: 100_000 });
|
|
useCombatStore.getState().registerMob(nearbyTargetId, { name: "Nearby Target", maxHealth: 100_000 });
|
|
useCombatStore.getState().registerMob(distantTargetId, { name: "Distant Target", maxHealth: 100_000 });
|
|
setMobPosition(targetId, [4, 0, 0]);
|
|
setMobPosition(nearbyTargetId, [7, 0, 0]);
|
|
setMobPosition(distantTargetId, [13, 0, 0]);
|
|
useCombatStore.setState((state) => ({ selectedTargetId: targetId }));
|
|
const divineStorm = unlockTalentAbility("Divine Storm");
|
|
const result = useCombatStore.getState().castAbility(divineStorm, { targetActorId: targetId, now: 1_000 });
|
|
expect(result, JSON.stringify(result)).toMatchObject({ ok: true });
|
|
expect(result.affectedMobIds).toEqual(expect.arrayContaining([targetId, nearbyTargetId]));
|
|
expect(result.affectedMobIds).not.toContain(distantTargetId);
|
|
|
|
const healEvents = useCombatStore.getState().combatEvents.filter((event) => (
|
|
event.kind === "healing" && event.abilityId === divineStorm && event.effectiveAmount > 0
|
|
));
|
|
expect(healEvents.length).toBeGreaterThan(0);
|
|
expect(healEvents.length).toBeLessThanOrEqual(3);
|
|
expect(healEvents.every((event) => event.rawAmount > 0)).toBe(true);
|
|
});
|
|
|
|
it("transfers direct healing to the active Beacon of Light target", () => {
|
|
const member = usePartyStore.getState().members[0]!;
|
|
updatePartyRuntimePosition(member.id, 4, 0, 0);
|
|
usePartyStore.setState((party) => ({
|
|
members: party.members.map((candidate) => candidate.id === member.id
|
|
? { ...candidate, health: 100 }
|
|
: candidate),
|
|
}));
|
|
usePartyStore.getState().selectMember(member.id);
|
|
|
|
const beaconResult = useCombatStore.getState().castAbility(unlockTalentAbility("Beacon of Light"), undefined, 1_000);
|
|
expect(beaconResult).toMatchObject({ ok: true });
|
|
const beaconCast = useCombatStore.getState().activeCast;
|
|
if (beaconCast) useCombatStore.getState().tick(0.1, beaconCast.completesAt);
|
|
expect(useCombatStore.getState().auras.some((aura) => (
|
|
aura.targetId === member.id && aura.definition.utilityTags?.includes("beacon-of-light")
|
|
))).toBe(true);
|
|
|
|
useCombatStore.getState().damagePlayer(5_000);
|
|
const beforeTransfer = usePartyStore.getState().members.find((candidate) => candidate.id === member.id)!.health;
|
|
const heal = useCombatStore.getState().castAbility(abilityId("Flash of Light"), undefined, 3_000);
|
|
expect(heal).toMatchObject({ ok: true });
|
|
const healCast = useCombatStore.getState().activeCast;
|
|
if (healCast) useCombatStore.getState().tick(0.1, healCast.completesAt);
|
|
|
|
const afterTransfer = usePartyStore.getState().members.find((candidate) => candidate.id === member.id)!.health;
|
|
expect(afterTransfer).toBeGreaterThan(beforeTransfer);
|
|
expect(useCombatStore.getState().auras.some((aura) => aura.targetId === member.id
|
|
&& aura.definition.utilityTags?.includes("beacon-of-light"))).toBe(true);
|
|
});
|
|
|
|
it("limits Divine Sacrifice to the remaining portion of its shared damage cap", () => {
|
|
const member = usePartyStore.getState().members[0]!;
|
|
updatePartyRuntimePosition(member.id, 0, 0, 0);
|
|
usePartyStore.setState((party) => ({
|
|
members: party.members.map((candidate) => candidate.id === member.id
|
|
? { ...candidate, health: candidate.maxHealth }
|
|
: candidate),
|
|
}));
|
|
usePartyStore.getState().selectMember(member.id);
|
|
const sacrifice = unlockTalentAbility("Divine Sacrifice");
|
|
expect(useCombatStore.getState().castAbility(sacrifice, undefined, 1_000).ok).toBe(true);
|
|
|
|
const cap = Math.round(useCombatStore.getState().maxHealth * 1.5);
|
|
const anchor = useCombatStore.getState().auras.find((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.utilityTags?.includes("wow335-paladin-divine-sacrifice")
|
|
));
|
|
expect(anchor?.definition.redirectDamageCapPercent).toBe(1.5);
|
|
expect(useCombatStore.getState().auras.some((aura) => (
|
|
aura.targetId === member.id && aura.definition.utilityTags?.includes("wow335-paladin-divine-sacrifice")
|
|
))).toBe(true);
|
|
useCombatStore.setState((state) => ({
|
|
auras: state.auras.map((aura) => aura.instanceId === anchor!.instanceId
|
|
? { ...aura, redirectedDamage: cap - 20 }
|
|
: aura),
|
|
}));
|
|
|
|
const mobId = "paladin-divine-sacrifice-partial";
|
|
useCombatStore.getState().registerMob(mobId, { name: "Cap test attacker", maxHealth: 100_000 });
|
|
setMobPosition(mobId, [2, 0, 0]);
|
|
useCombatStore.getState().damageMob(mobId, 1, 1_000, { actorId: member.id, role: "tank" });
|
|
useCombatStore.setState((state) => ({
|
|
mobs: { ...state.mobs, [mobId]: { ...state.mobs[mobId]!, attackDamage: 1_000 } },
|
|
}));
|
|
const playerBefore = useCombatStore.getState().health;
|
|
const memberBefore = usePartyStore.getState().members.find((candidate) => candidate.id === member.id)!.health;
|
|
useCombatStore.getState().advanceMobCombat(1_450);
|
|
useCombatStore.getState().advanceMobCombat(3_350);
|
|
|
|
expect(playerBefore - useCombatStore.getState().health).toBe(20);
|
|
expect(usePartyStore.getState().members.find((candidate) => candidate.id === member.id)!.health).toBeLessThan(memberBefore);
|
|
expect(useCombatStore.getState().auras.find((aura) => aura.instanceId === anchor!.instanceId)?.redirectedDamage).toBe(cap);
|
|
});
|
|
|
|
it("stops Divine Sacrifice redirects after the shared damage cap is exhausted", () => {
|
|
const member = usePartyStore.getState().members[0]!;
|
|
updatePartyRuntimePosition(member.id, 0, 0, 0);
|
|
usePartyStore.setState((party) => ({
|
|
members: party.members.map((candidate) => candidate.id === member.id
|
|
? { ...candidate, health: candidate.maxHealth }
|
|
: candidate),
|
|
}));
|
|
usePartyStore.getState().selectMember(member.id);
|
|
const sacrifice = unlockTalentAbility("Divine Sacrifice");
|
|
expect(useCombatStore.getState().castAbility(sacrifice, undefined, 1_000).ok).toBe(true);
|
|
const anchor = useCombatStore.getState().auras.find((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.utilityTags?.includes("wow335-paladin-divine-sacrifice")
|
|
));
|
|
expect(anchor).toBeDefined();
|
|
const cap = Math.round(useCombatStore.getState().maxHealth * 1.5);
|
|
useCombatStore.setState((state) => ({
|
|
auras: state.auras.map((aura) => aura.instanceId === anchor!.instanceId
|
|
? { ...aura, redirectedDamage: cap }
|
|
: aura),
|
|
}));
|
|
|
|
const mobId = "paladin-divine-sacrifice-exhausted";
|
|
useCombatStore.getState().registerMob(mobId, { name: "Cap test attacker", maxHealth: 100_000 });
|
|
setMobPosition(mobId, [2, 0, 0]);
|
|
useCombatStore.getState().damageMob(mobId, 1, 1_000, { actorId: member.id, role: "tank" });
|
|
useCombatStore.setState((state) => ({
|
|
mobs: { ...state.mobs, [mobId]: { ...state.mobs[mobId]!, attackDamage: 1_000 } },
|
|
}));
|
|
const playerBefore = useCombatStore.getState().health;
|
|
const memberBefore = usePartyStore.getState().members.find((candidate) => candidate.id === member.id)!.health;
|
|
useCombatStore.getState().advanceMobCombat(1_450);
|
|
const resolvedDamage = useCombatStore.getState().advanceMobCombat(3_350);
|
|
expect(resolvedDamage, JSON.stringify(useCombatStore.getState().mobs[mobId])).toBeGreaterThan(0);
|
|
|
|
expect(useCombatStore.getState().health).toBe(playerBefore);
|
|
expect(usePartyStore.getState().members.find((candidate) => candidate.id === member.id)!.health).toBeLessThan(memberBefore);
|
|
expect(useCombatStore.getState().auras.find((aura) => aura.instanceId === anchor!.instanceId)?.redirectedDamage).toBe(cap);
|
|
});
|
|
|
|
it("does not redirect damage from an attack that targets the Paladin", () => {
|
|
const sacrifice = unlockTalentAbility("Divine Sacrifice");
|
|
expect(useCombatStore.getState().castAbility(sacrifice, undefined, 1_000).ok).toBe(true);
|
|
const anchor = useCombatStore.getState().auras.find((aura) => (
|
|
aura.targetId === PLAYER_AURA_ENTITY_ID
|
|
&& aura.definition.utilityTags?.includes("wow335-paladin-divine-sacrifice")
|
|
));
|
|
expect(anchor).toBeDefined();
|
|
|
|
const mobId = "paladin-divine-sacrifice-self-hit";
|
|
useCombatStore.getState().registerMob(mobId, { name: "Self hit attacker", maxHealth: 100_000 });
|
|
setMobPosition(mobId, [2, 0, 0]);
|
|
useCombatStore.getState().damageMob(mobId, 1, 1_000);
|
|
useCombatStore.setState((state) => ({
|
|
mobs: { ...state.mobs, [mobId]: { ...state.mobs[mobId]!, attackDamage: 1_000 } },
|
|
}));
|
|
const playerBefore = useCombatStore.getState().health;
|
|
expect(useCombatStore.getState().advanceMobCombat(1_450)).toBeGreaterThan(0);
|
|
|
|
expect(useCombatStore.getState().health).toBeLessThan(playerBefore);
|
|
expect(useCombatStore.getState().auras.find((aura) => aura.instanceId === anchor!.instanceId)?.redirectedDamage).toBe(0);
|
|
});
|
|
|
|
it("makes the next eligible Divine Favor heal critical and consumes its aura", () => {
|
|
const maxHealth = useCombatStore.getState().maxHealth;
|
|
useCombatStore.getState().damagePlayer(Math.round(maxHealth * 0.4));
|
|
|
|
const activate = useCombatStore.getState().castAbility(unlockTalentAbility("Divine Favor"), undefined, 1_000);
|
|
expect(activate).toMatchObject({ ok: true });
|
|
expect(useCombatStore.getState().auras.some((aura) => (
|
|
aura.definition.utilityTags?.includes("wow335-divine-favor-next-holy-heal")
|
|
))).toBe(true);
|
|
|
|
const flashOfLight = abilityId("Flash of Light");
|
|
const heal = useCombatStore.getState().castAbility(flashOfLight, undefined, 3_000);
|
|
expect(heal).toMatchObject({ ok: true });
|
|
const activeCast = useCombatStore.getState().activeCast;
|
|
if (activeCast) useCombatStore.getState().tick(0.1, activeCast.completesAt);
|
|
|
|
expect(useCombatStore.getState().combatEvents.some((event) => (
|
|
event.kind === "healing" && event.abilityId === flashOfLight && event.critical
|
|
))).toBe(true);
|
|
expect(useCombatStore.getState().auras.some((aura) => (
|
|
aura.definition.utilityTags?.includes("wow335-divine-favor-next-holy-heal")
|
|
))).toBe(false);
|
|
});
|
|
});
|