Initial commit

src/logic/damage.ts

@@ -0,0 +1,131 @@
+/**
+ * Damage application engine — flows through 4 layers:
+ * 1. Magical Armor (DR + every 5 dmg absorbed degrades value by 1 via runicCounter)
+ * 2. Magical Shield (raw temp HP; cannot be healed; vanishes at 0)
+ * 3. Physical Armor (flat DR; optionally degrade `condition` by 1)
+ * 4. Health (the leftover hits HP)
+ *
+ * Bypass flags allow effects to skip individual layers.
+ *
+ * After resolving, if HP loss meets the Oszołomiony threshold ⌈(C+U+D)/3⌉
+ * the effect is auto-applied to character actors.
+ */
+
+import { DamageType } from '../constants';
+
+export interface ApplyDamageOptions {
+  amount: number;
+  type?: DamageType;
+  ignoreMagicalArmor?: boolean;
+  ignoreMagicalShield?: boolean;
+  ignorePhysicalArmor?: boolean;
+  damageArmor?: boolean;
+  postChat?: boolean;
+}
+
+export interface DamageReport {
+  amount: number;
+  absorbed: { magicalArmor: number; magicalShield: number; physicalArmor: number };
+  hpDamage: number;
+  shieldDropped: boolean;
+  oszolomionyApplied: boolean;
+}
+
+interface ActorLike {
+  name: string;
+  type: string;
+  system: any;
+  update: (changes: Record<string, unknown>) => Promise<unknown>;
+  toggleStatusEffect?: (id: string, options?: any) => Promise<any> | any;
+  effects?: { find: (fn: (e: any) => boolean) => any };
+}
+
+export async function applyDamage(actor: ActorLike, opts: ApplyDamageOptions): Promise<DamageReport> {
+  const total = Math.max(0, Math.floor(opts.amount));
+  const a = actor.system.attributes;
+  const updates: Record<string, unknown> = {};
+  const report: DamageReport = {
+    amount: total,
+    absorbed: { magicalArmor: 0, magicalShield: 0, physicalArmor: 0 },
+    hpDamage: 0,
+    shieldDropped: false,
+    oszolomionyApplied: false,
+  };
+
+  let remaining = total;
+
+  // Layer 1: Magical Armor — DR-based; runicCounter accumulates incoming damage.
+  if (!opts.ignoreMagicalArmor && a.magicalArmor) {
+    const dr = Math.max(0, Number(a.magicalArmor.value) || 0);
+    const absorbed = Math.min(dr, remaining);
+    if (absorbed > 0) {
+      const incomingDmg = remaining;
+      report.absorbed.magicalArmor = absorbed;
+      remaining -= absorbed;
+      const newCounter = (Number(a.magicalArmor.runicCounter) || 0) + incomingDmg;
+      const decrements = Math.floor(newCounter / 5);
+      const newValue = Math.max(0, dr - decrements);
+      updates['system.attributes.magicalArmor.runicCounter'] = newCounter % 5;
+      updates['system.attributes.magicalArmor.value'] = newValue;
+    }
+  }
+
+  // Layer 2: Magical Shield — pure temp HP (raw subtraction).
+  if (remaining > 0 && !opts.ignoreMagicalShield && a.magicalShield) {
+    const shield = Math.max(0, Number(a.magicalShield.value) || 0);
+    const taken = Math.min(shield, remaining);
+    if (taken > 0) {
+      report.absorbed.magicalShield = taken;
+      remaining -= taken;
+      const newShield = shield - taken;
+      updates['system.attributes.magicalShield.value'] = newShield;
+      if (newShield === 0) report.shieldDropped = true;
+    }
+  }
+
+  // Layer 3: Physical Armor — flat DR; optionally degrade condition.
+  if (remaining > 0 && !opts.ignorePhysicalArmor && a.physicalArmor) {
+    const dr = Math.max(0, Number(a.physicalArmor.value) || 0);
+    const absorbed = Math.min(dr, remaining);
+    if (absorbed > 0) {
+      report.absorbed.physicalArmor = absorbed;
+      remaining -= absorbed;
+    }
+    if (opts.damageArmor && actor.type === 'character' && a.physicalArmor.condition != null) {
+      // Decrement durability of the first equipped armor piece (character only)
+      const items = (actor as any).items as Iterable<any> | undefined;
+      if (items) {
+        for (const it of items) {
+          if (it.type === 'gear' && it.system?.equipped && it.system?.category === 'armor') {
+            const cond = Math.max(0, Number(it.system.armor?.condition ?? 0) - 1);
+            await it.update({ 'system.armor.condition': cond });
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  // Layer 4: Health
+  if (remaining > 0 && a.health) {
+    const hp = Math.max(0, Number(a.health.value) || 0);
+    const newHp = Math.max(0, hp - remaining);
+    report.hpDamage = hp - newHp;
+    updates['system.attributes.health.value'] = newHp;
+  }
+
+  if (Object.keys(updates).length > 0) await actor.update(updates);
+
+  if (opts.postChat ?? true) {
+    const lines: string[] = [
+      `<strong>${actor.name}</strong> — ${game.i18n.localize('HBM.damage.report.title')}: <strong>${total}</strong>`,
+    ];
+    if (report.absorbed.magicalArmor) lines.push(`${game.i18n.localize('HBM.resources.magicalArmor')}: −${report.absorbed.magicalArmor}`);
+    if (report.absorbed.magicalShield) lines.push(`${game.i18n.localize('HBM.resources.magicalShield')}: −${report.absorbed.magicalShield}${report.shieldDropped ? ' ✦' : ''}`);
+    if (report.absorbed.physicalArmor) lines.push(`${game.i18n.localize('HBM.resources.physicalArmor')}: −${report.absorbed.physicalArmor}`);
+    if (report.hpDamage) lines.push(`${game.i18n.localize('HBM.resources.health')}: −${report.hpDamage}`);
+    await ChatMessage.create({ content: `<div class="hbm-damage-report">${lines.join('<br/>')}</div>` });
+  }
+
+  return report;
+}