1916 lines
63 KiB
TypeScript
1916 lines
63 KiB
TypeScript
/**
|
||
* Diablo II Combat Mathematics & Formulas.
|
||
*
|
||
* Implements canonical combat mathematics according to D2MOO, Diablo II 1.10–1.14c
|
||
* game logic, and authoritative community documentation (The Phrozen Keep, The Amazon Basin, Arreat Summit):
|
||
*
|
||
* 1. Attack Rating (AR) vs Defense Rating (DR/AC) to-hit formula with:
|
||
* - Ignore Target's Defense (ITD) - only works on normal monsters, fails on bosses/champions/players.
|
||
* - -% Target Defense - 100% on normal monsters, halved (50% effectiveness) against bosses/champions.
|
||
* - Running defender defense penalty (DR = 0 when running).
|
||
* - Clamped to [5%, 95%].
|
||
* 2. Shield blocking formula with Dexterity and Character Level scaling:
|
||
* - Capped at 75% while standing/walking/attacking.
|
||
* - Reduced to 1/3 and capped at 25% while running.
|
||
* 3. Two distinct Critical Strike types:
|
||
* - Critical Strike (CS) from skills (Amazon/Barbarian/Assassin).
|
||
* - Deadly Strike (DS) from equipment.
|
||
* - Mutually exclusive sequential roll (CS first, then DS; no 4x damage; physical damage only).
|
||
* 4. Crushing Blow (CB):
|
||
* - Normal Monster: 25% (melee) / 12.5% (ranged) current HP.
|
||
* - Boss / Champion / Super Unique: 12.5% (melee) / 6.25% (ranged) current HP.
|
||
* - Player / Merc: 10% (melee) / 5% (ranged) current HP.
|
||
* - Physical resistance interaction: reduced by 0%–99% DR; immune at >=100% DR;
|
||
* NOT amplified by negative DR (multiplier capped at 1.0).
|
||
* 5. Open Wounds (OW):
|
||
* - Fixed 200 frames (8.0 seconds at 25 fps).
|
||
* - Level-dependent 1/256th bit rate across 5 level brackets (1–15, 16–30, 31–45, 46–60, 61–99).
|
||
* - Bosses/Super Uniques take 50% damage; players take 25% (melee) / 12.5% (ranged).
|
||
* - Disables natural monster life regeneration while bleeding.
|
||
* 6. Life & Mana Steal (Leech):
|
||
* - Applied only to final physical damage.
|
||
* - Subject to target's Drain Effectiveness (e.g. Skeletons/Hell Mephisto = 0%).
|
||
* - Subject to game difficulty penalty (Normal 100%, Nightmare 50%, Hell 33.3%).
|
||
* 7. Control effects:
|
||
* - Freezes Target +X (with level difference, boss chill fallback, difficulty duration reduction).
|
||
* - Knockback (size and boss immunity).
|
||
* 8. Canonical Damage Mitigation Sequence:
|
||
* - Flat DR/MDR -> Percentage Resistance (%DR & Resists) -> Absorb.
|
||
* 9. Hit Recovery (FHR) trigger based on net damage vs Max HP thresholds.
|
||
* 10. Canonical 99-level experience progression table.
|
||
*/
|
||
|
||
export type TargetTier = 'normal' | 'boss' | 'player'
|
||
export type GameDifficulty = 'normal' | 'nightmare' | 'hell'
|
||
|
||
/**
|
||
* Options for To-Hit Chance calculation.
|
||
*/
|
||
export interface HitChanceOptions {
|
||
/** Ignore Target's Defense (ITD) affix (e.g. from Jah rune, Lightsaber). */
|
||
readonly ignoreTargetDefense?: boolean | undefined
|
||
/** -X% Target's Defense (e.g. Eth rune -25%, Conviction). */
|
||
readonly targetDefenseReductionPercent?: number | undefined
|
||
/** Whether the defender is currently running (sets defender DR to 0). */
|
||
readonly isTargetRunning?: boolean | undefined
|
||
/** Whether the defender is a boss, champion, unique, or player. */
|
||
readonly isBossOrChampion?: boolean | undefined
|
||
}
|
||
|
||
/**
|
||
* 1. To-Hit Chance (Attack Rating vs Defense Rating).
|
||
*
|
||
* Canonical formula:
|
||
* Chance = clamp(5%, 95%, 100% * (2 * AR / (AR + EffectiveDR)) * (AttackerLevel / (AttackerLevel + DefenderLevel)))
|
||
*
|
||
* Modifiers:
|
||
* - Running: Effective DR = 0.
|
||
* - ITD: Effective DR = 0 if defender is normal monster; fails on bosses/champions/players.
|
||
* - -% Target Defense: Effective on normal monsters; 50% effectiveness against bosses/champions.
|
||
*
|
||
* @param attackerAr - Attacker's Attack Rating (AR).
|
||
* @param defenderDr - Defender's Defense Rating (DR / AC).
|
||
* @param attackerLevel - Attacker's level.
|
||
* @param defenderLevel - Defender's level.
|
||
* @param options - Defensive reduction and posture options.
|
||
* @returns To-hit probability in percentage [5, 95].
|
||
*/
|
||
export function calculateHitChance(
|
||
attackerAr: number,
|
||
defenderDr: number,
|
||
attackerLevel: number,
|
||
defenderLevel: number,
|
||
options: HitChanceOptions = {},
|
||
): number {
|
||
const ar = Math.max(0, attackerAr)
|
||
let dr = Math.max(0, defenderDr)
|
||
const attLvl = Math.max(1, attackerLevel)
|
||
const defLvl = Math.max(1, defenderLevel)
|
||
|
||
if (options.isTargetRunning) {
|
||
dr = 0
|
||
} else if (options.ignoreTargetDefense && !options.isBossOrChampion) {
|
||
dr = 0
|
||
} else if (options.targetDefenseReductionPercent && options.targetDefenseReductionPercent > 0) {
|
||
const factor = options.isBossOrChampion
|
||
? options.targetDefenseReductionPercent / 2
|
||
: options.targetDefenseReductionPercent
|
||
dr = Math.max(0, dr * (1 - factor / 100))
|
||
}
|
||
|
||
if (ar + dr <= 0) return 5
|
||
|
||
const arFactor = (2 * ar) / (ar + dr)
|
||
const lvlFactor = attLvl / (attLvl + defLvl)
|
||
const rawChance = 100 * arFactor * lvlFactor
|
||
|
||
return Math.max(5, Math.min(95, Math.round(rawChance * 100) / 100))
|
||
}
|
||
|
||
/**
|
||
* 2. Player Shield Blocking Chance.
|
||
*
|
||
* Canonical formula:
|
||
* Total Block % = min(75%, floor(BaseBlock * (Dexterity - 15) / (2 * CharacterLevel)))
|
||
*
|
||
* When running, block chance is reduced to 1/3 and capped at 25%.
|
||
*
|
||
* @param baseBlock - Shield's base block chance + item bonuses.
|
||
* @param dexterity - Character's total Dexterity.
|
||
* @param characterLevel - Character level (1–99).
|
||
* @param isRunning - Whether the character is currently running.
|
||
* @returns Block chance in percentage [0, 75] (or [0, 25] if running).
|
||
*/
|
||
export function calculatePlayerBlockChance(
|
||
baseBlock: number,
|
||
dexterity: number,
|
||
characterLevel: number,
|
||
isRunning = false,
|
||
): number {
|
||
if (baseBlock <= 0 || dexterity <= 15 || characterLevel <= 0) return 0
|
||
const rawBlock = Math.floor((baseBlock * (dexterity - 15)) / (2 * characterLevel))
|
||
if (isRunning) {
|
||
return Math.max(0, Math.min(25, Math.floor(rawBlock / 3)))
|
||
}
|
||
return Math.max(0, Math.min(75, rawBlock))
|
||
}
|
||
|
||
/**
|
||
* 3. Combined Critical Strike / Deadly Strike chance.
|
||
*
|
||
* In D2:
|
||
* Critical Strike (CS) and Deadly Strike (DS) each double physical damage,
|
||
* but cannot proc simultaneously to quadruple damage.
|
||
* Combined probability:
|
||
* P = CS + DS * (1 - CS)
|
||
*
|
||
* @param criticalStrikePercent - Critical Strike % from skills [0, 100].
|
||
* @param deadlyStrikePercent - Deadly Strike % from equipment [0, 100].
|
||
* @returns Combined double-damage probability % [0, 100].
|
||
*/
|
||
export function calculateCriticalChance(
|
||
criticalStrikePercent: number,
|
||
deadlyStrikePercent: number,
|
||
): number {
|
||
const cs = Math.max(0, Math.min(100, criticalStrikePercent)) / 100
|
||
const ds = Math.max(0, Math.min(100, deadlyStrikePercent)) / 100
|
||
const combined = cs + ds * (1 - cs)
|
||
return Math.round(combined * 10000) / 100
|
||
}
|
||
|
||
/**
|
||
* Detailed outcome of sequential CS/DS evaluation.
|
||
*/
|
||
export interface CriticalEvaluationResult {
|
||
readonly isCritical: boolean
|
||
readonly triggeredBy: 'none' | 'critical_strike' | 'deadly_strike'
|
||
readonly csRoll: number
|
||
readonly dsRoll: number
|
||
readonly combinedChancePercent: number
|
||
}
|
||
|
||
/**
|
||
* Evaluates Critical Strike (skill) and Deadly Strike (item) in strict canonical sequence:
|
||
* Roll CS first; if it fails, roll DS. If either procs, physical damage is doubled.
|
||
*
|
||
* @param criticalStrikePercent - Critical Strike % from skills.
|
||
* @param deadlyStrikePercent - Deadly Strike % from equipment.
|
||
* @param randomFn - Random generator returning [0, 1).
|
||
*/
|
||
export function evaluateCriticalAndDeadlyStrike(
|
||
criticalStrikePercent: number,
|
||
deadlyStrikePercent: number,
|
||
randomFn: () => number = Math.random,
|
||
): CriticalEvaluationResult {
|
||
const cs = Math.max(0, Math.min(100, criticalStrikePercent))
|
||
const ds = Math.max(0, Math.min(100, deadlyStrikePercent))
|
||
const combinedChancePercent = calculateCriticalChance(cs, ds)
|
||
|
||
const csRoll = Math.round(randomFn() * 10000) / 100
|
||
if (cs > 0 && csRoll < cs) {
|
||
return {
|
||
isCritical: true,
|
||
triggeredBy: 'critical_strike',
|
||
csRoll,
|
||
dsRoll: 0,
|
||
combinedChancePercent,
|
||
}
|
||
}
|
||
|
||
const dsRoll = Math.round(randomFn() * 10000) / 100
|
||
if (ds > 0 && dsRoll < ds) {
|
||
return {
|
||
isCritical: true,
|
||
triggeredBy: 'deadly_strike',
|
||
csRoll,
|
||
dsRoll,
|
||
combinedChancePercent,
|
||
}
|
||
}
|
||
|
||
return {
|
||
isCritical: false,
|
||
triggeredBy: 'none',
|
||
csRoll,
|
||
dsRoll,
|
||
combinedChancePercent,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 4. Crushing Blow Damage.
|
||
*
|
||
* Base ratio of current HP truncated:
|
||
* - Normal Monster: Melee 25% (1/4), Ranged 12.5% (1/8).
|
||
* - Boss / Champion / Super Unique: Melee 12.5% (1/8), Ranged 6.25% (1/16).
|
||
* - Player / Mercenary: Melee 10% (1/10), Ranged 5% (1/20).
|
||
*
|
||
* Physical Resistance (DR%) Interaction:
|
||
* - If Physical Resistance >= 100% (Physical Immune): CB deals 0 damage.
|
||
* - If Physical Resistance is in [0%, 99%]: CB damage is reduced by DR%.
|
||
* - If Physical Resistance < 0%: CB damage is NOT amplified (factor capped at 1.0).
|
||
* - Flat DR does NOT reduce CB.
|
||
*
|
||
* @param currentHp - Target's current HP before attack.
|
||
* @param targetTierOrBoss - Target classification ('normal', 'boss', 'player', or boolean for backwards-compatibility).
|
||
* @param isRanged - Whether the attack is ranged.
|
||
* @param targetPhysicalResistance - Target's physical resistance % (DR%).
|
||
* @returns Final Crushing Blow damage applied to HP.
|
||
*/
|
||
export function calculateCrushingBlowDamage(
|
||
currentHp: number,
|
||
targetTierOrBoss: boolean | TargetTier = false,
|
||
isRanged = false,
|
||
targetPhysicalResistance = 0,
|
||
): number {
|
||
if (currentHp <= 0) return 0
|
||
if (targetPhysicalResistance >= 100) return 0
|
||
|
||
let ratio = 0.25
|
||
const isPlayer = targetTierOrBoss === 'player'
|
||
const isBoss = targetTierOrBoss === true || targetTierOrBoss === 'boss'
|
||
|
||
if (isPlayer) {
|
||
ratio = isRanged ? 0.05 : 0.10
|
||
} else if (isBoss) {
|
||
ratio = isRanged ? 0.0625 : 0.125
|
||
} else {
|
||
ratio = isRanged ? 0.125 : 0.25
|
||
}
|
||
|
||
const baseDmg = Math.floor(currentHp * ratio)
|
||
const resFactor = targetPhysicalResistance > 0
|
||
? Math.max(0, (100 - targetPhysicalResistance) / 100)
|
||
: 1.0
|
||
|
||
return Math.floor(baseDmg * resFactor)
|
||
}
|
||
|
||
/**
|
||
* 5. Open Wounds (OW) Damage.
|
||
*
|
||
* Canonical 1.10+ formula:
|
||
* Lasts 200 frames (8.0 seconds at 25 fps).
|
||
* Life drain per frame in 1/256th point units based on attacker level (Clvl):
|
||
* Clvl 1–15: (9 * Clvl + 31)
|
||
* Clvl 16–30: (18 * Clvl - 104)
|
||
* Clvl 31–45: (27 * Clvl - 374)
|
||
* Clvl 46–60: (36 * Clvl - 779)
|
||
* Clvl >60: (45 * Clvl - 1319)
|
||
*
|
||
* Modifiers:
|
||
* - Boss / Champion / Super Unique: 1/2 (x0.5) for both melee and ranged.
|
||
* - Player: 1/4 (x0.25) for melee, 1/8 (x0.125) for ranged.
|
||
* - Normal monster: unmodified (x1.0).
|
||
*
|
||
* Crucial property: Disables natural monster life regeneration while active.
|
||
*/
|
||
export interface OpenWoundsDamageResult {
|
||
readonly attackerLevel: number
|
||
readonly lifeDrainPerFrame: number // in 1/256th point units
|
||
readonly damagePerFrame: number // actual HP per frame
|
||
readonly damagePerSecond: number // 25 fps
|
||
readonly totalDamage200Frames: number
|
||
readonly durationFrames: number // 200
|
||
readonly durationSeconds: number // 8.0
|
||
readonly modifierFactor: number
|
||
readonly isBoss: boolean
|
||
readonly isPlayer: boolean
|
||
}
|
||
|
||
export function calculateOpenWoundsDamage(
|
||
attackerLevel: number,
|
||
targetTierOrBoss: boolean | TargetTier = 'normal',
|
||
isRanged = false,
|
||
): OpenWoundsDamageResult {
|
||
const lvl = Math.max(1, Math.min(99, Math.floor(attackerLevel)))
|
||
|
||
let basePerFrame = 0
|
||
if (lvl <= 15) {
|
||
basePerFrame = 9 * lvl + 31
|
||
} else if (lvl <= 30) {
|
||
basePerFrame = 18 * lvl - 104
|
||
} else if (lvl <= 45) {
|
||
basePerFrame = 27 * lvl - 374
|
||
} else if (lvl <= 60) {
|
||
basePerFrame = 36 * lvl - 779
|
||
} else {
|
||
basePerFrame = 45 * lvl - 1319
|
||
}
|
||
|
||
let modifierFactor = 1.0
|
||
const isBoss = targetTierOrBoss === true || targetTierOrBoss === 'boss'
|
||
const isPlayer = targetTierOrBoss === 'player'
|
||
|
||
if (isBoss) {
|
||
modifierFactor = 0.5
|
||
} else if (isPlayer) {
|
||
modifierFactor = isRanged ? 0.125 : 0.25
|
||
}
|
||
|
||
const damagePerFrame = (basePerFrame * modifierFactor) / 256
|
||
const damagePerSecond = Math.round(damagePerFrame * 25 * 100) / 100
|
||
const totalDamage200Frames = Math.floor(damagePerFrame * 200)
|
||
|
||
return {
|
||
attackerLevel: lvl,
|
||
lifeDrainPerFrame: basePerFrame,
|
||
damagePerFrame,
|
||
damagePerSecond,
|
||
totalDamage200Frames,
|
||
durationFrames: 200,
|
||
durationSeconds: 8.0,
|
||
modifierFactor,
|
||
isBoss,
|
||
isPlayer,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 6. Life & Mana Steal (Leech).
|
||
*
|
||
* Rules:
|
||
* - Only applies to the final physical damage dealt to the target.
|
||
* - Multiplied by target's Drain Effectiveness (from MonStats.txt, 0% to 100%).
|
||
* - Multiplied by game difficulty penalty:
|
||
* Normal: 100% (x1.0)
|
||
* Nightmare: 50% (x0.5)
|
||
* Hell: 33.3% (x1/3)
|
||
*/
|
||
export interface LeechResult {
|
||
readonly lifeLeeched: number
|
||
readonly manaLeeched: number
|
||
readonly difficultyPenaltyFactor: number
|
||
readonly drainEffectivenessFactor: number
|
||
readonly rawLifeAttempted: number
|
||
readonly rawManaAttempted: number
|
||
}
|
||
|
||
export function calculateLeech(
|
||
finalPhysicalDamage: number,
|
||
lifeLeechPercent: number,
|
||
manaLeechPercent: number,
|
||
drainEffectivenessPercent = 100,
|
||
difficulty: GameDifficulty = 'normal',
|
||
): LeechResult {
|
||
if (finalPhysicalDamage <= 0) {
|
||
return {
|
||
lifeLeeched: 0,
|
||
manaLeeched: 0,
|
||
difficultyPenaltyFactor: 1.0,
|
||
drainEffectivenessFactor: Math.max(0, drainEffectivenessPercent) / 100,
|
||
rawLifeAttempted: 0,
|
||
rawManaAttempted: 0,
|
||
}
|
||
}
|
||
|
||
let diffPenalty = 1.0
|
||
if (difficulty === 'nightmare') {
|
||
diffPenalty = 0.5
|
||
} else if (difficulty === 'hell') {
|
||
diffPenalty = 1 / 3
|
||
}
|
||
|
||
const drainFactor = Math.max(0, drainEffectivenessPercent) / 100
|
||
const rawLife = finalPhysicalDamage * (Math.max(0, lifeLeechPercent) / 100)
|
||
const rawMana = finalPhysicalDamage * (Math.max(0, manaLeechPercent) / 100)
|
||
|
||
const lifeLeeched = Math.floor(rawLife * drainFactor * diffPenalty)
|
||
const manaLeeched = Math.floor(rawMana * drainFactor * diffPenalty)
|
||
|
||
return {
|
||
lifeLeeched,
|
||
manaLeeched,
|
||
difficultyPenaltyFactor: diffPenalty,
|
||
drainEffectivenessFactor: drainFactor,
|
||
rawLifeAttempted: Math.round(rawLife * 10) / 10,
|
||
rawManaAttempted: Math.round(rawMana * 10) / 10,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 7. Freezes Target +X calculation.
|
||
*
|
||
* Canonical formulas:
|
||
* Melee: Chance = clamp(0, 100, 5 * (4 * B + AttackerLevel - DefenderLevel) + 30)
|
||
* Ranged: Chance = clamp(0, 100, 5 * (4 * B + (AttackerLevel - 6) - DefenderLevel) / 3)
|
||
*
|
||
* Target rules:
|
||
* - Bosses, Champions, Super Uniques and Players cannot be frozen; they are chilled instead.
|
||
* - Duration = (Chance - Roll) * 2 + 25 frames [clamped 25, 250 frames].
|
||
* - Duration is halved in Nightmare, quartered in Hell.
|
||
*/
|
||
export interface FreezeTargetResult {
|
||
readonly chancePercent: number
|
||
readonly roll: number
|
||
readonly willFreeze: boolean
|
||
readonly isChilledOnly: boolean
|
||
readonly durationFrames: number
|
||
readonly durationSeconds: number
|
||
}
|
||
|
||
export function calculateFreezeTarget(
|
||
freezeBonus: number,
|
||
attackerLevel: number,
|
||
defenderLevel: number,
|
||
targetTierOrBoss: boolean | TargetTier = 'normal',
|
||
isRanged = false,
|
||
difficulty: GameDifficulty = 'normal',
|
||
randomFn: () => number = Math.random,
|
||
): FreezeTargetResult {
|
||
if (freezeBonus <= 0) {
|
||
return {
|
||
chancePercent: 0,
|
||
roll: 0,
|
||
willFreeze: false,
|
||
isChilledOnly: false,
|
||
durationFrames: 0,
|
||
durationSeconds: 0,
|
||
}
|
||
}
|
||
|
||
const B = freezeBonus
|
||
const al = attackerLevel
|
||
const dl = defenderLevel
|
||
|
||
let rawChance = 0
|
||
if (!isRanged) {
|
||
rawChance = 5 * (4 * B + al - dl) + 30
|
||
} else {
|
||
rawChance = (5 * (4 * B + (al - 6) - dl)) / 3
|
||
}
|
||
|
||
const chancePercent = Math.max(0, Math.min(100, Math.round(rawChance * 10) / 10))
|
||
const roll = Math.round(randomFn() * 10000) / 100
|
||
const success = roll < chancePercent
|
||
|
||
if (!success) {
|
||
return {
|
||
chancePercent,
|
||
roll,
|
||
willFreeze: false,
|
||
isChilledOnly: false,
|
||
durationFrames: 0,
|
||
durationSeconds: 0,
|
||
}
|
||
}
|
||
|
||
const isBossOrPlayer = targetTierOrBoss === true || targetTierOrBoss === 'boss' || targetTierOrBoss === 'player'
|
||
if (isBossOrPlayer) {
|
||
return {
|
||
chancePercent,
|
||
roll,
|
||
willFreeze: false,
|
||
isChilledOnly: true,
|
||
durationFrames: 75,
|
||
durationSeconds: 3.0,
|
||
}
|
||
}
|
||
|
||
let duration = Math.min(250, Math.max(25, Math.floor((chancePercent - roll) * 2 + 25)))
|
||
if (difficulty === 'nightmare') {
|
||
duration = Math.floor(duration / 2)
|
||
} else if (difficulty === 'hell') {
|
||
duration = Math.floor(duration / 4)
|
||
}
|
||
|
||
return {
|
||
chancePercent,
|
||
roll,
|
||
willFreeze: true,
|
||
isChilledOnly: false,
|
||
durationFrames: duration,
|
||
durationSeconds: Math.round((duration / 25) * 10) / 10,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 8. Resistance Damage Multiplier.
|
||
*
|
||
* In D2:
|
||
* - Resistance >= 100% means Immune (0 damage).
|
||
* - Resistance between 0% and 99% reduces damage: Damage * (1 - Res / 100).
|
||
* - Resistance < 0% amplifies damage: Damage * (1 + |Res| / 100), capped at -100% (2x damage).
|
||
*
|
||
* @param resistancePercent - Target's resistance percentage.
|
||
* @returns Multiplier factor (0 for immune, >1 for negative resistance) and immunity flag.
|
||
*/
|
||
export function calculateResistanceFactor(resistancePercent: number): {
|
||
readonly factor: number
|
||
readonly isImmune: boolean
|
||
} {
|
||
if (resistancePercent >= 100) {
|
||
return { factor: 0, isImmune: true }
|
||
}
|
||
const clampedRes = Math.max(-100, resistancePercent)
|
||
const factor = (100 - clampedRes) / 100
|
||
return { factor, isImmune: false }
|
||
}
|
||
|
||
/**
|
||
* 8b. Resistance Reduction & 1/5th Rule for Breaking Immunities.
|
||
*
|
||
* Canonical Diablo II 1.10+ rules:
|
||
* - If target's initial resistance >= 100% (Immune):
|
||
* - Conviction Aura and Lower Resist Curse have their effectiveness reduced to 1/5th (20%).
|
||
* - In integer arithmetic: floor(Penalty / 5).
|
||
* - If (InitialRes - EffectiveConviction - EffectiveLowerRes) >= 100%:
|
||
* - Immunity is NOT broken.
|
||
* - Direct equipment reduction (-% Enemy Resistance, e.g. Rainbow Facet, Griffon's Eye) CANNOT apply!
|
||
* - Target remains immune (0 damage).
|
||
* - If (InitialRes - EffectiveConviction - EffectiveLowerRes) < 100%:
|
||
* - Immunity IS BROKEN!
|
||
* - Direct equipment reduction (-% Enemy Resistance) now applies at 100% FULL effectiveness!
|
||
* - If target's initial resistance < 100% (Non-Immune):
|
||
* - Conviction, Lower Resist, and equipment reduction all apply at 100% full strength.
|
||
* - Resistance is capped at a lower bound of -100% (2x damage multiplier).
|
||
*/
|
||
export interface ResistanceReductionResult {
|
||
readonly initialRes: number
|
||
readonly wasImmune: boolean
|
||
readonly isImmune: boolean
|
||
readonly immunityBroken: boolean
|
||
readonly convictionPenalty: number
|
||
readonly effectiveConviction: number
|
||
readonly lowerResPenalty: number
|
||
readonly effectiveLowerRes: number
|
||
readonly itemMinusRes: number
|
||
readonly effectiveItemMinusRes: number
|
||
readonly resAfterSkills: number
|
||
readonly finalRes: number
|
||
readonly damageMultiplier: number
|
||
}
|
||
|
||
export function calculateResistanceReduction(
|
||
enemyRes: number,
|
||
convictionPenalty = 0,
|
||
lowerResPenalty = 0,
|
||
itemMinusRes = 0,
|
||
): ResistanceReductionResult {
|
||
const initialRes = enemyRes
|
||
const wasImmune = initialRes >= 100
|
||
|
||
let effectiveConviction = Math.max(0, convictionPenalty)
|
||
let effectiveLowerRes = Math.max(0, lowerResPenalty)
|
||
|
||
if (wasImmune) {
|
||
// 1/5th Rule: skills only have 20% effectiveness against immune monsters
|
||
effectiveConviction = Math.floor(effectiveConviction / 5)
|
||
effectiveLowerRes = Math.floor(effectiveLowerRes / 5)
|
||
}
|
||
|
||
const resAfterSkills = initialRes - (effectiveConviction + effectiveLowerRes)
|
||
const immunityBroken = wasImmune && resAfterSkills < 100
|
||
|
||
let effectiveItemMinusRes = 0
|
||
let isImmune = false
|
||
let finalRes = resAfterSkills
|
||
|
||
if (resAfterSkills >= 100) {
|
||
// Immunity persists: equipment -% enemy resistance fails completely
|
||
isImmune = true
|
||
effectiveItemMinusRes = 0
|
||
finalRes = resAfterSkills
|
||
} else {
|
||
// Non-immune or broken immunity: equipment -% resistance applies at 100% full effect
|
||
isImmune = false
|
||
effectiveItemMinusRes = Math.max(0, itemMinusRes)
|
||
finalRes = Math.max(-100, resAfterSkills - effectiveItemMinusRes)
|
||
}
|
||
|
||
const damageMultiplier = isImmune ? 0 : Math.round(((100 - finalRes) / 100) * 10000) / 10000
|
||
|
||
return {
|
||
initialRes,
|
||
wasImmune,
|
||
isImmune,
|
||
immunityBroken,
|
||
convictionPenalty: Math.max(0, convictionPenalty),
|
||
effectiveConviction,
|
||
lowerResPenalty: Math.max(0, lowerResPenalty),
|
||
effectiveLowerRes,
|
||
itemMinusRes: Math.max(0, itemMinusRes),
|
||
effectiveItemMinusRes,
|
||
resAfterSkills,
|
||
finalRes,
|
||
damageMultiplier,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 8c. Monster Life Regeneration & Prevent Monster Heal (PMH).
|
||
*
|
||
* Canonical D2 mechanics:
|
||
* - Natural regeneration per frame:
|
||
* Regen/frame = (MaxHP * RegenRate) / 4096
|
||
* (RegenRate is from MonStats.txt, typically 1 to 50).
|
||
* - At 25 fps:
|
||
* Regen/sec = (MaxHP * RegenRate * 25) / 4096
|
||
* - Natural regeneration is completely suppressed to 0 if:
|
||
* - Target is under Open Wounds (OW) bleeding (lasts 200 frames / 8 seconds).
|
||
* - Target is inflicted with Prevent Monster Heal (PMH) (lasts 120,000 frames / 80 minutes).
|
||
*/
|
||
export interface MonsterRegenResult {
|
||
readonly maxHp: number
|
||
readonly regenRate: number
|
||
readonly rawRegenPerFrame: number
|
||
readonly rawRegenPerSecond: number
|
||
readonly effectiveRegenPerFrame: number
|
||
readonly effectiveRegenPerSecond: number
|
||
readonly isBlockedByOW: boolean
|
||
readonly isBlockedByPMH: boolean
|
||
}
|
||
|
||
export function calculateMonsterRegeneration(
|
||
maxHp: number,
|
||
regenRate: number,
|
||
hasOW = false,
|
||
hasPMH = false,
|
||
): MonsterRegenResult {
|
||
const hp = Math.max(0, maxHp)
|
||
const rate = Math.max(0, regenRate)
|
||
|
||
const rawRegenPerFrame = (hp * rate) / 4096
|
||
const rawRegenPerSecond = Math.round(rawRegenPerFrame * 25 * 100) / 100
|
||
|
||
const isBlocked = hasOW || hasPMH
|
||
const effectiveRegenPerFrame = isBlocked ? 0 : rawRegenPerFrame
|
||
const effectiveRegenPerSecond = isBlocked ? 0 : rawRegenPerSecond
|
||
|
||
return {
|
||
maxHp: hp,
|
||
regenRate: rate,
|
||
rawRegenPerFrame,
|
||
rawRegenPerSecond,
|
||
effectiveRegenPerFrame,
|
||
effectiveRegenPerSecond,
|
||
isBlockedByOW: hasOW,
|
||
isBlockedByPMH: hasPMH,
|
||
}
|
||
}
|
||
|
||
export interface PreventMonsterHealEvaluation {
|
||
readonly applied: boolean
|
||
readonly durationFrames: number // 120,000 frames = 4800s = 80min
|
||
readonly durationSeconds: number
|
||
readonly reason: string
|
||
}
|
||
|
||
export function evaluatePreventMonsterHeal(
|
||
attackerType: 'player' | 'mercenary' | 'minion' = 'player',
|
||
targetTierOrUber: 'normal' | 'champion' | 'boss' | 'uber' = 'normal',
|
||
): PreventMonsterHealEvaluation {
|
||
if (attackerType !== 'player') {
|
||
return {
|
||
applied: false,
|
||
durationFrames: 0,
|
||
durationSeconds: 0,
|
||
reason: 'PMH 仅能由玩家本体近战或远程攻击命中触发 (雇佣兵与仆从佩戴无效)',
|
||
}
|
||
}
|
||
|
||
if (targetTierOrUber === 'uber') {
|
||
return {
|
||
applied: false,
|
||
durationFrames: 0,
|
||
durationSeconds: 0,
|
||
reason: '超级地狱火炬 Boss (Pandemonium Ubers) 免疫阻止怪物自愈 (PMH)',
|
||
}
|
||
}
|
||
|
||
return {
|
||
applied: true,
|
||
durationFrames: 120000,
|
||
durationSeconds: 4800,
|
||
reason: '阻止怪物自愈 (PMH) 命中生效，持续 120,000 帧 (80 分钟)',
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 8d. Knockback vs Monster Size & Boss Immunity.
|
||
*
|
||
* Canonical D2 rules:
|
||
* - Bosses (Andariel, Duriel, Mephisto, Diablo, Baal, etc.) and Siege Beasts:
|
||
* 100% IMMUNE to knockback (0% chance).
|
||
* - Non-bosses with Knockback affix:
|
||
* - Melee: Small 100%, Medium 50%, Large 25%.
|
||
* - Ranged: Small 50%, Medium 25%, Large 12.5%.
|
||
*/
|
||
export type MonsterSize = 'small' | 'medium' | 'large'
|
||
|
||
export interface KnockbackEvaluationResult {
|
||
readonly hasKnockbackAffix: boolean
|
||
readonly isBossOrImmune: boolean
|
||
readonly size: MonsterSize
|
||
readonly isRanged: boolean
|
||
readonly baseSizeChancePercent: number
|
||
readonly finalChancePercent: number
|
||
readonly roll: number
|
||
readonly triggered: boolean
|
||
readonly reason: string
|
||
}
|
||
|
||
export function calculateKnockbackSuccess(
|
||
hasKnockback: boolean,
|
||
defenderSize: MonsterSize = 'medium',
|
||
isBossOrImmune = false,
|
||
isRanged = false,
|
||
randomFn: () => number = Math.random,
|
||
): KnockbackEvaluationResult {
|
||
if (!hasKnockback) {
|
||
return {
|
||
hasKnockbackAffix: false,
|
||
isBossOrImmune,
|
||
size: defenderSize,
|
||
isRanged,
|
||
baseSizeChancePercent: 0,
|
||
finalChancePercent: 0,
|
||
roll: 0,
|
||
triggered: false,
|
||
reason: '攻击未附带击退词缀',
|
||
}
|
||
}
|
||
|
||
if (isBossOrImmune) {
|
||
return {
|
||
hasKnockbackAffix: true,
|
||
isBossOrImmune: true,
|
||
size: defenderSize,
|
||
isRanged,
|
||
baseSizeChancePercent: 0,
|
||
finalChancePercent: 0,
|
||
roll: 0,
|
||
triggered: false,
|
||
reason: '关底首领 (Boss) 与攻城巨兽完全豁免击退效果',
|
||
}
|
||
}
|
||
|
||
let baseChance = 50
|
||
if (defenderSize === 'small') {
|
||
baseChance = isRanged ? 50 : 100
|
||
} else if (defenderSize === 'medium') {
|
||
baseChance = isRanged ? 25 : 50
|
||
} else {
|
||
baseChance = isRanged ? 12.5 : 25
|
||
}
|
||
|
||
const roll = Math.round(randomFn() * 10000) / 100
|
||
const triggered = roll < baseChance
|
||
|
||
return {
|
||
hasKnockbackAffix: true,
|
||
isBossOrImmune: false,
|
||
size: defenderSize,
|
||
isRanged,
|
||
baseSizeChancePercent: baseChance,
|
||
finalChancePercent: baseChance,
|
||
roll,
|
||
triggered,
|
||
reason: triggered
|
||
? `体型 ${defenderSize} (${baseChance}%几率) 击退成功 (掷骰 ${roll.toFixed(1)}%)`
|
||
: `体型 ${defenderSize} (${baseChance}%几率) 掷骰未触发击退 (掷骰 ${roll.toFixed(1)}%)`,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 8e. Slows Target by X% (减速目标).
|
||
*
|
||
* Rules:
|
||
* - Normal monsters: capped at 90%.
|
||
* - Bosses / Champions / Super Uniques: capped at 50%.
|
||
* - Stacks with Holy Freeze / Cold chill up to caps.
|
||
*/
|
||
export interface SlowTargetResult {
|
||
readonly requestedSlowPercent: number
|
||
readonly isBoss: boolean
|
||
readonly maxCapPercent: number
|
||
readonly effectiveSlowPercent: number
|
||
readonly reason: string
|
||
}
|
||
|
||
export function calculateSlowTarget(
|
||
requestedSlowPercent: number,
|
||
isBoss = false,
|
||
): SlowTargetResult {
|
||
const req = Math.max(0, requestedSlowPercent)
|
||
const maxCapPercent = isBoss ? 50 : 90
|
||
const effectiveSlowPercent = Math.min(maxCapPercent, req)
|
||
|
||
const reason = isBoss && req > 50
|
||
? `首领/精英减速上限封顶为 50% (原请求 ${req}%)`
|
||
: `减速目标生效: ${effectiveSlowPercent}%`
|
||
|
||
return {
|
||
requestedSlowPercent: req,
|
||
isBoss,
|
||
maxCapPercent,
|
||
effectiveSlowPercent,
|
||
reason,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 8f. Crowd Control: Hit Blinds Target (HBT) & Hit Causes Monster to Flee (HCMTF).
|
||
*
|
||
* Hit Blinds Target:
|
||
* - Melee: Chance = clamp(1, 100, 50 + (AttackerLevel + Bonus * 4 - TargetLevel) * 2)
|
||
* - Ranged: Chance = clamp(1, 100, (50 + (AttackerLevel + Bonus * 4 - TargetLevel) * 2) / 3)
|
||
* - Bosses / Champions / Uniques are IMMUNE.
|
||
* - Duration: (Bonus * 4 + 4) seconds.
|
||
*
|
||
* Hit Causes Monster to Flee:
|
||
* - Fixed 125 frames (5.0 seconds).
|
||
* - Bosses and Champions are IMMUNE.
|
||
*/
|
||
export interface HitBlindsTargetResult {
|
||
readonly bonus: number
|
||
readonly attackerLevel: number
|
||
readonly targetLevel: number
|
||
readonly isBossOrChampion: boolean
|
||
readonly isRanged: boolean
|
||
readonly chancePercent: number
|
||
readonly roll: number
|
||
readonly triggered: boolean
|
||
readonly durationFrames: number
|
||
readonly durationSeconds: number
|
||
readonly reason: string
|
||
}
|
||
|
||
export function calculateHitBlindsTarget(
|
||
bonus: number,
|
||
attackerLevel: number,
|
||
targetLevel: number,
|
||
isBossOrChampion = false,
|
||
isRanged = false,
|
||
randomFn: () => number = Math.random,
|
||
): HitBlindsTargetResult {
|
||
if (bonus <= 0) {
|
||
return {
|
||
bonus: 0,
|
||
attackerLevel,
|
||
targetLevel,
|
||
isBossOrChampion,
|
||
isRanged,
|
||
chancePercent: 0,
|
||
roll: 0,
|
||
triggered: false,
|
||
durationFrames: 0,
|
||
durationSeconds: 0,
|
||
reason: '无致盲词缀 (Hit Blinds Target)',
|
||
}
|
||
}
|
||
|
||
if (isBossOrChampion) {
|
||
return {
|
||
bonus,
|
||
attackerLevel,
|
||
targetLevel,
|
||
isBossOrChampion: true,
|
||
isRanged,
|
||
chancePercent: 0,
|
||
roll: 0,
|
||
triggered: false,
|
||
durationFrames: 0,
|
||
durationSeconds: 0,
|
||
reason: '首领、暗金怪与冠军怪免疫致盲效果',
|
||
}
|
||
}
|
||
|
||
const rawMeleeChance = 50 + (attackerLevel + bonus * 4 - targetLevel) * 2
|
||
const rawChance = isRanged ? rawMeleeChance / 3 : rawMeleeChance
|
||
const chancePercent = Math.max(1, Math.min(100, Math.round(rawChance * 10) / 10))
|
||
|
||
const roll = Math.round(randomFn() * 10000) / 100
|
||
const triggered = roll < chancePercent
|
||
|
||
const durationSeconds = bonus * 4 + 4
|
||
const durationFrames = durationSeconds * 25
|
||
|
||
return {
|
||
bonus,
|
||
attackerLevel,
|
||
targetLevel,
|
||
isBossOrChampion: false,
|
||
isRanged,
|
||
chancePercent,
|
||
roll,
|
||
triggered,
|
||
durationFrames: triggered ? durationFrames : 0,
|
||
durationSeconds: triggered ? durationSeconds : 0,
|
||
reason: triggered
|
||
? `致盲命中！使目标盲目 (微暗灵视) 持续 ${durationSeconds} 秒 (${chancePercent}%几率)`
|
||
: `致盲未命中 (${chancePercent}%几率, 掷骰 ${roll.toFixed(1)}%)`,
|
||
}
|
||
}
|
||
|
||
export interface HitCausesFleeResult {
|
||
readonly fleeChancePercent: number
|
||
readonly isBossOrChampion: boolean
|
||
readonly roll: number
|
||
readonly triggered: boolean
|
||
readonly durationFrames: number
|
||
readonly durationSeconds: number
|
||
readonly reason: string
|
||
}
|
||
|
||
export function calculateHitCausesFlee(
|
||
fleeChancePercent: number,
|
||
isBossOrChampion = false,
|
||
randomFn: () => number = Math.random,
|
||
): HitCausesFleeResult {
|
||
const chance = Math.max(0, Math.min(100, fleeChancePercent))
|
||
if (chance <= 0) {
|
||
return {
|
||
fleeChancePercent: 0,
|
||
isBossOrChampion,
|
||
roll: 0,
|
||
triggered: false,
|
||
durationFrames: 0,
|
||
durationSeconds: 0,
|
||
reason: '无恐吓逃跑词缀',
|
||
}
|
||
}
|
||
|
||
if (isBossOrChampion) {
|
||
return {
|
||
fleeChancePercent: chance,
|
||
isBossOrChampion: true,
|
||
roll: 0,
|
||
triggered: false,
|
||
durationFrames: 0,
|
||
durationSeconds: 0,
|
||
reason: '首领与冠军怪物免疫恐吓逃跑效果',
|
||
}
|
||
}
|
||
|
||
const roll = Math.round(randomFn() * 10000) / 100
|
||
const triggered = roll < chance
|
||
const durationFrames = triggered ? 125 : 0
|
||
const durationSeconds = triggered ? 5.0 : 0
|
||
|
||
return {
|
||
fleeChancePercent: chance,
|
||
isBossOrChampion: false,
|
||
roll,
|
||
triggered,
|
||
durationFrames,
|
||
durationSeconds,
|
||
reason: triggered
|
||
? `恐吓逃跑生效！怪物陷入恐惧逃窜 5 秒 (几率 ${chance}%)`
|
||
: `恐吓未触发 (几率 ${chance}%, 掷骰 ${roll.toFixed(1)}%)`,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 8g. Physical Damage Decomposition (Off-Weapon ED & Flat +Damage / Grief).
|
||
*
|
||
* Canonical Formula:
|
||
* BaseMin = floor(WeaponBaseMin * (1 + OnWeaponED / 100)) + FlatDamage
|
||
* BaseMax = floor(WeaponBaseMax * (1 + OnWeaponED / 100)) + FlatDamage
|
||
* TotalPhysMin = floor(BaseMin * (1 + (OffWeaponED + StatBonus) / 100))
|
||
* TotalPhysMax = floor(BaseMax * (1 + (OffWeaponED + StatBonus) / 100))
|
||
*/
|
||
export interface PhysicalDamageComponents {
|
||
readonly weaponBaseMin: number
|
||
readonly weaponBaseMax: number
|
||
readonly onWeaponEdPercent?: number | undefined
|
||
readonly flatDamage?: number | undefined
|
||
readonly offWeaponEdPercent?: number | undefined
|
||
readonly statBonusPercent?: number | undefined
|
||
}
|
||
|
||
export interface PhysicalDamageRangeResult {
|
||
readonly weaponBaseMin: number
|
||
readonly weaponBaseMax: number
|
||
readonly onWeaponEdPercent: number
|
||
readonly baseMinWithWeaponEd: number
|
||
readonly baseMaxWithWeaponEd: number
|
||
readonly flatDamage: number
|
||
readonly baseMinWithFlat: number
|
||
readonly baseMaxWithFlat: number
|
||
readonly offWeaponEdPercent: number
|
||
readonly statBonusPercent: number
|
||
readonly totalMultiplier: number
|
||
readonly finalMinDamage: number
|
||
readonly finalMaxDamage: number
|
||
}
|
||
|
||
export function calculatePhysicalWeaponDamage(
|
||
components: PhysicalDamageComponents,
|
||
): PhysicalDamageRangeResult {
|
||
const wMin = Math.max(0, components.weaponBaseMin)
|
||
const wMax = Math.max(wMin, components.weaponBaseMax)
|
||
const onEd = Math.max(0, components.onWeaponEdPercent ?? 0)
|
||
const flat = Math.max(0, components.flatDamage ?? 0)
|
||
const offEd = Math.max(0, components.offWeaponEdPercent ?? 0)
|
||
const statBonus = Math.max(0, components.statBonusPercent ?? 0)
|
||
|
||
const baseMinWithWeaponEd = Math.floor(wMin * (1 + onEd / 100))
|
||
const baseMaxWithWeaponEd = Math.floor(wMax * (1 + onEd / 100))
|
||
|
||
const baseMinWithFlat = baseMinWithWeaponEd + flat
|
||
const baseMaxWithFlat = baseMaxWithWeaponEd + flat
|
||
|
||
const totalMultiplier = 1 + (offEd + statBonus) / 100
|
||
const finalMinDamage = Math.floor(baseMinWithFlat * totalMultiplier)
|
||
const finalMaxDamage = Math.floor(baseMaxWithFlat * totalMultiplier)
|
||
|
||
return {
|
||
weaponBaseMin: wMin,
|
||
weaponBaseMax: wMax,
|
||
onWeaponEdPercent: onEd,
|
||
baseMinWithWeaponEd,
|
||
baseMaxWithWeaponEd,
|
||
flatDamage: flat,
|
||
baseMinWithFlat,
|
||
baseMaxWithFlat,
|
||
offWeaponEdPercent: offEd,
|
||
statBonusPercent: statBonus,
|
||
totalMultiplier: Math.round(totalMultiplier * 1000) / 1000,
|
||
finalMinDamage,
|
||
finalMaxDamage,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 8h. Poison Bit Rate & Duration Averaging Stacking.
|
||
*
|
||
* In D2:
|
||
* - Poison rate is in 1/256th damage per frame.
|
||
* - Stacking across items:
|
||
* TotalBitRate = sum(BitRates)
|
||
* AvgDuration = sum(Durations) / N
|
||
* TotalDamage = floor((TotalBitRate * AvgDuration) / 256)
|
||
*/
|
||
export interface PoisonSource {
|
||
readonly damage: number
|
||
readonly durationSeconds?: number | undefined
|
||
readonly durationFrames?: number | undefined
|
||
}
|
||
|
||
export interface PoisonStackResult {
|
||
readonly totalBitRate: number
|
||
readonly averageDurationFrames: number
|
||
readonly averageDurationSeconds: number
|
||
readonly totalPoisonDamage: number
|
||
readonly damagePerSecond: number
|
||
readonly sourcesCount: number
|
||
}
|
||
|
||
export function calculatePoisonStack(sources: readonly PoisonSource[]): PoisonStackResult {
|
||
if (sources.length === 0) {
|
||
return {
|
||
totalBitRate: 0,
|
||
averageDurationFrames: 0,
|
||
averageDurationSeconds: 0,
|
||
totalPoisonDamage: 0,
|
||
damagePerSecond: 0,
|
||
sourcesCount: 0,
|
||
}
|
||
}
|
||
|
||
let sumBitRate = 0
|
||
let sumFrames = 0
|
||
let validCount = 0
|
||
|
||
for (const src of sources) {
|
||
const frames = src.durationFrames ?? ((src.durationSeconds ?? 0) * 25)
|
||
if (frames > 0 && src.damage > 0) {
|
||
const bitRate = (src.damage * 256) / frames
|
||
sumBitRate += bitRate
|
||
sumFrames += frames
|
||
validCount += 1
|
||
}
|
||
}
|
||
|
||
if (validCount === 0) {
|
||
return {
|
||
totalBitRate: 0,
|
||
averageDurationFrames: 0,
|
||
averageDurationSeconds: 0,
|
||
totalPoisonDamage: 0,
|
||
damagePerSecond: 0,
|
||
sourcesCount: 0,
|
||
}
|
||
}
|
||
|
||
const averageDurationFrames = Math.round(sumFrames / validCount)
|
||
const averageDurationSeconds = Math.round((averageDurationFrames / 25) * 10) / 10
|
||
const totalPoisonDamage = Math.floor((sumBitRate * averageDurationFrames) / 256)
|
||
const damagePerSecond = Math.round(((sumBitRate * 25) / 256) * 100) / 100
|
||
|
||
return {
|
||
totalBitRate: Math.round(sumBitRate),
|
||
averageDurationFrames,
|
||
averageDurationSeconds,
|
||
totalPoisonDamage,
|
||
damagePerSecond,
|
||
sourcesCount: validCount,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 9. Hit Recovery / Stun Check.
|
||
*
|
||
* In D2:
|
||
* When a hit inflicts damage > MaxHP / 16:
|
||
* - Damage >= MaxHP / 4: 100% chance to enter hit recovery.
|
||
* - Damage >= MaxHP / 8: 50% chance to enter hit recovery.
|
||
* - Damage >= MaxHP / 16: 25% chance to enter hit recovery.
|
||
* - Damage < MaxHP / 16: 0% chance.
|
||
*
|
||
* @param damageDealt - Net damage received.
|
||
* @param maxHp - Defender's maximum HP.
|
||
* @param roll0to1 - Random float in [0, 1) (defaults to Math.random()).
|
||
* @returns Whether hit recovery is triggered, and the trigger chance.
|
||
*/
|
||
export function checkHitRecovery(
|
||
damageDealt: number,
|
||
maxHp: number,
|
||
roll0to1 = Math.random(),
|
||
): { readonly triggered: boolean; readonly chancePercent: number } {
|
||
if (maxHp <= 0 || damageDealt <= 0) {
|
||
return { triggered: false, chancePercent: 0 }
|
||
}
|
||
const ratio = damageDealt / maxHp
|
||
let chancePercent = 0
|
||
if (ratio >= 0.25) {
|
||
chancePercent = 100
|
||
} else if (ratio >= 0.125) {
|
||
chancePercent = 50
|
||
} else if (ratio >= 0.0625) {
|
||
chancePercent = 25
|
||
}
|
||
|
||
const triggered = chancePercent > 0 && roll0to1 * 100 < chancePercent
|
||
return { triggered, chancePercent }
|
||
}
|
||
|
||
/**
|
||
* Elemental Damage specification for an attack.
|
||
*/
|
||
export interface AttackDamageSpec {
|
||
/** Min physical damage rolled from weapon/skill/strength. */
|
||
readonly physicalMin: number
|
||
/** Max physical damage. */
|
||
readonly physicalMax: number
|
||
/** Fire damage. */
|
||
readonly fire?: number
|
||
/** Lightning damage. */
|
||
readonly lightning?: number
|
||
/** Cold damage (also chills). */
|
||
readonly cold?: number
|
||
/** Cold chill duration in frames/seconds. */
|
||
readonly coldChillDuration?: number
|
||
/** Poison damage (dealt over duration). */
|
||
readonly poison?: number
|
||
/** Magic damage (e.g. Berserk, Bone Spear). */
|
||
readonly magic?: number
|
||
}
|
||
|
||
/**
|
||
* Target's defensive specification.
|
||
*/
|
||
export interface DefenderDefenseSpec {
|
||
/** Target Level. */
|
||
readonly level: number
|
||
/** Defense Rating (DR / AC). */
|
||
readonly defense: number
|
||
/** Block chance % [0, 75]. */
|
||
readonly blockPercent: number
|
||
/** Flat physical damage reduced (DR). */
|
||
readonly flatDamageReduction?: number | undefined
|
||
/** Flat magic damage reduced (MDR). */
|
||
readonly flatMagicReduction?: number | undefined
|
||
/** Physical resistance % (also known as %DR). */
|
||
readonly resPhysical?: number | undefined
|
||
/** Fire resistance %. */
|
||
readonly resFire?: number | undefined
|
||
/** Lightning resistance %. */
|
||
readonly resLightning?: number | undefined
|
||
/** Cold resistance %. */
|
||
readonly resCold?: number | undefined
|
||
/** Poison resistance %. */
|
||
readonly resPoison?: number | undefined
|
||
/** Magic resistance %. */
|
||
readonly resMagic?: number | undefined
|
||
/** Current HP (for crushing blow). */
|
||
readonly currentHp: number
|
||
/** Max HP (for hit recovery check). */
|
||
readonly maxHp: number
|
||
/** Target classification tier. */
|
||
readonly tier?: TargetTier | undefined
|
||
/** Monster physical size ('small', 'medium', 'large'). */
|
||
readonly size?: MonsterSize | undefined
|
||
/** Natural life regeneration rate from MonStats.txt. */
|
||
readonly regenRate?: number | undefined
|
||
/** Whether target is a Pandemonium Uber (immune to PMH). */
|
||
readonly isUber?: boolean | undefined
|
||
/** Whether the defender is a boss or champion (backwards-compatibility). */
|
||
readonly isBoss?: boolean | undefined
|
||
/** Whether defender is currently running (DR=0 and 1/3 block cap 25%). */
|
||
readonly isRunning?: boolean | undefined
|
||
/** Drain effectiveness % (0–100%, 0% for skeletons/hell bosses). */
|
||
readonly drainEffectiveness?: number | undefined
|
||
}
|
||
|
||
/**
|
||
* Additional combat calculation options.
|
||
*/
|
||
export interface CombatOptions {
|
||
readonly criticalStrikePercent?: number | undefined
|
||
readonly deadlyStrikePercent?: number | undefined
|
||
readonly crushingBlowPercent?: number | undefined
|
||
readonly openWoundsPercent?: number | undefined
|
||
readonly lifeLeechPercent?: number | undefined
|
||
readonly manaLeechPercent?: number | undefined
|
||
readonly ignoreTargetDefense?: boolean | undefined
|
||
readonly targetDefenseReductionPercent?: number | undefined
|
||
readonly freezeBonus?: number | undefined
|
||
readonly knockbackPercent?: number | undefined
|
||
readonly difficulty?: GameDifficulty | undefined
|
||
readonly isSpell?: boolean | undefined
|
||
readonly isRanged?: boolean | undefined
|
||
// PvE Depth Options (Issue #39)
|
||
readonly defenderSize?: MonsterSize | undefined
|
||
readonly convictionPenalty?: number | undefined
|
||
readonly lowerResPenalty?: number | undefined
|
||
readonly itemMinusPhysRes?: number | undefined
|
||
readonly itemMinusFireRes?: number | undefined
|
||
readonly itemMinusLightRes?: number | undefined
|
||
readonly itemMinusColdRes?: number | undefined
|
||
readonly itemMinusPoisonRes?: number | undefined
|
||
readonly slowPercent?: number | undefined
|
||
readonly hitBlindsTargetBonus?: number | undefined
|
||
readonly hitCausesFleePercent?: number | undefined
|
||
readonly preventMonsterHeal?: boolean | undefined
|
||
readonly attackerType?: 'player' | 'mercenary' | 'minion' | undefined
|
||
}
|
||
|
||
/**
|
||
* Full breakdown of an attack calculation for logging and inspection.
|
||
*/
|
||
export interface CombatCalculationResult {
|
||
readonly attackerAr: number
|
||
readonly defenderDr: number
|
||
readonly hitChancePercent: number
|
||
readonly hitRoll: number
|
||
readonly isHit: boolean
|
||
readonly isBlocked: boolean
|
||
readonly defenderBlockPercent: number
|
||
readonly isCritical: boolean
|
||
readonly criticalTrigger: 'none' | 'critical_strike' | 'deadly_strike'
|
||
readonly isCrushingBlow: boolean
|
||
readonly crushingBlowDamage: number
|
||
readonly isOpenWounds: boolean
|
||
readonly openWoundsResult?: OpenWoundsDamageResult | undefined
|
||
readonly lifeLeeched: number
|
||
readonly manaLeeched: number
|
||
readonly freezeResult?: FreezeTargetResult | undefined
|
||
readonly knockbackTriggered: boolean
|
||
readonly knockbackResult?: KnockbackEvaluationResult | undefined
|
||
readonly slowResult?: SlowTargetResult | undefined
|
||
readonly blindResult?: HitBlindsTargetResult | undefined
|
||
readonly fleeResult?: HitCausesFleeResult | undefined
|
||
readonly pmhResult?: PreventMonsterHealEvaluation | undefined
|
||
readonly monsterRegenResult?: MonsterRegenResult | undefined
|
||
readonly resistanceBreakResults?: Record<string, ResistanceReductionResult> | undefined
|
||
readonly rawPhysicalDamage: number
|
||
readonly finalPhysicalDamage: number
|
||
readonly finalFireDamage: number
|
||
readonly finalLightningDamage: number
|
||
readonly finalColdDamage: number
|
||
readonly finalPoisonDamage: number
|
||
readonly finalMagicDamage: number
|
||
readonly totalDamage: number
|
||
readonly immunities: readonly string[]
|
||
readonly hitRecoveryTriggered: boolean
|
||
readonly hitRecoveryChance: number
|
||
readonly log: readonly string[]
|
||
}
|
||
|
||
/**
|
||
* Execute a complete Diablo II attack calculation with full mathematical provenance.
|
||
*
|
||
* @param attackerLevel - Attacker level.
|
||
* @param attackerAr - Attacker Attack Rating (0 to bypass AR check, e.g. for spells).
|
||
* @param damageSpec - Attack damage components.
|
||
* @param defender - Defender attributes and defenses.
|
||
* @param options - Additional proc chances, modifiers, and difficulty.
|
||
* @param randomFn - Random generator function returning [0, 1).
|
||
* @returns Detailed combat result.
|
||
*/
|
||
export function calculateAttack(
|
||
attackerLevel: number,
|
||
attackerAr: number,
|
||
damageSpec: AttackDamageSpec,
|
||
defender: DefenderDefenseSpec,
|
||
options: CombatOptions = {},
|
||
randomFn: () => number = Math.random,
|
||
): CombatCalculationResult {
|
||
const log: string[] = []
|
||
const immunities: string[] = []
|
||
const resistanceBreakResults: Record<string, ResistanceReductionResult> = {}
|
||
|
||
const isBossOrChampion = defender.isBoss ?? (defender.tier === 'boss')
|
||
const targetTier: TargetTier = defender.tier ?? (defender.isBoss ? 'boss' : 'normal')
|
||
const isRunning = defender.isRunning ?? false
|
||
const isSpell = options.isSpell ?? false
|
||
const isRanged = options.isRanged ?? false
|
||
const difficulty = options.difficulty ?? 'normal'
|
||
|
||
// 1. To-Hit Check
|
||
let isHit = true
|
||
let hitChancePercent = 100
|
||
const hitRoll = Math.round(randomFn() * 10000) / 100
|
||
|
||
if (!isSpell) {
|
||
hitChancePercent = calculateHitChance(
|
||
attackerAr,
|
||
defender.defense,
|
||
attackerLevel,
|
||
defender.level,
|
||
{
|
||
ignoreTargetDefense: options.ignoreTargetDefense,
|
||
targetDefenseReductionPercent: options.targetDefenseReductionPercent,
|
||
isTargetRunning: isRunning,
|
||
isBossOrChampion,
|
||
},
|
||
)
|
||
isHit = hitRoll < hitChancePercent
|
||
|
||
const itdNote = options.ignoreTargetDefense
|
||
? isBossOrChampion
|
||
? ' [ITD 对暗金/Boss无效]'
|
||
: ' [ITD 生效: 目标防御降为0]'
|
||
: ''
|
||
const defRedNote = (options.targetDefenseReductionPercent ?? 0) > 0
|
||
? isBossOrChampion
|
||
? ` [-%Def 衰减折半: -${(options.targetDefenseReductionPercent! / 2).toFixed(1)}%]`
|
||
: ` [-%Def 全额生效: -${options.targetDefenseReductionPercent}%]`
|
||
: ''
|
||
const runNote = isRunning ? ' [目标奔跑: 防御视为0]' : ''
|
||
|
||
log.push(
|
||
`[1. 命中率判定 (AR vs DR)]: 攻击者 AR=${attackerAr} (Lv${attackerLevel}) 对抗 防御者 DR=${defender.defense} (Lv${defender.level})` +
|
||
`${itdNote}${defRedNote}${runNote} => 最终命中率: ${hitChancePercent.toFixed(1)}% (范围 5%–95%)。掷骰: ${hitRoll.toFixed(1)}% => ${isHit ? '✓ 命中' : '✗ 未命中 (MISS)'}`,
|
||
)
|
||
} else {
|
||
log.push(`[1. 法术技能检查]: 法术攻击无视护甲与命中率 (100% 必定命中)`)
|
||
}
|
||
|
||
if (!isHit) {
|
||
return {
|
||
attackerAr,
|
||
defenderDr: defender.defense,
|
||
hitChancePercent,
|
||
hitRoll,
|
||
isHit: false,
|
||
isBlocked: false,
|
||
defenderBlockPercent: defender.blockPercent,
|
||
isCritical: false,
|
||
criticalTrigger: 'none',
|
||
isCrushingBlow: false,
|
||
crushingBlowDamage: 0,
|
||
isOpenWounds: false,
|
||
lifeLeeched: 0,
|
||
manaLeeched: 0,
|
||
knockbackTriggered: false,
|
||
rawPhysicalDamage: 0,
|
||
finalPhysicalDamage: 0,
|
||
finalFireDamage: 0,
|
||
finalLightningDamage: 0,
|
||
finalColdDamage: 0,
|
||
finalPoisonDamage: 0,
|
||
finalMagicDamage: 0,
|
||
totalDamage: 0,
|
||
immunities: [],
|
||
hitRecoveryTriggered: false,
|
||
hitRecoveryChance: 0,
|
||
log,
|
||
}
|
||
}
|
||
|
||
// 2. Shield Blocking Check
|
||
let isBlocked = false
|
||
let defenderBlock = defender.blockPercent
|
||
if (isRunning) {
|
||
defenderBlock = Math.max(0, Math.min(25, Math.floor(defenderBlock / 3)))
|
||
}
|
||
|
||
if (!isSpell && defenderBlock > 0) {
|
||
const blockRoll = Math.round(randomFn() * 10000) / 100
|
||
isBlocked = blockRoll < defenderBlock
|
||
log.push(
|
||
`[2. 格挡判定]: 防御者有效格挡率: ${defenderBlock}%${isRunning ? ' (奔跑削减至1/3且上限25%)' : ''}，掷骰: ${blockRoll.toFixed(1)}% => ${isBlocked ? '🛡️ 格挡成功 (伤害完全抵消 0)' : '格挡失败'}`,
|
||
)
|
||
}
|
||
|
||
if (isBlocked) {
|
||
return {
|
||
attackerAr,
|
||
defenderDr: defender.defense,
|
||
hitChancePercent,
|
||
hitRoll,
|
||
isHit: true,
|
||
isBlocked: true,
|
||
defenderBlockPercent: defenderBlock,
|
||
isCritical: false,
|
||
criticalTrigger: 'none',
|
||
isCrushingBlow: false,
|
||
crushingBlowDamage: 0,
|
||
isOpenWounds: false,
|
||
lifeLeeched: 0,
|
||
manaLeeched: 0,
|
||
knockbackTriggered: false,
|
||
rawPhysicalDamage: 0,
|
||
finalPhysicalDamage: 0,
|
||
finalFireDamage: 0,
|
||
finalLightningDamage: 0,
|
||
finalColdDamage: 0,
|
||
finalPoisonDamage: 0,
|
||
finalMagicDamage: 0,
|
||
totalDamage: 0,
|
||
immunities: [],
|
||
hitRecoveryTriggered: false,
|
||
hitRecoveryChance: 0,
|
||
log,
|
||
}
|
||
}
|
||
|
||
// 3. Critical Strike (CS) & Deadly Strike (DS) Check
|
||
const critResult = evaluateCriticalAndDeadlyStrike(
|
||
options.criticalStrikePercent ?? 0,
|
||
options.deadlyStrikePercent ?? 0,
|
||
randomFn,
|
||
)
|
||
if (!isSpell && (options.criticalStrikePercent || options.deadlyStrikePercent)) {
|
||
if (critResult.triggeredBy === 'critical_strike') {
|
||
log.push(
|
||
`[3. 暴击判定 (CS/DS)]: 技能致命一击 (CS ${options.criticalStrikePercent}%) 命中掷骰 ${critResult.csRoll.toFixed(1)}% => ⚡ 触发致命一击 (物理伤害 x2)`,
|
||
)
|
||
} else if (critResult.triggeredBy === 'deadly_strike') {
|
||
log.push(
|
||
`[3. 暴击判定 (CS/DS)]: CS 未触发 (掷骰 ${critResult.csRoll.toFixed(1)}%) -> 装备双倍打击 (DS ${options.deadlyStrikePercent}%) 命中掷骰 ${critResult.dsRoll.toFixed(1)}% => ⚡ 触发双倍打击 (物理伤害 x2)`,
|
||
)
|
||
} else {
|
||
log.push(
|
||
`[3. 暴击判定 (CS/DS)]: 综合双倍几率 ${critResult.combinedChancePercent.toFixed(1)}%，掷骰未触发双倍打击`,
|
||
)
|
||
}
|
||
}
|
||
|
||
// 4. Crushing Blow (CB) Check
|
||
const cbChance = options.crushingBlowPercent ?? 0
|
||
const cbRoll = Math.round(randomFn() * 10000) / 100
|
||
const isCrushingBlow = !isSpell && cbChance > 0 && cbRoll < cbChance
|
||
let crushingBlowDamage = 0
|
||
if (isCrushingBlow) {
|
||
const physRes = defender.resPhysical ?? 0
|
||
crushingBlowDamage = calculateCrushingBlowDamage(
|
||
defender.currentHp,
|
||
targetTier,
|
||
isRanged,
|
||
physRes,
|
||
)
|
||
const resNote = physRes >= 100
|
||
? ' [目标物理免疫: CB 伤害为 0]'
|
||
: physRes > 0
|
||
? ` [受物抗 ${physRes}% 削减]`
|
||
: physRes < 0
|
||
? ` [负物抗不增伤, 封顶100%]`
|
||
: ''
|
||
log.push(
|
||
`[4. 压碎性打击 (CB)]: 几率 ${cbChance}% 命中 (掷骰 ${cbRoll.toFixed(1)}%)！当前生命 ${defender.currentHp} 削减 ${crushingBlowDamage} HP${resNote}`,
|
||
)
|
||
}
|
||
|
||
// 5. Open Wounds (OW) Check
|
||
const owChance = options.openWoundsPercent ?? 0
|
||
const owRoll = Math.round(randomFn() * 10000) / 100
|
||
const isOpenWounds = !isSpell && owChance > 0 && owRoll < owChance
|
||
let openWoundsResult: OpenWoundsDamageResult | undefined
|
||
if (isOpenWounds) {
|
||
openWoundsResult = calculateOpenWoundsDamage(attackerLevel, targetTier, isRanged)
|
||
log.push(
|
||
`[5. 撕开伤口 (OW)]: 几率 ${owChance}% 命中 (掷骰 ${owRoll.toFixed(1)}%)！持续流血 200 帧 (8秒)，` +
|
||
`每秒流失 ${openWoundsResult.damagePerSecond} HP (总计 ${openWoundsResult.totalDamage200Frames} HP)，并禁止目标自愈！`,
|
||
)
|
||
}
|
||
|
||
// 6. Roll Raw Physical Damage
|
||
const pMin = damageSpec.physicalMin
|
||
const pMax = Math.max(pMin, damageSpec.physicalMax)
|
||
let rawPhysical = pMin + Math.round(randomFn() * (pMax - pMin))
|
||
if (critResult.isCritical) {
|
||
rawPhysical *= 2
|
||
}
|
||
// Note: CB damage is physical, added directly after critical doubling
|
||
rawPhysical += crushingBlowDamage
|
||
|
||
// 7. Apply Resistances & Reductions
|
||
// 7a. Physical: Flat DR -> %DR (Resistance with -% Enemy Phys Res)
|
||
const physBreak = calculateResistanceReduction(
|
||
defender.resPhysical ?? 0,
|
||
0,
|
||
0,
|
||
options.itemMinusPhysRes ?? 0,
|
||
)
|
||
resistanceBreakResults.physical = physBreak
|
||
if (physBreak.isImmune) immunities.push('Physical')
|
||
const flatDr = defender.flatDamageReduction ?? 0
|
||
let finalPhysicalDamage = Math.max(0, (rawPhysical - flatDr) * physBreak.damageMultiplier)
|
||
finalPhysicalDamage = Math.round(finalPhysicalDamage * 10) / 10
|
||
log.push(
|
||
`[6. 物理伤害结算]: 原始物理 ${rawPhysical} (基准 [${pMin}..${pMax}]${critResult.isCritical ? ' 暴击x2' : ''}${isCrushingBlow ? ' +CB' : ''}) ` +
|
||
`- 减伤(DR) ${flatDr} -> 物抗 ${physBreak.finalRes}% (因子 x${physBreak.damageMultiplier.toFixed(2)}${physBreak.isImmune ? ' 物理免疫' : ''}) => 最终物理伤害: ${finalPhysicalDamage}`,
|
||
)
|
||
|
||
// 7b. Fire (with Conviction & Lower Resist 1/5th rule + Equipment -% Fire Res)
|
||
const flatMdr = defender.flatMagicReduction ?? 0
|
||
let finalFire = 0
|
||
if ((damageSpec.fire ?? 0) > 0) {
|
||
const fireBreak = calculateResistanceReduction(
|
||
defender.resFire ?? 0,
|
||
options.convictionPenalty ?? 0,
|
||
options.lowerResPenalty ?? 0,
|
||
options.itemMinusFireRes ?? 0,
|
||
)
|
||
resistanceBreakResults.fire = fireBreak
|
||
if (fireBreak.isImmune) immunities.push('Fire')
|
||
finalFire = Math.max(0, Math.round((Math.max(0, damageSpec.fire! - flatMdr) * fireBreak.damageMultiplier) * 10) / 10)
|
||
|
||
const breakNote = fireBreak.immunityBroken
|
||
? ` [⚡ 1/5法则破免成功! 原${fireBreak.initialRes}% -> 降为${fireBreak.finalRes}%]`
|
||
: fireBreak.wasImmune && fireBreak.isImmune
|
||
? ` [🛡️ 减抗未能破免! 原${fireBreak.initialRes}% -> ${fireBreak.finalRes}%仍>=100%]`
|
||
: ` -> 火抗 ${fireBreak.finalRes}%`
|
||
|
||
log.push(
|
||
`[7. 火焰伤害]: 基础火伤 ${damageSpec.fire} - MDR ${flatMdr}${breakNote} (因子 x${fireBreak.damageMultiplier.toFixed(2)}${fireBreak.isImmune ? ' 免疫' : ''}) => 净火伤: ${finalFire}`,
|
||
)
|
||
}
|
||
|
||
// 7c. Lightning (with Conviction & Lower Resist 1/5th rule + Equipment -% Light Res)
|
||
let finalLightning = 0
|
||
if ((damageSpec.lightning ?? 0) > 0) {
|
||
const lightBreak = calculateResistanceReduction(
|
||
defender.resLightning ?? 0,
|
||
options.convictionPenalty ?? 0,
|
||
options.lowerResPenalty ?? 0,
|
||
options.itemMinusLightRes ?? 0,
|
||
)
|
||
resistanceBreakResults.lightning = lightBreak
|
||
if (lightBreak.isImmune) immunities.push('Lightning')
|
||
finalLightning = Math.max(0, Math.round((Math.max(0, damageSpec.lightning! - flatMdr) * lightBreak.damageMultiplier) * 10) / 10)
|
||
|
||
const breakNote = lightBreak.immunityBroken
|
||
? ` [⚡ 1/5法则破免成功! 原${lightBreak.initialRes}% -> 降为${lightBreak.finalRes}%]`
|
||
: lightBreak.wasImmune && lightBreak.isImmune
|
||
? ` [🛡️ 减抗未能破免! 原${lightBreak.initialRes}% -> ${lightBreak.finalRes}%仍>=100%]`
|
||
: ` -> 电抗 ${lightBreak.finalRes}%`
|
||
|
||
log.push(
|
||
`[8. 闪电伤害]: 基础电伤 ${damageSpec.lightning} - MDR ${flatMdr}${breakNote} (因子 x${lightBreak.damageMultiplier.toFixed(2)}${lightBreak.isImmune ? ' 免疫' : ''}) => 净电伤: ${finalLightning}`,
|
||
)
|
||
}
|
||
|
||
// 7d. Cold (with Conviction & Lower Resist 1/5th rule + Equipment -% Cold Res)
|
||
let finalCold = 0
|
||
if ((damageSpec.cold ?? 0) > 0) {
|
||
const coldBreak = calculateResistanceReduction(
|
||
defender.resCold ?? 0,
|
||
options.convictionPenalty ?? 0,
|
||
options.lowerResPenalty ?? 0,
|
||
options.itemMinusColdRes ?? 0,
|
||
)
|
||
resistanceBreakResults.cold = coldBreak
|
||
if (coldBreak.isImmune) immunities.push('Cold')
|
||
finalCold = Math.max(0, Math.round((Math.max(0, damageSpec.cold! - flatMdr) * coldBreak.damageMultiplier) * 10) / 10)
|
||
|
||
const breakNote = coldBreak.immunityBroken
|
||
? ` [⚡ 1/5法则破免成功! 原${coldBreak.initialRes}% -> 降为${coldBreak.finalRes}%]`
|
||
: coldBreak.wasImmune && coldBreak.isImmune
|
||
? ` [🛡️ 减抗未能破免! 原${coldBreak.initialRes}% -> ${coldBreak.finalRes}%仍>=100%]`
|
||
: ` -> 冰抗 ${coldBreak.finalRes}%`
|
||
|
||
log.push(
|
||
`[9. 冰冷伤害]: 基础冰伤 ${damageSpec.cold} - MDR ${flatMdr}${breakNote} (因子 x${coldBreak.damageMultiplier.toFixed(2)}${coldBreak.isImmune ? ' 免疫' : ''}) => 净冰伤: ${finalCold}`,
|
||
)
|
||
}
|
||
|
||
// 7e. Poison (Conviction does NOT affect poison; Lower Resist DOES affect poison)
|
||
let finalPoison = 0
|
||
if ((damageSpec.poison ?? 0) > 0) {
|
||
const poisonBreak = calculateResistanceReduction(
|
||
defender.resPoison ?? 0,
|
||
0, // Conviction has no effect on Poison
|
||
options.lowerResPenalty ?? 0,
|
||
options.itemMinusPoisonRes ?? 0,
|
||
)
|
||
resistanceBreakResults.poison = poisonBreak
|
||
if (poisonBreak.isImmune) immunities.push('Poison')
|
||
finalPoison = Math.max(0, Math.round((damageSpec.poison! * poisonBreak.damageMultiplier) * 10) / 10)
|
||
|
||
const breakNote = poisonBreak.immunityBroken
|
||
? ` [⚡ 诅咒破毒免成功! 原${poisonBreak.initialRes}% -> 降为${poisonBreak.finalRes}%]`
|
||
: poisonBreak.wasImmune && poisonBreak.isImmune
|
||
? ` [🛡️ 减抗未能破毒免! 原${poisonBreak.initialRes}% -> ${poisonBreak.finalRes}%仍>=100%]`
|
||
: ` -> 毒抗 ${poisonBreak.finalRes}%`
|
||
|
||
log.push(
|
||
`[10. 毒素伤害]: 基础毒伤 ${damageSpec.poison}${breakNote} (因子 x${poisonBreak.damageMultiplier.toFixed(2)}${poisonBreak.isImmune ? ' 免疫' : ''}) => 净毒伤: ${finalPoison}`,
|
||
)
|
||
}
|
||
|
||
// 7f. Magic
|
||
let finalMagic = 0
|
||
if ((damageSpec.magic ?? 0) > 0) {
|
||
const magicRes = defender.resMagic ?? 0
|
||
const factor = calculateResistanceFactor(magicRes)
|
||
if (factor.isImmune) immunities.push('Magic')
|
||
finalMagic = Math.max(0, Math.round((Math.max(0, damageSpec.magic! - flatMdr) * factor.factor) * 10) / 10)
|
||
log.push(
|
||
`[11. 纯魔法伤害]: 基础魔伤 ${damageSpec.magic} - MDR ${flatMdr} -> 魔抗 ${magicRes}% (因子 x${factor.factor.toFixed(2)}${factor.isImmune ? ' 免疫' : ''}) => 净魔伤: ${finalMagic}`,
|
||
)
|
||
}
|
||
|
||
// 8. Life & Mana Leech
|
||
const leechResult = calculateLeech(
|
||
finalPhysicalDamage,
|
||
options.lifeLeechPercent ?? 0,
|
||
options.manaLeechPercent ?? 0,
|
||
defender.drainEffectiveness ?? 100,
|
||
difficulty,
|
||
)
|
||
if (!isSpell && ((options.lifeLeechPercent ?? 0) > 0 || (options.manaLeechPercent ?? 0) > 0)) {
|
||
const drainEff = defender.drainEffectiveness ?? 100
|
||
log.push(
|
||
`[12. 偷取生命/法力]: 汲取效率 ${drainEff}%, 难度惩罚 x${leechResult.difficultyPenaltyFactor.toFixed(2)} ` +
|
||
`=> 实际偷取生命 +${leechResult.lifeLeeched} HP, 偷取法力 +${leechResult.manaLeeched} MP`,
|
||
)
|
||
}
|
||
|
||
// 9. Freezes Target & Knockback (Size-based & Boss Immunity)
|
||
let freezeResult: FreezeTargetResult | undefined
|
||
if (!isSpell && (options.freezeBonus ?? 0) > 0) {
|
||
freezeResult = calculateFreezeTarget(
|
||
options.freezeBonus!,
|
||
attackerLevel,
|
||
defender.level,
|
||
targetTier,
|
||
isRanged,
|
||
difficulty,
|
||
randomFn,
|
||
)
|
||
if (freezeResult.willFreeze) {
|
||
log.push(
|
||
`[13. 冻结目标 (Freezes Target)]: 冻结几率 ${freezeResult.chancePercent}% (掷骰 ${freezeResult.roll.toFixed(1)}%) => ❄️ 目标被冰冻 ${freezeResult.durationSeconds} 秒 (${freezeResult.durationFrames} 帧)!`,
|
||
)
|
||
} else if (freezeResult.isChilledOnly) {
|
||
log.push(
|
||
`[13. 冻结目标 (Freezes Target)]: 目标为 Boss/精英，免疫完全冰冻，降级为减速减速 (Chill) ${freezeResult.durationSeconds} 秒!`,
|
||
)
|
||
}
|
||
}
|
||
|
||
const kbChance = options.knockbackPercent ?? 0
|
||
const defenderSize = defender.size ?? options.defenderSize ?? 'medium'
|
||
const kbResult = calculateKnockbackSuccess(
|
||
kbChance > 0,
|
||
defenderSize,
|
||
isBossOrChampion,
|
||
isRanged,
|
||
randomFn,
|
||
)
|
||
const knockbackTriggered = !isSpell && kbResult.triggered
|
||
if (kbChance > 0) {
|
||
log.push(`[14. 击退判定 (Knockback)]: ${kbResult.reason}`)
|
||
}
|
||
|
||
// 10. Crowd Control: Slow Target, Blinds, Causes Flee
|
||
let slowResult: SlowTargetResult | undefined
|
||
if ((options.slowPercent ?? 0) > 0) {
|
||
slowResult = calculateSlowTarget(options.slowPercent!, isBossOrChampion)
|
||
log.push(`[15. 减速目标 (Slow)]: ${slowResult.reason}`)
|
||
}
|
||
|
||
let blindResult: HitBlindsTargetResult | undefined
|
||
if (!isSpell && (options.hitBlindsTargetBonus ?? 0) > 0) {
|
||
blindResult = calculateHitBlindsTarget(
|
||
options.hitBlindsTargetBonus!,
|
||
attackerLevel,
|
||
defender.level,
|
||
isBossOrChampion,
|
||
isRanged,
|
||
randomFn,
|
||
)
|
||
log.push(`[16. 使目标盲目 (HBT)]: ${blindResult.reason}`)
|
||
}
|
||
|
||
let fleeResult: HitCausesFleeResult | undefined
|
||
if (!isSpell && (options.hitCausesFleePercent ?? 0) > 0) {
|
||
fleeResult = calculateHitCausesFlee(
|
||
options.hitCausesFleePercent!,
|
||
isBossOrChampion,
|
||
randomFn,
|
||
)
|
||
log.push(`[17. 恐吓逃跑 (HCMTF)]: ${fleeResult.reason}`)
|
||
}
|
||
|
||
// 11. Prevent Monster Heal (PMH) & Monster Regeneration Evaluation
|
||
let pmhResult: PreventMonsterHealEvaluation | undefined
|
||
if (!isSpell && options.preventMonsterHeal) {
|
||
const targetKind = defender.isUber ? 'uber' : (isBossOrChampion ? 'boss' : 'normal')
|
||
pmhResult = evaluatePreventMonsterHeal(options.attackerType ?? 'player', targetKind)
|
||
log.push(`[18. 阻止怪物自愈 (PMH)]: ${pmhResult.reason}`)
|
||
}
|
||
|
||
const monsterRegenResult = calculateMonsterRegeneration(
|
||
defender.maxHp,
|
||
defender.regenRate ?? 0,
|
||
isOpenWounds,
|
||
pmhResult?.applied ?? false,
|
||
)
|
||
|
||
const totalDamage = Math.round((finalPhysicalDamage + finalFire + finalLightning + finalCold + finalPoison + finalMagic) * 10) / 10
|
||
log.push(
|
||
`[19. 最终伤害汇总]: 单次打击扣减 = ${totalDamage} HP (目标剩余生命: ${Math.max(0, Math.round((defender.currentHp - totalDamage) * 10) / 10)} / ${defender.maxHp})`,
|
||
)
|
||
|
||
// 12. Hit Recovery (Stun) Check
|
||
const recovery = checkHitRecovery(totalDamage, defender.maxHp, randomFn())
|
||
if (recovery.triggered) {
|
||
log.push(`[20. 受击硬直 (Hit Recovery)]: 单次伤害达到触发阈值 (几率 ${recovery.chancePercent}%) => 💥 触发硬直后仰！`)
|
||
} else if (recovery.chancePercent > 0) {
|
||
log.push(`[20. 受击硬直 (Hit Recovery)]: 伤害达到阈值 (几率 ${recovery.chancePercent}%)，掷骰通过，未陷入硬直`)
|
||
}
|
||
|
||
return {
|
||
attackerAr,
|
||
defenderDr: defender.defense,
|
||
hitChancePercent,
|
||
hitRoll,
|
||
isHit: true,
|
||
isBlocked: false,
|
||
defenderBlockPercent: defenderBlock,
|
||
isCritical: critResult.isCritical,
|
||
criticalTrigger: critResult.triggeredBy,
|
||
isCrushingBlow,
|
||
crushingBlowDamage,
|
||
isOpenWounds,
|
||
openWoundsResult,
|
||
lifeLeeched: leechResult.lifeLeeched,
|
||
manaLeeched: leechResult.manaLeeched,
|
||
freezeResult,
|
||
knockbackTriggered,
|
||
knockbackResult: kbResult,
|
||
slowResult,
|
||
blindResult,
|
||
fleeResult,
|
||
pmhResult,
|
||
monsterRegenResult,
|
||
resistanceBreakResults,
|
||
rawPhysicalDamage: rawPhysical,
|
||
finalPhysicalDamage,
|
||
finalFireDamage: finalFire,
|
||
finalLightningDamage: finalLightning,
|
||
finalColdDamage: finalCold,
|
||
finalPoisonDamage: finalPoison,
|
||
finalMagicDamage: finalMagic,
|
||
totalDamage,
|
||
immunities,
|
||
hitRecoveryTriggered: recovery.triggered,
|
||
hitRecoveryChance: recovery.chancePercent,
|
||
log,
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Canonical Diablo II 1.13c Experience Progression Table (Levels 1 to 99).
|
||
*
|
||
* Index corresponds to character level (Index 1 = Level 1).
|
||
*/
|
||
export const D2_EXPERIENCE_TABLE_99: readonly number[] = [
|
||
0, // Index 0 (unused)
|
||
0, // Level 1
|
||
500, // Level 2
|
||
1500, // Level 3
|
||
3750, // Level 4
|
||
7875, // Level 5
|
||
14175, // Level 6
|
||
22680, // Level 7
|
||
32886, // Level 8
|
||
44396, // Level 9
|
||
57715, // Level 10
|
||
72144, // Level 11
|
||
90180, // Level 12
|
||
112725, // Level 13
|
||
140906, // Level 14
|
||
176132, // Level 15
|
||
220165, // Level 16
|
||
275206, // Level 17
|
||
344008, // Level 18
|
||
430010, // Level 19
|
||
537512, // Level 20
|
||
671890, // Level 21
|
||
839862, // Level 22
|
||
1049828, // Level 23
|
||
1312285, // Level 24
|
||
1640356, // Level 25
|
||
2050445, // Level 26
|
||
2563056, // Level 27
|
||
3203820, // Level 28
|
||
3902664, // Level 29
|
||
4663904, // Level 30
|
||
5493655, // Level 31
|
||
6398084, // Level 32
|
||
7383912, // Level 33
|
||
8458464, // Level 34
|
||
9629726, // Level 35
|
||
10906401, // Level 36
|
||
12297977, // Level 37
|
||
13814795, // Level 38
|
||
15468127, // Level 39
|
||
17270258, // Level 40
|
||
19234581, // Level 41
|
||
21375693, // Level 42
|
||
23709505, // Level 43
|
||
26253360, // Level 44
|
||
29026162, // Level 45
|
||
32048517, // Level 46
|
||
35342884, // Level 47
|
||
38933744, // Level 48
|
||
42847781, // Level 49
|
||
47114081, // Level 50
|
||
51764348, // Level 51
|
||
56833139, // Level 52
|
||
62358122, // Level 53
|
||
68380353, // Level 54
|
||
74944585, // Level 55
|
||
82099598, // Level 56
|
||
89898562, // Level 57
|
||
98399433, // Level 58
|
||
107665382, // Level 59
|
||
117765266, // Level 60
|
||
128774140, // Level 61
|
||
140773813, // Level 62
|
||
153853456, // Level 63
|
||
168110267, // Level 64
|
||
183650191, // Level 65
|
||
200588708, // Level 66
|
||
219051692, // Level 67
|
||
239176344, // Level 68
|
||
261112215, // Level 69
|
||
285022314, // Level 70
|
||
311084322, // Level 71
|
||
339511911, // Level 72
|
||
370507983, // Level 73
|
||
404293701, // Level 74
|
||
441110134, // Level 75
|
||
481240046, // Level 76
|
||
524981650, // Level 77
|
||
572660000, // Level 78
|
||
624629400, // Level 79
|
||
681276046, // Level 80
|
||
743020890, // Level 81
|
||
810322770, // Level 82
|
||
883681819, // Level 83
|
||
963643183, // Level 84
|
||
1050801070, // Level 85
|
||
1145803166, // Level 86
|
||
1249355451, // Level 87
|
||
1362227442, // Level 88
|
||
1485257912, // Level 89
|
||
1619361124, // Level 90
|
||
1765533625, // Level 91
|
||
1924861651, // Level 92
|
||
2098529199, // Level 93
|
||
2287826827, // Level 94
|
||
2494161241, // Level 95
|
||
2719065753, // Level 96
|
||
2964211671, // Level 97
|
||
3231420721, // Level 98
|
||
3522678586, // Level 99
|
||
]
|