510 lines
18 KiB
TypeScript
510 lines
18 KiB
TypeScript
import { armorReductionPercent, type DamageSchool } from "./itemStats";
|
|
import type { CharacterStats, WotlkAttackKind } from "./wotlkStats";
|
|
|
|
export type CombatAttackKind = WotlkAttackKind;
|
|
export type CombatOutcome = "hit" | "crit" | "miss" | "dodge" | "parry" | "block" | "resist" | "deflect";
|
|
export type CombatResistanceMode = "none" | "partial" | "binary";
|
|
export type CombatRollStage = "outcome" | "resistance" | "block" | "critical-block";
|
|
|
|
/** A roll must be in [0, 1). Values outside that range are safely clamped. */
|
|
export type CombatRollSource = (stage: CombatRollStage) => number;
|
|
|
|
export interface CombatAttackerStats {
|
|
readonly level: number;
|
|
readonly hitPercent?: number;
|
|
readonly criticalChancePercent?: number;
|
|
readonly criticalDamageMultiplier?: number;
|
|
readonly expertiseReductionPercent?: number;
|
|
readonly armorPenetrationPercent?: number;
|
|
readonly spellPenetration?: number;
|
|
}
|
|
|
|
export interface CombatDefenderStats {
|
|
readonly level: number;
|
|
readonly armor?: number;
|
|
readonly dodgePercent?: number;
|
|
readonly parryPercent?: number;
|
|
readonly blockPercent?: number;
|
|
readonly blockValue?: number;
|
|
/** Integer chance passed to AzerothCore's roll_chance_i after a successful block. */
|
|
readonly criticalBlockChancePercent?: number;
|
|
readonly criticalAvoidancePercent?: number;
|
|
readonly damageReductionPercent?: number;
|
|
readonly resistances?: Partial<Readonly<Record<DamageSchool, number>>>;
|
|
}
|
|
|
|
export interface CombatResultRules {
|
|
/** Exact source packet identity and recipient ordinal for native RoM spells. */
|
|
readonly romNativeSource?: { readonly skillId: number; readonly componentId: number };
|
|
readonly romNativeTargetOrdinal?: number;
|
|
/** Native periodic power already includes source target defense at application. */
|
|
readonly targetMitigationSnapshotted?: boolean;
|
|
/** School or encounter immunity: the attack is reported as fully resisted. */
|
|
readonly immune?: boolean;
|
|
/** Ordinary abilities use the special-attack miss table. Auto attacks may use the dual-wield penalty. */
|
|
readonly isAutoAttack?: boolean;
|
|
readonly isDualWielding?: boolean;
|
|
readonly canMiss?: boolean;
|
|
readonly canCrit?: boolean;
|
|
readonly canDodge?: boolean;
|
|
readonly canParry?: boolean;
|
|
readonly canBlock?: boolean;
|
|
/** Source direct physical spells roll block separately after landing, including crits. */
|
|
readonly blockMode?: "post-hit";
|
|
/** Source mechanic exception (for example, bleed effects that bypass armor). */
|
|
readonly ignoreArmor?: boolean;
|
|
readonly resistanceMode?: CombatResistanceMode;
|
|
/** Overrides the level-derived base miss chance before the attacker's hit bonus is applied. */
|
|
readonly baseMissChancePercent?: number;
|
|
}
|
|
|
|
export interface ResolveCombatResultInput {
|
|
readonly amount: number;
|
|
readonly attackKind: CombatAttackKind;
|
|
readonly damageSchool: DamageSchool;
|
|
readonly attacker: CombatAttackerStats;
|
|
readonly defender: CombatDefenderStats;
|
|
readonly rules?: CombatResultRules;
|
|
/** Defaults to Math.random. Inject a stage-aware source for replays and exact tests. */
|
|
readonly roll?: CombatRollSource;
|
|
}
|
|
|
|
export interface CombatAttackTable {
|
|
readonly missPercent: number;
|
|
readonly dodgePercent: number;
|
|
readonly parryPercent: number;
|
|
readonly blockPercent: number;
|
|
readonly criticalPercent: number;
|
|
readonly hitPercent: number;
|
|
}
|
|
|
|
export interface CombatResult {
|
|
readonly outcome: CombatOutcome;
|
|
readonly landed: boolean;
|
|
readonly critical: boolean;
|
|
readonly missed: boolean;
|
|
readonly dodged: boolean;
|
|
readonly parried: boolean;
|
|
readonly blocked: boolean;
|
|
readonly avoided: boolean;
|
|
/** Exact source spell deflection avoids the packet rather than absorbing it. */
|
|
readonly deflected?: boolean;
|
|
readonly fullyResisted: boolean;
|
|
readonly partiallyResisted: boolean;
|
|
readonly rawDamage: number;
|
|
readonly damageBeforeMitigation: number;
|
|
readonly effectiveArmor: number;
|
|
readonly armorReductionPercent: number;
|
|
readonly armorMitigatedAmount: number;
|
|
readonly blockedAmount: number;
|
|
readonly resistedAmount: number;
|
|
readonly damageReductionAmount: number;
|
|
readonly finalDamage: number;
|
|
readonly attackTable: CombatAttackTable;
|
|
readonly outcomeRoll: number;
|
|
readonly resistanceRoll: number | null;
|
|
readonly resistanceFraction: number;
|
|
readonly postHitBlockRoll?: number;
|
|
readonly postHitBlockChancePercent?: number;
|
|
/** Integer in [0, 99], matching the sample consumed by roll_chance_i. */
|
|
readonly criticalBlockRoll?: number;
|
|
readonly criticalBlockChancePercent?: number;
|
|
readonly criticalBlocked?: boolean;
|
|
}
|
|
|
|
/**
|
|
* Exact 100% source deflection is applied after the existing miss/full-resist
|
|
* result, before any damage or proc is committed. It cannot replace avoidance.
|
|
* Partial-resist and block calculations on the discarded packet are not damage.
|
|
*/
|
|
export function deflectLandedCombatResult(result: CombatResult): CombatResult {
|
|
if (!result.landed || result.avoided || result.fullyResisted) return result;
|
|
const { postHitBlockRoll: _blockRoll, postHitBlockChancePercent: _blockChance,
|
|
criticalBlockRoll: _criticalBlockRoll, criticalBlockChancePercent: _criticalBlockChance,
|
|
criticalBlocked: _criticalBlocked, ...retained } = result;
|
|
return Object.freeze({
|
|
...retained,
|
|
outcome: "deflect",
|
|
landed: false,
|
|
critical: false,
|
|
missed: false,
|
|
dodged: false,
|
|
parried: false,
|
|
blocked: false,
|
|
avoided: true,
|
|
deflected: true,
|
|
fullyResisted: false,
|
|
partiallyResisted: false,
|
|
damageBeforeMitigation: 0,
|
|
effectiveArmor: 0,
|
|
armorReductionPercent: 0,
|
|
armorMitigatedAmount: 0,
|
|
blockedAmount: 0,
|
|
resistedAmount: 0,
|
|
damageReductionAmount: 0,
|
|
finalDamage: 0,
|
|
resistanceFraction: 0,
|
|
});
|
|
}
|
|
|
|
const DEFAULT_CRITICAL_DAMAGE_MULTIPLIER = 2;
|
|
const DUAL_WIELD_AUTO_ATTACK_MISS_PENALTY = 19;
|
|
const PARTIAL_RESIST_STEP = 0.1;
|
|
|
|
function finiteNonNegative(value: number | undefined): number {
|
|
return Number.isFinite(value) ? Math.max(0, Number(value)) : 0;
|
|
}
|
|
|
|
function finitePercent(value: number | undefined, maximum = 100): number {
|
|
return Math.min(maximum, finiteNonNegative(value));
|
|
}
|
|
|
|
function safeLevel(value: number): number {
|
|
return Math.max(1, Math.min(255, Math.trunc(Number.isFinite(value) ? value : 1)));
|
|
}
|
|
|
|
function normalizedRoll(value: number): number {
|
|
if (!Number.isFinite(value)) return 0;
|
|
return Math.min(1 - Number.EPSILON, Math.max(0, value));
|
|
}
|
|
|
|
/**
|
|
* WotLK-shaped base miss chance for attacks against NPCs. The caller may
|
|
* override this for encounters or rulesets with a different combat table.
|
|
*/
|
|
export function baseMissChancePercent(
|
|
attackKind: CombatAttackKind,
|
|
attackerLevel: number,
|
|
defenderLevel: number,
|
|
isDualWieldAutoAttack = false,
|
|
): number {
|
|
const difference = safeLevel(defenderLevel) - safeLevel(attackerLevel);
|
|
if (attackKind === "spell") {
|
|
const base = difference <= 2
|
|
? 4 + difference
|
|
: 17 + Math.max(0, difference - 3) * 11;
|
|
return Math.max(0, Math.min(100, base));
|
|
}
|
|
|
|
const base = difference <= 2
|
|
? 5 + difference * 0.5
|
|
: 8 + Math.max(0, difference - 3) * 2;
|
|
return Math.max(
|
|
0,
|
|
Math.min(100, base + (isDualWieldAutoAttack ? DUAL_WIELD_AUTO_ATTACK_MISS_PENALTY : 0)),
|
|
);
|
|
}
|
|
|
|
function cappedAttackTable(chances: readonly number[]): readonly number[] {
|
|
let remaining = 100;
|
|
return chances.map((chance) => {
|
|
const applied = Math.min(remaining, finitePercent(chance));
|
|
remaining -= applied;
|
|
return applied;
|
|
});
|
|
}
|
|
|
|
export function combatAttackTable(input: ResolveCombatResultInput): CombatAttackTable {
|
|
const { attackKind, attacker, defender } = input;
|
|
const rules = input.rules ?? {};
|
|
const expertise = attackKind === "melee"
|
|
? finitePercent(attacker.expertiseReductionPercent)
|
|
: 0;
|
|
const defaultCanDodge = attackKind === "melee";
|
|
const defaultCanParry = attackKind === "melee";
|
|
const defaultCanBlock = attackKind === "melee" || attackKind === "ranged";
|
|
const baseMiss = rules.baseMissChancePercent ?? baseMissChancePercent(
|
|
attackKind,
|
|
attacker.level,
|
|
defender.level,
|
|
Boolean(rules.isAutoAttack && rules.isDualWielding && attackKind === "melee"),
|
|
);
|
|
const rawChances = [
|
|
rules.canMiss === false ? 0 : Math.max(0, baseMiss - finitePercent(attacker.hitPercent)),
|
|
(rules.canDodge ?? defaultCanDodge)
|
|
? Math.max(0, finitePercent(defender.dodgePercent) - expertise)
|
|
: 0,
|
|
(rules.canParry ?? defaultCanParry)
|
|
? Math.max(0, finitePercent(defender.parryPercent) - expertise)
|
|
: 0,
|
|
rules.blockMode !== "post-hit" && (rules.canBlock ?? defaultCanBlock) ? finitePercent(defender.blockPercent) : 0,
|
|
rules.canCrit === false
|
|
? 0
|
|
: Math.max(
|
|
0,
|
|
finitePercent(attacker.criticalChancePercent)
|
|
- finitePercent(defender.criticalAvoidancePercent),
|
|
),
|
|
] as const;
|
|
const [missPercent, dodgePercent, parryPercent, blockPercent, criticalPercent] = cappedAttackTable(rawChances);
|
|
const hitPercent = Math.max(
|
|
0,
|
|
100 - missPercent - dodgePercent - parryPercent - blockPercent - criticalPercent,
|
|
);
|
|
return Object.freeze({
|
|
missPercent,
|
|
dodgePercent,
|
|
parryPercent,
|
|
blockPercent,
|
|
criticalPercent,
|
|
hitPercent,
|
|
});
|
|
}
|
|
|
|
function outcomeFromRoll(table: CombatAttackTable, roll: number): CombatOutcome {
|
|
const percentile = normalizedRoll(roll) * 100;
|
|
let threshold = table.missPercent;
|
|
if (percentile < threshold) return "miss";
|
|
threshold += table.dodgePercent;
|
|
if (percentile < threshold) return "dodge";
|
|
threshold += table.parryPercent;
|
|
if (percentile < threshold) return "parry";
|
|
threshold += table.blockPercent;
|
|
if (percentile < threshold) return "block";
|
|
threshold += table.criticalPercent;
|
|
if (percentile < threshold) return "crit";
|
|
return "hit";
|
|
}
|
|
|
|
function defaultResistanceMode(school: DamageSchool): CombatResistanceMode {
|
|
return school === "physical" ? "none" : "partial";
|
|
}
|
|
|
|
function resistanceFraction(
|
|
resistance: number,
|
|
attackerLevel: number,
|
|
mode: CombatResistanceMode,
|
|
roll: number,
|
|
): number {
|
|
if (mode === "none" || resistance <= 0) return 0;
|
|
const average = Math.min(
|
|
0.75,
|
|
resistance / Math.max(1, resistance + safeLevel(attackerLevel) * 5) * 0.75,
|
|
);
|
|
if (mode === "binary") return normalizedRoll(roll) < average ? 1 : 0;
|
|
|
|
// Select between adjacent 10% partial-resist buckets while preserving the
|
|
// source formula's expected mitigation over many attacks.
|
|
const lower = Math.floor((average + Number.EPSILON) / PARTIAL_RESIST_STEP) * PARTIAL_RESIST_STEP;
|
|
const upper = Math.min(1, lower + PARTIAL_RESIST_STEP);
|
|
const upperChance = upper <= lower ? 0 : (average - lower) / (upper - lower);
|
|
return normalizedRoll(roll) < upperChance ? upper : lower;
|
|
}
|
|
|
|
function emptyResult(
|
|
outcome: Extract<CombatOutcome, "miss" | "dodge" | "parry" | "resist">,
|
|
rawDamage: number,
|
|
table: CombatAttackTable,
|
|
outcomeRoll: number,
|
|
resistanceRoll: number | null,
|
|
resistedAmount = 0,
|
|
damageBeforeMitigation = 0,
|
|
): CombatResult {
|
|
return Object.freeze({
|
|
outcome,
|
|
landed: false,
|
|
critical: false,
|
|
missed: outcome === "miss",
|
|
dodged: outcome === "dodge",
|
|
parried: outcome === "parry",
|
|
blocked: false,
|
|
avoided: true,
|
|
fullyResisted: outcome === "resist",
|
|
partiallyResisted: false,
|
|
rawDamage,
|
|
damageBeforeMitigation,
|
|
effectiveArmor: 0,
|
|
armorReductionPercent: 0,
|
|
armorMitigatedAmount: 0,
|
|
blockedAmount: 0,
|
|
resistedAmount,
|
|
damageReductionAmount: 0,
|
|
finalDamage: 0,
|
|
attackTable: table,
|
|
outcomeRoll,
|
|
resistanceRoll,
|
|
resistanceFraction: outcome === "resist" ? 1 : 0,
|
|
});
|
|
}
|
|
|
|
/** Resolves one attack into a discrete, proc-friendly combat event. */
|
|
export function resolveCombatResult(input: ResolveCombatResultInput): CombatResult {
|
|
const rollSource = input.roll ?? (() => Math.random());
|
|
const outcomeRoll = normalizedRoll(rollSource("outcome"));
|
|
const table = combatAttackTable(input);
|
|
const rawDamage = Math.max(0, Math.round(finiteNonNegative(input.amount)));
|
|
if (input.rules?.immune) {
|
|
return emptyResult("resist", rawDamage, table, outcomeRoll, null, rawDamage, rawDamage);
|
|
}
|
|
const rolledOutcome = outcomeFromRoll(table, outcomeRoll);
|
|
if (rolledOutcome === "miss" || rolledOutcome === "dodge" || rolledOutcome === "parry") {
|
|
return emptyResult(rolledOutcome, rawDamage, table, outcomeRoll, null);
|
|
}
|
|
|
|
const critical = rolledOutcome === "crit";
|
|
const criticalMultiplier = Math.max(
|
|
1,
|
|
Number.isFinite(input.attacker.criticalDamageMultiplier)
|
|
? Number(input.attacker.criticalDamageMultiplier)
|
|
: DEFAULT_CRITICAL_DAMAGE_MULTIPLIER,
|
|
);
|
|
const damageBeforeMitigation = Math.max(
|
|
0,
|
|
Math.round(rawDamage * (critical ? criticalMultiplier : 1)),
|
|
);
|
|
|
|
const armorPenetration = finitePercent(input.attacker.armorPenetrationPercent);
|
|
const effectiveArmor = input.damageSchool === "physical" && !input.rules?.ignoreArmor
|
|
? finiteNonNegative(input.defender.armor) * (1 - armorPenetration / 100)
|
|
: 0;
|
|
const physicalReduction = input.damageSchool === "physical" && !input.rules?.ignoreArmor
|
|
? armorReductionPercent(effectiveArmor, input.attacker.level)
|
|
: 0;
|
|
const armorMitigatedAmount = Math.min(
|
|
damageBeforeMitigation,
|
|
Math.round(damageBeforeMitigation * physicalReduction / 100),
|
|
);
|
|
let remaining = damageBeforeMitigation - armorMitigatedAmount;
|
|
|
|
const postHitBlockChancePercent = input.rules?.blockMode === "post-hit"
|
|
&& input.rules.canBlock !== false && input.damageSchool === "physical"
|
|
&& (input.attackKind === "melee" || input.attackKind === "ranged")
|
|
? finitePercent(input.defender.blockPercent) : 0;
|
|
const postHitBlockRoll = postHitBlockChancePercent > 0
|
|
? normalizedRoll(rollSource("block")) : undefined;
|
|
const blocked = rolledOutcome === "block"
|
|
|| (postHitBlockRoll !== undefined && postHitBlockRoll * 100 < postHitBlockChancePercent);
|
|
// AzerothCore's roll_chance_i is chance > irand(0, 99), so even 0% and
|
|
// 100% consume a roll when the source supplied this stat. Keep the optional
|
|
// field absent as the compatibility boundary for existing callers.
|
|
const hasCriticalBlockChance = input.defender.criticalBlockChancePercent !== undefined;
|
|
const criticalBlockChancePercent = hasCriticalBlockChance
|
|
? (Number.isFinite(input.defender.criticalBlockChancePercent)
|
|
? Math.trunc(Number(input.defender.criticalBlockChancePercent))
|
|
: 0)
|
|
: undefined;
|
|
const criticalBlockRoll = blocked && hasCriticalBlockChance
|
|
? Math.floor(normalizedRoll(rollSource("critical-block")) * 100)
|
|
: undefined;
|
|
const criticalBlocked = criticalBlockRoll !== undefined
|
|
&& criticalBlockChancePercent !== undefined
|
|
&& criticalBlockChancePercent > criticalBlockRoll;
|
|
const blockedAmount = blocked
|
|
? Math.min(remaining, Math.round(
|
|
finiteNonNegative(input.defender.blockValue) * (criticalBlocked ? 2 : 1),
|
|
))
|
|
: 0;
|
|
remaining -= blockedAmount;
|
|
|
|
const mode = input.rules?.resistanceMode ?? defaultResistanceMode(input.damageSchool);
|
|
const targetResistance = finiteNonNegative(input.defender.resistances?.[input.damageSchool]);
|
|
const effectiveResistance = input.damageSchool === "physical"
|
|
? 0
|
|
: Math.max(0, targetResistance - finiteNonNegative(input.attacker.spellPenetration));
|
|
const needsResistanceRoll = mode !== "none" && effectiveResistance > 0;
|
|
const resistanceRoll = needsResistanceRoll
|
|
? normalizedRoll(rollSource("resistance"))
|
|
: null;
|
|
const resistedFraction = needsResistanceRoll
|
|
? resistanceFraction(effectiveResistance, input.attacker.level, mode, resistanceRoll!)
|
|
: 0;
|
|
if (resistedFraction >= 1) {
|
|
return emptyResult(
|
|
"resist",
|
|
rawDamage,
|
|
table,
|
|
outcomeRoll,
|
|
resistanceRoll,
|
|
remaining,
|
|
damageBeforeMitigation,
|
|
);
|
|
}
|
|
const resistedAmount = Math.min(remaining, Math.round(remaining * resistedFraction));
|
|
remaining -= resistedAmount;
|
|
|
|
const damageReductionPercent = finitePercent(input.defender.damageReductionPercent, 75);
|
|
const damageReductionAmount = Math.min(
|
|
remaining,
|
|
Math.round(remaining * damageReductionPercent / 100),
|
|
);
|
|
remaining -= damageReductionAmount;
|
|
|
|
return Object.freeze({
|
|
outcome: blocked && !critical ? "block" : rolledOutcome,
|
|
landed: true,
|
|
critical,
|
|
missed: false,
|
|
dodged: false,
|
|
parried: false,
|
|
blocked,
|
|
avoided: false,
|
|
fullyResisted: false,
|
|
partiallyResisted: resistedAmount > 0,
|
|
rawDamage,
|
|
damageBeforeMitigation,
|
|
effectiveArmor,
|
|
armorReductionPercent: physicalReduction,
|
|
armorMitigatedAmount,
|
|
blockedAmount,
|
|
resistedAmount,
|
|
damageReductionAmount,
|
|
finalDamage: remaining,
|
|
attackTable: table,
|
|
outcomeRoll,
|
|
resistanceRoll,
|
|
resistanceFraction: resistedFraction,
|
|
...(postHitBlockRoll !== undefined ? { postHitBlockRoll, postHitBlockChancePercent } : {}),
|
|
...(criticalBlockChancePercent !== undefined && criticalBlockRoll !== undefined ? {
|
|
criticalBlockChancePercent,
|
|
criticalBlocked,
|
|
criticalBlockRoll,
|
|
} : {}),
|
|
});
|
|
}
|
|
|
|
export function combatAttackerFromCharacterStats(
|
|
stats: CharacterStats,
|
|
attackKind: CombatAttackKind,
|
|
): CombatAttackerStats {
|
|
const hitPercent = attackKind === "spell"
|
|
? stats.spellHitPercent
|
|
: attackKind === "ranged"
|
|
? stats.rangedHitPercent
|
|
: stats.meleeHitPercent;
|
|
const criticalChancePercent = attackKind === "spell"
|
|
? stats.spellCritPercent
|
|
: attackKind === "ranged"
|
|
? stats.rangedCritPercent
|
|
: stats.meleeCritPercent;
|
|
return Object.freeze({
|
|
level: stats.level,
|
|
hitPercent,
|
|
criticalChancePercent,
|
|
expertiseReductionPercent: attackKind === "melee" ? stats.expertiseReductionPercent : 0,
|
|
armorPenetrationPercent: attackKind === "spell" ? 0 : stats.armorPenetrationPercent,
|
|
spellPenetration: attackKind === "spell" ? stats.spellPenetration : 0,
|
|
});
|
|
}
|
|
|
|
export function combatDefenderFromCharacterStats(stats: CharacterStats): CombatDefenderStats {
|
|
return Object.freeze({
|
|
level: stats.level,
|
|
armor: stats.armor,
|
|
dodgePercent: stats.dodgePercent,
|
|
parryPercent: stats.parryPercent,
|
|
blockPercent: stats.blockPercent,
|
|
blockValue: stats.blockValue,
|
|
// CharacterStats stores resilience's all-damage reduction, which is twice
|
|
// its critical-strike reduction in the 3.3.5a rules represented here.
|
|
criticalAvoidancePercent: stats.resiliencePercent / 2,
|
|
damageReductionPercent: stats.resiliencePercent,
|
|
resistances: {
|
|
arcane: stats.arcaneResistance,
|
|
fire: stats.fireResistance,
|
|
frost: stats.frostResistance,
|
|
nature: stats.natureResistance,
|
|
shadow: stats.shadowResistance,
|
|
},
|
|
});
|
|
}
|