initial commit

Outnumbered/Domain/CombatResolver.cs

@@ -0,0 +1,78 @@
+using System.Collections.Frozen;
+using Outnumbered.Config;
+
+namespace Outnumbered.Domain;
+
+// The offense + defense multiplier chains — the SINGLE source of truth shared by the damage hook (applies them) and the
+// HUD readout (shows them). Pure: the crit decision (which has engine side effects: a sound + the crit-XP marker) is made
+// by the caller and passed in as `crit`; the HUD passes crit:false. Lifesteal/thorns amounts are here too so the reactive
+// sustain glue applies identical numbers.
+public static class CombatResolver
+{
+    public static double CritChance(in PlayerSnapshot s, FrozenDictionary<string, StatDef> defs) =>
+        StatResolver.EffRun(s, StatKeys.CritChance, defs);
+
+    // The damage hook path: computes its own MDeal (one ComputeT per hit). Delegates to the mDeal-taking overload.
+    public static double OffenseMultiplier(in PlayerSnapshot s, bool headshot, bool crit,
+        FrozenDictionary<string, StatDef> defs, in ResolvedHandicap rh, AbilitiesConfig ab, int baseMaxHp) =>
+        OffenseMultiplier(s, headshot, crit, defs, ab, baseMaxHp, HandicapModel.MDeal(s, rh));
+
+    // Overload taking a PRECOMPUTED MDeal — lets the HUD share ONE ComputeT across deal/take/xp (via HandicapModel.Bands).
+    // The missing-HP fraction (an EffRun lookup + a divide) is computed only when a Berserk consumer is actually active.
+    public static double OffenseMultiplier(in PlayerSnapshot s, bool headshot, bool crit,
+        FrozenDictionary<string, StatDef> defs, AbilitiesConfig ab, int baseMaxHp, double mDeal)
+    {
+        double dmgMul = 1.0 + StatResolver.EffRun(s, StatKeys.Damage, defs) / 100.0;
+        double hsMul = headshot ? 1.0 + StatResolver.EffRun(s, StatKeys.HeadshotDamage, defs) / 100.0 : 1.0;
+        double critMul = crit ? 1.0 + StatResolver.EffRun(s, StatKeys.CritDamage, defs) / 100.0 : 1.0;
+
+        double abilityMul = 1.0;
+        double berserkCard = StatResolver.CardMag(s, CardKeys.BerserkPassive); // always-on passive card
+        bool needMissing = berserkCard > 0 || (ab.Enabled && s.BerserkActive); // the only consumers of `missing`
+        double missing = needMissing ? StatResolver.MissingHpFraction(s, StatResolver.MaxHp(s, defs, baseMaxHp)) : 0.0;
+        if (ab.Enabled)
+        {
+            if (s.OverchargeActive) abilityMul *= 1.0 + ab.Overcharge.Magnitude / 100.0;
+            if (s.BerserkActive)
+            {
+                abilityMul *= 1.0 + missing * ab.Berserk.Magnitude;
+                if (crit) critMul += missing * ab.Berserk.Magnitude2;
+            }
+        }
+        if (berserkCard > 0) abilityMul *= 1.0 + missing * berserkCard / 100.0;
+
+        return dmgMul * hsMul * critMul * abilityMul * mDeal;
+    }
+
+    // The damage hook path: computes its own MTake. Delegates to the mTake-taking overload.
+    public static double DefenseMultiplier(in PlayerSnapshot s, bool headshot, in ResolvedHandicap rh, AbilitiesConfig ab) =>
+        DefenseMultiplier(s, headshot, ab, HandicapModel.MTake(s, rh));
+
+    // Overload taking a PRECOMPUTED MTake (the global_take team card is already folded in by HandicapModel).
+    public static double DefenseMultiplier(in PlayerSnapshot s, bool headshot, AbilitiesConfig ab, double mTake)
+    {
+        double take = mTake;
+        if (ab.Enabled && s.AdrenalineActive) take *= 1.0 - ab.Adrenaline.Magnitude / 100.0;
+        if (headshot)
+        {
+            double hsCut = StatResolver.CardMag(s, CardKeys.HsReduction);       // armor doesn't help vs HS; this does
+            if (hsCut > 0) take *= Math.Max(0.0, 1.0 - hsCut / 100.0);
+        }
+        return take;
+    }
+
+    // ---- pure amounts the reactive-sustain glue applies (it still does the engine HP/armor writes) ----
+    // dmgHealth is a double so BOTH callers share one formula bit-identically: the on-hit path passes the int
+    // ev.DmgHealth (widens exactly) with the crit multiplier; the thorns-reflect path passes the FLOAT `dealt`
+    // (the offense-scaled reflected damage — keeps full precision, no pre-truncation) with critMult=1.0 (×1.0 is exact).
+    public static int LifestealHeal(double dmgHealth, double lifestealPct, double critMult, int minHeal) =>
+        Math.Max(minHeal, (int)Math.Round(dmgHealth * lifestealPct / 100.0 * critMult));
+
+    public static int ArmorLifestealGain(double dmgHealth, double armorLifestealPct, double critMult) =>
+        (int)Math.Round(dmgHealth * armorLifestealPct / 100.0 * critMult);
+
+    // % of the damage ACTUALLY taken (health + armor, so it already includes the MTake handicap that sized the hit — a 5x
+    // handicap 250 HP hit at 10% is 25). The caller deals this FLAT (DamageDealer flat) so the bot eats exactly this: no
+    // build and no MDeal are re-applied on the way out.
+    public static double ThornsReflect(int dmgHealth, int dmgArmor, double thornsPct) => (dmgHealth + dmgArmor) * thornsPct / 100.0;
+}