39 lines
2.2 KiB
TypeScript
39 lines
2.2 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import { deflectLandedCombatResult, resolveCombatResult } from "./combatResults";
|
|
|
|
function attack(overrides: Parameters<typeof resolveCombatResult>[0]["rules"] = {}, roll = 0.5) {
|
|
return resolveCombatResult({ amount: 100, attackKind: "spell", damageSchool: "frost",
|
|
attacker: { level: 80, criticalChancePercent: 100 },
|
|
defender: { level: 80, resistances: { frost: 400 } },
|
|
rules: { canMiss: false, resistanceMode: "partial", ...overrides }, roll: () => roll });
|
|
}
|
|
|
|
describe("guaranteed source deflection after the existing hit gate", () => {
|
|
it("discards landed critical/partial-resist damage without reporting absorb, block or crit", () => {
|
|
const landed = attack();
|
|
expect(landed).toMatchObject({ landed: true, critical: true, partiallyResisted: true });
|
|
const result = deflectLandedCombatResult(landed);
|
|
expect(result).toMatchObject({ outcome: "deflect", deflected: true, landed: false,
|
|
avoided: true, rawDamage: 100, finalDamage: 0, blocked: false, blockedAmount: 0,
|
|
critical: false, resistedAmount: 0, fullyResisted: false, partiallyResisted: false });
|
|
});
|
|
it.each(["miss", "resist"] as const)("preserves an earlier %s and its original evidence", (outcome) => {
|
|
const prior = outcome === "miss"
|
|
? attack({ canMiss: true, baseMissChancePercent: 100 })
|
|
: attack({ resistanceMode: "binary" }, 0);
|
|
expect(prior.outcome).toBe(outcome);
|
|
expect(deflectLandedCombatResult(prior)).toBe(prior);
|
|
});
|
|
it("removes block-roll evidence from the discarded ranged spell packet", () => {
|
|
const blocked = resolveCombatResult({ amount: 100, attackKind: "ranged", damageSchool: "physical",
|
|
attacker: { level: 80 }, defender: { level: 80, blockPercent: 100, blockValue: 20,
|
|
criticalBlockChancePercent: 100 },
|
|
rules: { canMiss: false, canCrit: false, blockMode: "post-hit" }, roll: () => 0.5 });
|
|
expect(blocked).toMatchObject({ landed: true, blocked: true, criticalBlocked: true });
|
|
const deflected = deflectLandedCombatResult(blocked);
|
|
expect(deflected).toMatchObject({ outcome: "deflect", blocked: false, finalDamage: 0 });
|
|
expect(deflected.postHitBlockRoll).toBeUndefined();
|
|
expect(deflected.criticalBlockRoll).toBeUndefined();
|
|
});
|
|
});
|