implement more enemies, balance some programming languages and enemies to be less annoying

2026-07-10 10:21:47 +02:00
parent e3ea42c93e
commit 18297fac9a
33 changed files with 1025 additions and 136 deletions
@@ -7,12 +7,15 @@ namespace KernelPanic.Combat
 {
    public sealed class DealDamageEffect : ICardEffect
    {
+        private const int RustOverflowRollMax = 1000000;
+        private const string RustUnsigned64LimitText = "18446744073709551615";
+
        private readonly int _minAmount;
        private readonly int _maxAmount;
        private readonly Language _language;
        private readonly bool _trueDamage;
        private readonly bool _canCrit;
-        private readonly bool _allEnemies;
+        private readonly bool _allEnemies; 

        public DealDamageEffect(int minAmount, int maxAmount, Language language, bool trueDamage = false, bool canCrit = true, bool allEnemies = false)
        {
@@ -49,22 +52,80 @@ namespace KernelPanic.Combat
                int amount = minAmount == maxAmount
                    ? minAmount
                    : RandomRoll.RollRange(minAmount, maxAmount, new RollContext(context.Source));
+                bool rustUnsignedOverflow = IsRustDamage(context)
+                    && RandomRoll.RollRange(1, RustOverflowRollMax, new RollContext(context.Source)) == 1;
+                if (rustUnsignedOverflow)
+                {
+                    amount = int.MaxValue;
+                    context.CombatManager.ReportEffectResult($"rust unsigned overflow: {RustUnsigned64LimitText}");
+                }

-                bool rustOverkillToShield = _language == Language.Rust || context.Card?.Definition?.Language == Language.Rust;
-                int survivable = rustOverkillToShield
-                    ? _trueDamage ? target.CurrentUptime : target.CurrentUptime + target.Shield
+                bool rustOverkillToShield = IsRustDamage(context);
+                bool overkillSpills = IsSpillDamage(context);
+                int survivable = rustOverkillToShield || overkillSpills
+                    ? GetSurvivableDamage(target, _trueDamage)
                    : 0;
-                DamageResult result = context.DamagePipeline.DealDamage(new DamageRequest(context.Source, target, amount, _language, _trueDamage, _canCrit));
+                DamageResult result = context.DamagePipeline.DealDamage(new DamageRequest(context.Source, target, amount, _language, _trueDamage, _canCrit && !rustUnsignedOverflow));
                dealtDamage |= result.IncomingAmount > 0;
                if (rustOverkillToShield)
                {
                    GrantRustOverkillShield(context, result, survivable);
                }
+
+                if (overkillSpills)
+                {
+                    dealtDamage |= SpillOverkillDamage(context, target, result, survivable);
+                }
            }

            SegfaultRecoil.TryApply(context, _language, dealtDamage);
        }

+        private bool IsRustDamage(CombatContext context)
+        {
+            return _language == Language.Rust || context.Card?.Definition?.Language == Language.Rust;
+        }
+
+        private bool IsSpillDamage(CombatContext context)
+        {
+            Language cardLanguage = context.Card?.Definition == null ? _language : context.Card.Definition.Language;
+            return _language == Language.C
+                || _language == Language.Java
+                || cardLanguage == Language.C
+                || cardLanguage == Language.Java;
+        }
+
+        private static int GetSurvivableDamage(CombatantState target, bool trueDamage)
+        {
+            return target == null ? 0 : trueDamage ? target.CurrentUptime : target.CurrentUptime + target.Shield;
+        }
+
+        private bool SpillOverkillDamage(CombatContext context, CombatantState firstTarget, DamageResult firstResult, int firstSurvivable)
+        {
+            int remaining = UnityEngine.Mathf.Max(0, firstResult.IncomingAmount - firstSurvivable);
+            if (remaining <= 0)
+            {
+                return false;
+            }
+
+            bool dealtDamage = false;
+            for (int i = 0; i < context.Enemies.Count && remaining > 0; i++)
+            {
+                CombatantState spillTarget = context.Enemies[i].State;
+                if (spillTarget == null || spillTarget == firstTarget || spillTarget.IsDefeated)
+                {
+                    continue;
+                }
+
+                int survivable = GetSurvivableDamage(spillTarget, _trueDamage);
+                DamageResult spillResult = context.DamagePipeline.DealDamage(new DamageRequest(context.Source, spillTarget, remaining, _language, _trueDamage, false, applySourceModifiers: false));
+                dealtDamage |= spillResult.IncomingAmount > 0;
+                remaining = UnityEngine.Mathf.Max(0, spillResult.IncomingAmount - survivable);
+            }
+
+            return dealtDamage;
+        }
+
        private static void GrantRustOverkillShield(CombatContext context, DamageResult result, int survivable)
        {
            int overkill = UnityEngine.Mathf.Max(0, result.IncomingAmount - survivable);
@@ -165,7 +226,9 @@ namespace KernelPanic.Combat
                    continue;
                }

-                int roll = RandomRoll.RollRange(1, 100, new RollContext(context.Source));
+                int roll = context.Source != null && context.Source.ForceMaxRolls
+                    ? 1
+                    : RandomRoll.RollRange(1, 100, RollContext.None);
                int damageAmount = UpgradeMath.ScaleAmount(UpgradeMath.ApplySourceFlatBonus(_damageAmount, context), context.Card);
                int amount = roll <= _successPercent ? damageAmount : 0;
                DamageResult result = context.DamagePipeline.DealDamage(new DamageRequest(context.Source, target, amount, _language, false, true));
@@ -308,7 +371,7 @@ namespace KernelPanic.Combat
        public void Execute(CombatContext context)
        {
            int cCards = context.HandController.Cards.Count(card => card?.Definition != null && card.Definition.Language == Language.C);
-            int amount = 3 * cCards;
+            int amount = 5 * cCards;
            new DealDamageEffect(amount, amount, Language.C).Execute(context);
        }
    }
@@ -873,6 +936,7 @@ namespace KernelPanic.Combat

            DamageResult result = context.DamagePipeline.DealDamage(new DamageRequest(null, context.Source, uptimeDamage, Language.C, true, false));
            context.CombatManager.ReportEffectResult($"segfault: uptime -{result.FinalAmount}");
+            context.CombatManager.TryCorruptRandomHandCard("segfault");
            if (drawOnSegfault)
            {
                context.CombatManager.DrawCards(2, "free() recoil");
@@ -922,9 +986,9 @@ namespace KernelPanic.Combat
                    new DrawEffect(1)
                },
                "lang_rs_borrow" => One(new ShieldEffect(5)),
-                "lang_c_malloc" => One(new DealDamageEffect(8, 8, Language.C)),
-                "lang_c_printf" => One(new DealDamageEffect(4, 4, Language.C)),
-                "lang_c_pointer" => One(new PreviousLanguageDamageEffect(6, 10, Language.C)),
+                "lang_c_malloc" => One(new DealDamageEffect(12, 12, Language.C)),
+                "lang_c_printf" => One(new DealDamageEffect(7, 7, Language.C)),
+                "lang_c_pointer" => One(new PreviousLanguageDamageEffect(9, 15, Language.C)),
                "lang_java_public_static_main" => One(new DealDamageEffect(7, 7, Language.Java)),
                "lang_java_system_out_println" => One(new DealDamageEffect(5, 5, Language.Java)),
                "lang_java_new_object" => One(new DealDamageEffect(3, 3, Language.Java)),
@@ -976,14 +1040,14 @@ namespace KernelPanic.Combat
                "fedora_dnf_update" => One(new DealDamageEffect(9, 9, Language.Java)),
                "fedora_rawhide" => One(new RawhideEffect()),
                "fedora_selinux" => One(new IncomingAttackHalveEffect(2)),
-                "arch_pacman_syu" => One(new DealDamageEffect(8, 8, Language.C)),
+                "arch_pacman_syu" => One(new DealDamageEffect(14, 14, Language.C)),
                "arch_consult_wiki" => One(new ConsultWikiEffect()),
-                "arch_makepkg" => One(new BtwScaledDamageEffect(4, 2, Language.C)),
+                "arch_makepkg" => One(new BtwScaledDamageEffect(7, 3, Language.C)),
                "arch_aur_helper" => One(new RandomCommonLanguageCardEffect()),
                "arch_minimal_install" => One(new MinimalInstallEffect()),
-                "shop_c_free" => One(new DealDamageEffect(12, 12, Language.C)),
+                "shop_c_free" => One(new DealDamageEffect(18, 18, Language.C)),
                "shop_c_sizeof" => One(new SizeofDamageEffect()),
-                "shop_c_kernel_exploit" => One(new DealDamageEffect(25, 25, Language.C, true)),
+                "shop_c_kernel_exploit" => One(new DealDamageEffect(36, 36, Language.C, true)),
                _ => Todo("card effect is not authored")
            };
        }
@@ -1053,12 +1117,12 @@ namespace KernelPanic.Combat
                "lang_rs_fn_main" => $"deal {UpgradeMath.ScaleAmount(6, card)}. overkill becomes shield.{marker}",
                "lang_rs_unwrap" => $"deal {UpgradeMath.ScaleAmount(9, card)}. overkill becomes shield. draw {UpgradeMath.ScaleAmount(1, card)}.{marker}",
                "lang_rs_borrow" => $"gain {UpgradeMath.ScaleShield(5, card)} shield.{marker}",
-                "lang_c_malloc" => $"deal {UpgradeMath.ScaleAmount(8, card)}. 20%: segfault, uptime -3.{marker}",
-                "lang_c_printf" => $"deal {UpgradeMath.ScaleAmount(4, card)}. 20%: segfault, uptime -3.{marker}",
-                "lang_c_pointer" => $"deal {UpgradeMath.ScaleAmount(6, card)}; {UpgradeMath.ScaleAmount(10, card)} if the previous card was C. 20%: segfault, uptime -3.{marker}",
-                "lang_java_public_static_main" => $"uses 2 RAM. deal {UpgradeMath.ScaleAmount(7, card)}. JIT: Java cards cost 1 less this combat each time you play a Java card; discount decays by 1 after each wave.{marker}",
-                "lang_java_system_out_println" => $"uses 2 RAM. deal {UpgradeMath.ScaleAmount(5, card)}. JIT applies; discount decays by 1 after each wave.{marker}",
-                "lang_java_new_object" => $"uses 2 RAM. deal {UpgradeMath.ScaleAmount(3, card)}. JIT applies; discount decays by 1 after each wave.{marker}",
+                "lang_c_malloc" => $"deal {UpgradeMath.ScaleAmount(12, card)}. overkill spills. 20%: segfault, uptime -3 and corrupt a hand card.{marker}",
+                "lang_c_printf" => $"deal {UpgradeMath.ScaleAmount(7, card)}. overkill spills. 20%: segfault, uptime -3 and corrupt a hand card.{marker}",
+                "lang_c_pointer" => $"deal {UpgradeMath.ScaleAmount(9, card)}; {UpgradeMath.ScaleAmount(15, card)} if the previous card was C. overkill spills. 20%: segfault, uptime -3 and corrupt a hand card.{marker}",
+                "lang_java_public_static_main" => $"uses 2 RAM. deal {UpgradeMath.ScaleAmount(7, card)}. overkill spills. JIT: Java cards cost 1 less this combat each time you play a Java card; discount decays by 1 after each wave.{marker}",
+                "lang_java_system_out_println" => $"uses 2 RAM. deal {UpgradeMath.ScaleAmount(5, card)}. overkill spills. JIT applies; discount decays by 1 after each wave.{marker}",
+                "lang_java_new_object" => $"uses 2 RAM. deal {UpgradeMath.ScaleAmount(3, card)}. overkill spills. JIT applies; discount decays by 1 after each wave.{marker}",
                "shop_py_list_append" => $"queue: deal {UpgradeMath.ScaleAmount(4 + UnityEngine.Mathf.Max(0, card.QueuePlayCount - 1), card)}; +1 each time re-queued.{marker}",
                "shop_py_async_def" => $"queue: draw {UpgradeMath.ScaleAmount(2, card)}. gain {UpgradeMath.ScaleAmount(1, card)} cycle next turn.{marker}",
                "shop_py_zip" => $"next {UpgradeMath.ScaleAmount(2, card)} queued cards resolve twice.{marker}",
@@ -1077,17 +1141,17 @@ namespace KernelPanic.Combat
                "mint_timeshift" => $"queue: record uptime now. at end of your next turn, restore to it if lower.{marker}",
                "fedora_dnf_autoremove" => $"deal {UpgradeMath.ScaleAmount(7, card)}. exhaust a junk/NOP/broken card from hand; if you do, gain {UpgradeMath.ScaleAmount(1, card)} cycle. if not, do nothing.{marker}",
                "fedora_first_to_package" => $"deal {UpgradeMath.ScaleAmount(7, card)}. Java cards cost 1 less this turn.{marker}",
-                "fedora_dnf_update" => $"deal {UpgradeMath.ScaleAmount(9, card)}. costs 1 less per Java card played this combat.{marker}",
+                "fedora_dnf_update" => $"deal {UpgradeMath.ScaleAmount(9, card)}. overkill spills. costs 1 less per Java card played this combat.{marker}",
                "fedora_rawhide" => $"draw {UpgradeMath.ScaleAmount(2, card)}. next card this turn gains bleeding edge.{marker}",
                "fedora_selinux" => $"next {UpgradeMath.ScaleAmount(2, card)} enemy attacks deal half damage.{marker}",
-                "arch_pacman_syu" => $"deal {UpgradeMath.ScaleAmount(8, card)}. 20%: segfault, uptime -3. TODO: 20% break a random hand card.{marker}",
+                "arch_pacman_syu" => $"deal {UpgradeMath.ScaleAmount(14, card)}. overkill spills. 20%: segfault, uptime -3 and corrupt a hand card.{marker}",
                "arch_consult_wiki" => $"fix a broken card and draw {UpgradeMath.ScaleAmount(1, card)}; if none, deal {UpgradeMath.ScaleAmount(6, card)}.{marker}",
-                "arch_makepkg" => $"deal {UpgradeMath.ScaleAmount(4, card)} + btw x2; x3 at Arch v3+. 20%: segfault, uptime -3.{marker}",
+                "arch_makepkg" => $"deal {UpgradeMath.ScaleAmount(7, card)} + btw x3; x4 at Arch v3+. overkill spills. 20%: segfault, uptime -3 and corrupt a hand card.{marker}",
                "arch_aur_helper" => $"add a random C/Rust common card to hand; it costs 0 this turn.{marker}",
                "arch_minimal_install" => $"exhaust up to 2 hand cards. per card: gain 3 Shield and 1 Cycle.{marker}",
-                "shop_c_free" => $"deal {UpgradeMath.ScaleAmount(12, card)}. 20%: segfault, uptime -3 and draw 2.{marker}",
-                "shop_c_sizeof" => $"deal 3 x C cards in hand. 20%: segfault, uptime -3.{marker}",
-                "shop_c_kernel_exploit" => $"deal {UpgradeMath.ScaleAmount(25, card)} ignoring Shield. 50%: segfault, uptime -8.{marker}",
+                "shop_c_free" => $"deal {UpgradeMath.ScaleAmount(18, card)}. overkill spills. 20%: segfault, uptime -3, corrupt a hand card, and draw 2.{marker}",
+                "shop_c_sizeof" => $"deal 5 x C cards in hand. overkill spills. 20%: segfault, uptime -3 and corrupt a hand card.{marker}",
+                "shop_c_kernel_exploit" => $"deal {UpgradeMath.ScaleAmount(36, card)} ignoring Shield. overkill spills. 50%: segfault, uptime -8 and corrupt a hand card.{marker}",
                _ => string.IsNullOrWhiteSpace(card.Definition.Description) ? "effect not authored." : $"{card.Definition.Description}{marker}"
            };
        }
@@ -53,6 +53,7 @@ namespace KernelPanic.Combat
        private int _rawhideBonusCharges;
        private int _queuedRepeatCharges;
        private int _nextTurnCycleBonus;
+        private int _nextRacePairId = 1;
        private Coroutine _phaseCoroutine;

        public TurnPhase CurrentPhase => currentPhase;
@@ -77,6 +78,7 @@ namespace KernelPanic.Combat
        private void Awake()
        {
            _runManager = GetComponent<RunManager>();
+            _damagePipeline.ResistanceResolver = ResolveDamageResistance;
        }

        private void OnEnable()
@@ -184,6 +186,18 @@ namespace KernelPanic.Combat
                return false;
            }

+            if (card.IsBroken)
+            {
+                Log($"{GetCardName(card)} is corrupted");
+                return false;
+            }
+
+            if (card.IsLocked)
+            {
+                Log($"{GetCardName(card)} is locked");
+                return false;
+            }
+
            bool fedoraBonus = CanApplyFedoraBonus();
            int cost = GetEffectiveCardCost(card);
            if (fedoraBonus)
@@ -343,6 +357,21 @@ namespace KernelPanic.Combat
            }
        }

+        public bool TryCorruptRandomHandCard(string sourceLabel)
+        {
+            CardInstance card = RandomHandCard(cardInstance => cardInstance != null && !cardInstance.IsBroken);
+            if (card == null)
+            {
+                Log($"{sourceLabel}: no card available to corrupt");
+                return false;
+            }
+
+            card.IsBroken = true;
+            Log($"{sourceLabel}: corrupted {GetCardName(card)}");
+            StateChanged?.Invoke();
+            return true;
+        }
+
        public void ReportEffectResult(string message)
        {
            if (!string.IsNullOrWhiteSpace(message))
@@ -651,6 +680,7 @@ namespace KernelPanic.Combat
            _pendingTargetCard = null;
            _cardsPlayedThisWave = 0;
            _turnNumberThisWave = 0;
+            _nextRacePairId = 1;
            _packageShieldBonusTriggeredThisTurn = false;
            _packageTimeshiftTriggeredThisWave = false;
            ResetArchWaveState();
@@ -753,10 +783,10 @@ namespace KernelPanic.Combat

        private IEnumerator ProcessEnemiesSequenced()
        {
-            int enemyCountAtPhaseStart = _enemies.Count;
-            for (int i = 0; i < enemyCountAtPhaseStart && i < _enemies.Count; i++)
+            List<EnemyInstance> actors = BuildEnemyActionOrder();
+            for (int i = 0; i < actors.Count; i++)
            {
-                EnemyInstance enemy = _enemies[i];
+                EnemyInstance enemy = actors[i];
                if (enemy.State.IsDefeated)
                {
                    continue;
@@ -779,11 +809,17 @@ namespace KernelPanic.Combat
                StateChanged?.Invoke();
                yield return Wait(CombatTuning.EnemyTelegraphDelaySeconds);

-                ExecuteEnemyIntent(enemy, i);
-                enemy.MarkTurnSurvived();
+                ExecuteEnemyIntent(enemy, _enemies.IndexOf(enemy));
+                ResolvePassiveEnemyAfterAction(enemy);
+                if (!enemy.State.IsDefeated)
+                {
+                    enemy.MarkTurnSurvived();
+                }
+
                GameEvents.RaiseEnemyActed(new EnemyActedEvent(enemy, enemy.CurrentIntent));
+                RemoveDefeatedEnemies();
                StateChanged?.Invoke();
-                if (CheckLoss())
+                if (CheckWinOrLoss())
                {
                    yield break;
                }
@@ -1519,7 +1555,7 @@ namespace KernelPanic.Combat
            state.DamageMultiplierPercent = 100;
            state.CurrentCardDamageMultiplierPercent = 100;
            state.ArchBtwDamagePerStack = IsDistro("arch") && _runConfig.DistroVersion >= 2 ? 2 : 1;
-            state.ArchMakepkgBtwMultiplier = IsDistro("arch") && _runConfig.DistroVersion >= 3 ? 3 : 2;
+            state.ArchMakepkgBtwMultiplier = IsDistro("arch") && _runConfig.DistroVersion >= 3 ? 4 : 3;
            state.ArchRollingReleaseShieldOnSave = IsDistro("arch") && _runConfig.DistroVersion >= 4 ? 15 : 0;
            state.ArchRollingReleaseCyclesOnSave = IsDistro("arch") && _runConfig.DistroVersion >= 4 ? 2 : 0;
        }
@@ -1693,13 +1729,15 @@ namespace KernelPanic.Combat
            {
                if (_enemies[i].State.IsDefeated)
                {
-                    if (_enemies[i].PendingRevive)
+                    EnemyInstance enemy = _enemies[i];
+                    if (enemy.PendingRevive)
                    {
                        continue;
                    }

-                    Log($"{_enemies[i].Name} exited");
+                    Log($"{enemy.Name} exited");
                    _runManager?.AddBits(CombatTuning.BitsPerKill);
+                    HandleEnemyDeath(enemy);
                    _enemies.RemoveAt(i);
                }
            }
@@ -1710,23 +1748,135 @@ namespace KernelPanic.Combat
            }
        }

+        private void HandleEnemyDeath(EnemyInstance enemy)
+        {
+            if (enemy == null)
+            {
+                return;
+            }
+
+            if (enemy.HasBehavior(EnemyBehaviorFlags.SegfaultOnDeath))
+            {
+                ApplySegfaultDeathPayload(enemy);
+            }
+
+            if (enemy.HasBehavior(EnemyBehaviorFlags.RacePair))
+            {
+                BreakRacePair(enemy);
+            }
+
+            if (enemy.HasBehavior(EnemyBehaviorFlags.LeavesOrphan))
+            {
+                SpawnOrphanFromDeath(enemy);
+            }
+        }
+
+        private void ApplySegfaultDeathPayload(EnemyInstance enemy)
+        {
+            _statusEffects.Apply(_playerState, StatusType.Segfault, 1, -1, enemy.State, skipNextTick: true);
+            TryCorruptRandomHandCard("segfault");
+        }
+
+        private CardInstance RandomHandCard(Predicate<CardInstance> predicate)
+        {
+            if (_handController == null || _handController.Cards.Count == 0)
+            {
+                return null;
+            }
+
+            List<CardInstance> candidates = new();
+            for (int i = 0; i < _handController.Cards.Count; i++)
+            {
+                CardInstance candidate = _handController.Cards[i];
+                if (predicate == null || predicate(candidate))
+                {
+                    candidates.Add(candidate);
+                }
+            }
+
+            if (candidates.Count == 0)
+            {
+                return null;
+            }
+
+            int index = RandomRoll.RollRange(0, candidates.Count - 1, new RollContext(_playerState));
+            return candidates[index];
+        }
+
+        private void BreakRacePair(EnemyInstance defeated)
+        {
+            EnemyInstance survivor = RacePartner(defeated);
+            if (survivor == null)
+            {
+                return;
+            }
+
+            survivor.EnrageRaceSurvivor();
+            Log($"{survivor.Name} race link broke; survivor enraged");
+        }
+
+        private void SpawnOrphanFromDeath(EnemyInstance source)
+        {
+            EnemyInstance orphan = SpawnEnemy("orphan_process", 0);
+            orphan.MarkSpawnedFromDeath();
+            Log($"{source.Name} left an orphan process");
+        }
+
        private void SpawnStructuralEnemies()
        {
            int wave = CurrentWaveNumber;
            int countGrowth = ((wave - 1) / 2) * CombatTuning.AdditionalEnemiesPerWave;
            int count = Mathf.Clamp(CombatTuning.BaseEnemiesPerWave + countGrowth, CombatTuning.BaseEnemiesPerWave, CombatTuning.MaxEnemiesPerWave);
            int waveUptimeBonus = Mathf.Max(0, wave - 1) * CombatTuning.EnemyUptimeGrowthPerWave;
+            bool rootkitSpawned = false;
            for (int i = 0; i < count; i++)
            {
-                SpawnEnemy(CreatePlaceholderArchetypeId(wave, i), waveUptimeBonus);
+                string archetypeId = CreatePlaceholderArchetypeId(wave, i);
+                if (archetypeId == "rootkit")
+                {
+                    if (rootkitSpawned)
+                    {
+                        archetypeId = CreateRootkitFallbackArchetypeId(wave, i);
+                    }
+                    else
+                    {
+                        rootkitSpawned = true;
+                    }
+                }
+
+                if (archetypeId == "race_condition" && i + 1 < count)
+                {
+                    SpawnRacePair(waveUptimeBonus);
+                    i++;
+                    continue;
+                }
+
+                if (archetypeId == "race_condition")
+                {
+                    archetypeId = "segfault";
+                }
+
+                SpawnEnemy(archetypeId, waveUptimeBonus);
            }
        }

-        private void SpawnEnemy(string archetypeId, int uptimeBonus)
+        private void SpawnRacePair(int uptimeBonus)
+        {
+            int pairId = _nextRacePairId++;
+            EnemyInstance first = SpawnEnemy("race_condition", uptimeBonus);
+            EnemyInstance second = SpawnEnemy("race_condition", uptimeBonus);
+            first.SetPairId(pairId);
+            second.SetPairId(pairId);
+            Log("race condition pair spawned");
+        }
+
+        private EnemyInstance SpawnEnemy(string archetypeId, int uptimeBonus)
        {
            EnemyArchetypeDescriptor archetype = EnemyArchetypeCatalog.Get(archetypeId);
            int baseUptime = RandomRoll.RollRange(archetype.BaseUptimeMin, archetype.BaseUptimeMax, RollContext.None);
-            _enemies.Add(new EnemyInstance(archetype, baseUptime + Mathf.Max(0, uptimeBonus)));
+            EnemyInstance enemy = new(archetype, baseUptime + Mathf.Max(0, uptimeBonus));
+            _enemies.Add(enemy);
+            return enemy;
        }

        private static string CreatePlaceholderArchetypeId(int wave, int slotIndex)
@@ -1736,17 +1886,28 @@ namespace KernelPanic.Combat
            {
                <= 1 => new[] { "zombie_process", "memory_leak" },
                2 => new[] { "zombie_process", "memory_leak", "fork_bomb", "firewalld" },
-                3 => new[] { "zombie_process", "memory_leak", "fork_bomb", "firewalld", "daemon" },
-                _ => new[] { "zombie_process", "memory_leak", "fork_bomb", "firewalld", "daemon", "cron_job" }
+                3 => new[] { "zombie_process", "memory_leak", "fork_bomb", "firewalld", "segfault" },
+                4 => new[] { "zombie_process", "memory_leak", "fork_bomb", "firewalld", "cron_job", "segfault", "race_condition" },
+                _ => new[] { "zombie_process", "memory_leak", "fork_bomb", "firewalld", "daemon", "cron_job", "segfault", "race_condition", "rootkit" }
            };

            if (slotIndex == 0)
            {
+                if (wave >= 5 && wave % 2 == 1)
+                {
+                    return "rootkit";
+                }
+
                return wave % 2 == 0 ? "firewalld" : "zombie_process";
            }

            if (slotIndex == 1 && wave >= 2)
            {
+                if (wave >= 4 && wave % 4 == 0)
+                {
+                    return "race_condition";
+                }
+
                return wave % 3 == 0 ? "fork_bomb" : "memory_leak";
            }

@@ -1754,6 +1915,13 @@ namespace KernelPanic.Combat
            return pool[index];
        }

+        private static string CreateRootkitFallbackArchetypeId(int wave, int slotIndex)
+        {
+            return slotIndex % 2 == 0
+                ? "firewalld"
+                : wave % 3 == 0 ? "fork_bomb" : "memory_leak";
+        }
+
        private void PickEnemyIntents()
        {
            for (int i = 0; i < _enemies.Count; i++)
@@ -1765,6 +1933,37 @@ namespace KernelPanic.Combat
            }
        }

+        private List<EnemyInstance> BuildEnemyActionOrder()
+        {
+            List<EnemyInstance> actors = _enemies
+                .Where(enemy => enemy.State != null && !enemy.State.IsDefeated)
+                .ToList();
+
+            for (int i = 0; i < actors.Count - 1; i++)
+            {
+                EnemyInstance enemy = actors[i];
+                if (!IsRacePairLinked(enemy))
+                {
+                    continue;
+                }
+
+                EnemyInstance partner = RacePartner(enemy);
+                int partnerIndex = partner == null ? -1 : actors.IndexOf(partner);
+                if (partnerIndex <= i)
+                {
+                    continue;
+                }
+
+                if (RandomRoll.RollRange(0, 1, new RollContext(enemy.State)) == 1)
+                {
+                    actors[i] = partner;
+                    actors[partnerIndex] = enemy;
+                }
+            }
+
+            return actors;
+        }
+
        private void ExecuteEnemyIntent(EnemyInstance enemy, int enemyIndex)
        {
            EnemyIntent intent = enemy.CurrentIntent;
@@ -1775,6 +1974,7 @@ namespace KernelPanic.Combat
            switch (intent.Kind)
            {
                case EnemyIntentKind.Attack:
+                    value = ApplyEnemyAttackBonuses(enemy, value);
                    value = ApplyIncomingAttackMitigation(value);
                    DamageResult attackResult = _damagePipeline.DealDamage(new DamageRequest(enemy.State, _playerState, value, intent.DamageType, intent.TrueDamage, false));
                    GameEvents.RaisePlayerDamaged(new PlayerDamagedEvent(enemy, attackResult.FinalAmount));
@@ -1790,6 +1990,7 @@ namespace KernelPanic.Combat
                    }
                    break;
                case EnemyIntentKind.StatusAttack:
+                    value = ApplyEnemyAttackBonuses(enemy, value);
                    DamageResult statusResult = _damagePipeline.DealDamage(new DamageRequest(enemy.State, _playerState, value, intent.DamageType, intent.TrueDamage, false));
                    GameEvents.RaisePlayerDamaged(new PlayerDamagedEvent(enemy, statusResult.FinalAmount));
                    if (intent.StatusStacks > 0)
@@ -1810,15 +2011,50 @@ namespace KernelPanic.Combat

        private void ExecuteSpecialEnemyIntent(EnemyInstance enemy)
        {
-            if (enemy.HasBehavior(EnemyBehaviorFlags.Split))
+            if (enemy.HasBehavior(EnemyBehaviorFlags.SegfaultOnDeath))
            {
-                TrySplitForkBomb(enemy);
+                enemy.AdvanceSegfaultCountdown();
+                if (enemy.CountdownRemaining <= 0)
+                {
+                    _damagePipeline.DealDamage(new DamageRequest(enemy.State, enemy.State, enemy.CurrentUptime, Language.C, true, false));
+                    Log($"{enemy.Name} dereferenced null");
+                }
+
                return;
            }

            Log("TODO: special intent needs enemy-specific behavior hooks.");
        }

+        private void ResolvePassiveEnemyAfterAction(EnemyInstance enemy)
+        {
+            if (enemy == null || enemy.State.IsDefeated)
+            {
+                return;
+            }
+
+            if (enemy.HasBehavior(EnemyBehaviorFlags.Split))
+            {
+                TrySplitForkBomb(enemy);
+            }
+        }
+
+        private int ApplyEnemyAttackBonuses(EnemyInstance enemy, int value)
+        {
+            int modified = value;
+            if (IsRacePairLinked(enemy))
+            {
+                modified += EnemyArchetypeCatalog.RacePairDamageBonus;
+            }
+
+            if (enemy != null && enemy.RaceEnrageStacks > 0)
+            {
+                modified += enemy.RaceEnrageStacks;
+            }
+
+            return modified;
+        }
+
        private void TrySplitForkBomb(EnemyInstance source)
        {
            int totalForkBombs = _enemies.Count(enemy => enemy.ArchetypeId == source.ArchetypeId && !enemy.State.IsDefeated);
@@ -1836,6 +2072,34 @@ namespace KernelPanic.Combat
            Log("fork bomb split");
        }

+        private bool IsRacePairLinked(EnemyInstance enemy)
+        {
+            return enemy != null
+                && enemy.HasBehavior(EnemyBehaviorFlags.RacePair)
+                && RacePartner(enemy) != null;
+        }
+
+        private EnemyInstance RacePartner(EnemyInstance enemy)
+        {
+            if (enemy == null || enemy.PairId < 0)
+            {
+                return null;
+            }
+
+            for (int i = 0; i < _enemies.Count; i++)
+            {
+                EnemyInstance candidate = _enemies[i];
+                if (candidate != enemy
+                    && candidate.PairId == enemy.PairId
+                    && !candidate.State.IsDefeated)
+                {
+                    return candidate;
+                }
+            }
+
+            return null;
+        }
+
        private void DefendSelfAndAdjacent(int enemyIndex, int amount)
        {
            int applied = 0;
@@ -1866,6 +2130,38 @@ namespace KernelPanic.Combat
            return mitigated;
        }

+        private int ResolveDamageResistance(DamageRequest request, int amount)
+        {
+            EnemyInstance target = FindEnemy(request.Target);
+            if (target == null
+                || !target.HasBehavior(EnemyBehaviorFlags.RootkitMasked)
+                || !HasOtherLivingEnemy(target))
+            {
+                return amount;
+            }
+
+            if (amount <= 0)
+            {
+                return 0;
+            }
+
+            return Mathf.Max(1, Mathf.CeilToInt(amount * (EnemyArchetypeCatalog.RootkitMaskedDamagePercent / 100f)));
+        }
+
+        private bool HasOtherLivingEnemy(EnemyInstance target)
+        {
+            for (int i = 0; i < _enemies.Count; i++)
+            {
+                EnemyInstance enemy = _enemies[i];
+                if (enemy != target && enemy.State != null && !enemy.State.IsDefeated)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
        private void ResolveDelayedEndOfTurnEffects()
        {
            for (int i = _delayedEffects.Count - 1; i >= 0; i--)
@@ -37,11 +37,21 @@ namespace KernelPanic.Combat
        public const int EntropyStartWave = 5;
        public const int EntropyPerWave = 3;
        public const int StatUpgradeMaxCycles = 1;
-        public const int StatUpgradeMaxUptime = 4;
-        public const int StatUpgradeHeal = 5;
+        public const int StatUpgradeMaxUptimePercent = 20;
+        public const int StatUpgradeHealPercent = 30;
        public const int StatUpgradeRam = 1;
        public const int UpgradeMagnitudeBonus = 2;

+        public static int ScaleStatUpgradeMaxUptime(int maxUptime)
+        {
+            return System.Math.Max(1, ((System.Math.Max(1, maxUptime) * StatUpgradeMaxUptimePercent) + 99) / 100);
+        }
+
+        public static int ScaleStatUpgradeHeal(int maxUptime)
+        {
+            return System.Math.Max(1, ((System.Math.Max(1, maxUptime) * StatUpgradeHealPercent) + 99) / 100);
+        }
+
        // Combat pacing: gaps between phase transitions and per-item resolution steps so
        // players can follow drawing/queue/enemy resolution instead of seeing it all at once.
        // Skipped entirely when UIPreferences.ReducedMotion is set.
@@ -36,7 +36,7 @@ namespace KernelPanic.Combat
        public int IncomingAttackHalfCharges { get; set; }
        public int ArchBtwStacks { get; set; }
        public int ArchBtwDamagePerStack { get; set; } = 1;
-        public int ArchMakepkgBtwMultiplier { get; set; } = 2;
+        public int ArchMakepkgBtwMultiplier { get; set; } = 3;
        public int ArchRollingReleaseSavesRemaining { get; set; }
        public int ArchRollingReleaseShieldOnSave { get; set; }
        public int ArchRollingReleaseCyclesOnSave { get; set; }
@@ -11,7 +11,8 @@ namespace KernelPanic.Combat
            int amount,
            Language language,
            bool trueDamage,
-            bool canCrit)
+            bool canCrit,
+            bool applySourceModifiers = true)
        {
            Source = source;
            Target = target;
@@ -19,6 +20,7 @@ namespace KernelPanic.Combat
            Language = language;
            TrueDamage = trueDamage;
            CanCrit = canCrit;
+            ApplySourceModifiers = applySourceModifiers;
        }

        public CombatantState Source { get; }
@@ -27,6 +29,7 @@ namespace KernelPanic.Combat
        public Language Language { get; }
        public bool TrueDamage { get; }
        public bool CanCrit { get; }
+        public bool ApplySourceModifiers { get; }
    }

    public readonly struct DamageResult
@@ -56,6 +59,8 @@ namespace KernelPanic.Combat
    /// </summary>
    public sealed class DamagePipeline
    {
+        public System.Func<DamageRequest, int, int> ResistanceResolver { get; set; }
+
        public DamageResult DealDamage(DamageRequest request)
        {
            if (request.Target == null || request.Target.IsDefeated)
@@ -64,9 +69,14 @@ namespace KernelPanic.Combat
            }

            int amount = Mathf.Max(0, request.Amount);
-            amount = ApplyFlatAdditions(amount, request);
-            amount = ApplyMultipliers(amount, request);
-            amount = ApplyCrit(amount, request, out bool wasCritical);
+            bool wasCritical = false;
+            if (request.ApplySourceModifiers)
+            {
+                amount = ApplyFlatAdditions(amount, request);
+                amount = ApplyMultipliers(amount, request);
+                amount = ApplyCrit(amount, request, out wasCritical);
+            }
+
            amount = ApplyResistancesAndWeaknesses(amount, request);

            int finalAmount = ApplyShieldAndUptime(amount, request, out int absorbedAmount, out int shieldDamage, out int uptimeDamage);
@@ -86,6 +96,11 @@ namespace KernelPanic.Combat

        private static int ApplyMultipliers(int amount, DamageRequest request)
        {
+            if (amount == int.MaxValue)
+            {
+                return amount;
+            }
+
            if (request.Source != null && request.Source.IgnoreDamageMultipliers)
            {
                // Mint V1+ ignores multiplicative damage modifiers. Mint V4 still allows flat
@@ -100,6 +115,11 @@ namespace KernelPanic.Combat

        private static int ApplyFlatAdditions(int amount, DamageRequest request)
        {
+            if (amount == int.MaxValue)
+            {
+                return amount;
+            }
+
            if (request.Source != null && request.Language == Language.JavaScript)
            {
                amount += Mathf.Max(0, request.Source.JavaScriptFlatDamageBonus);
@@ -116,7 +136,7 @@ namespace KernelPanic.Combat
        private static int ApplyCrit(int amount, DamageRequest request, out bool wasCritical)
        {
            wasCritical = false;
-            if (!request.CanCrit || amount <= 0 || request.Source != null && request.Source.ForceMaxRolls)
+            if (!request.CanCrit || amount <= 0 || amount == int.MaxValue || request.Source != null && request.Source.ForceMaxRolls)
            {
                return amount;
            }
@@ -144,12 +164,12 @@ namespace KernelPanic.Combat
            target.ArchRollingReleaseRecoveredThisHit = true;
        }

-        private static int ApplyResistancesAndWeaknesses(int amount, DamageRequest request)
+        private int ApplyResistancesAndWeaknesses(int amount, DamageRequest request)
        {
            // TODO: Enemy resistances/reductions are not authored yet. Mint V5 should re-resolve
            // a once-per-combat reduced effect here once those reduction sources exist.
            // TODO: Apply enemy language resistances and weaknesses here.
-            return amount;
+            return ResistanceResolver == null ? amount : ResistanceResolver(request, amount);
        }

        private static int ApplyShieldAndUptime(int amount, DamageRequest request, out int absorbedAmount, out int shieldDamage, out int uptimeDamage)
@@ -14,7 +14,12 @@ namespace KernelPanic.Combat
        Grow = 1 << 2,
        ObfuscateIntent = 1 << 3,
        DefendAllies = 1 << 4,
-        Countdown = 1 << 5
+        Countdown = 1 << 5,
+        LeavesOrphan = 1 << 6,
+        SegfaultOnDeath = 1 << 7,
+        RacePair = 1 << 8,
+        RootkitMasked = 1 << 9,
+        Elite = 1 << 10
    }

    public sealed class EnemyArchetypeDescriptor
@@ -51,18 +56,23 @@ namespace KernelPanic.Combat
    {
        public const int ZombieReapThresholdPercent = 30;
        public const int MemoryLeakAttackGrowthPerTurn = 1;
+        public const int MemoryLeakAttackCapMin = 4;
+        public const int MemoryLeakAttackCapMax = 5;
        public const int ForkBombTotalCap = 5;
+        public const int RootkitMaskedDamagePercent = 10;
+        public const int RacePairDamageBonus = 2;
        public const int CronInitialCountdown = 2;
+        public const int SegfaultInitialCountdown = 2;

        private static readonly EnemyArchetypeDescriptor ZombieProcess = new(
            "zombie_process",
            "Zombie Process",
            6,
            10,
-            EnemyBehaviorFlags.Revive,
+            EnemyBehaviorFlags.Revive | EnemyBehaviorFlags.LeavesOrphan,
            new[]
            {
-                new EnemyIntent(EnemyIntentKind.Attack, 3, 4, Language.C, "attack", "!")
+                new EnemyIntent(EnemyIntentKind.Attack, 2, 3, Language.C, "attack", "!")
            });

        private static readonly EnemyArchetypeDescriptor MemoryLeak = new(
@@ -73,7 +83,7 @@ namespace KernelPanic.Combat
            EnemyBehaviorFlags.Grow,
            new[]
            {
-                new EnemyIntent(EnemyIntentKind.StatusAttack, 1, 1, Language.C, "leak", "!", false, StatusType.MemoryLeak, 1, CombatTuning.EnemyStatusDuration)
+                new EnemyIntent(EnemyIntentKind.StatusAttack, 1, 2, Language.C, "leak", "!", false, StatusType.MemoryLeak, 1, CombatTuning.EnemyStatusDuration)
            });

        private static readonly EnemyArchetypeDescriptor ForkBomb = new(
@@ -81,10 +91,10 @@ namespace KernelPanic.Combat
            "Fork Bomb",
            3,
            5,
-            EnemyBehaviorFlags.Split,
+            EnemyBehaviorFlags.Split | EnemyBehaviorFlags.LeavesOrphan,
            new[]
            {
-                new EnemyIntent(EnemyIntentKind.Special, 0, 0, Language.C, "fork", ":", false, StatusType.MemoryLeak, 0, -1, "split")
+                new EnemyIntent(EnemyIntentKind.Attack, 1, 2, Language.C, "fork hit", "!")
            });

        private static readonly EnemyArchetypeDescriptor Daemon = new(
@@ -92,7 +102,7 @@ namespace KernelPanic.Combat
            "Daemon",
            10,
            14,
-            EnemyBehaviorFlags.ObfuscateIntent,
+            EnemyBehaviorFlags.ObfuscateIntent | EnemyBehaviorFlags.Elite,
            new[]
            {
                new EnemyIntent(EnemyIntentKind.Attack, 6, 8, Language.C, "daemon hit", "!")
@@ -108,7 +118,7 @@ namespace KernelPanic.Combat
            {
                new EnemyIntent(EnemyIntentKind.Defend, 3, 5, Language.C, "shield adjacent", "#"),
                new EnemyIntent(EnemyIntentKind.Defend, 3, 5, Language.C, "shield adjacent", "#"),
-                new EnemyIntent(EnemyIntentKind.Attack, 1, 2, Language.C, "poke", "!")
+                new EnemyIntent(EnemyIntentKind.Attack, 0, 1, Language.C, "poke", "!")
            });

        private static readonly EnemyArchetypeDescriptor CronJob = new(
@@ -122,6 +132,50 @@ namespace KernelPanic.Combat
                new EnemyIntent(EnemyIntentKind.Attack, 10, 12, Language.C, "cron fire", "@")
            });

+        private static readonly EnemyArchetypeDescriptor OrphanProcess = new(
+            "orphan_process",
+            "Orphan Process",
+            2,
+            4,
+            EnemyBehaviorFlags.None,
+            new[]
+            {
+                new EnemyIntent(EnemyIntentKind.Attack, 1, 2, Language.C, "orphan chip", ".")
+            });
+
+        private static readonly EnemyArchetypeDescriptor Segfault = new(
+            "segfault",
+            "Segfault",
+            2,
+            4,
+            EnemyBehaviorFlags.SegfaultOnDeath,
+            new[]
+            {
+                new EnemyIntent(EnemyIntentKind.Attack, 2, 3, Language.C, "unstable hit", "!")
+            });
+
+        private static readonly EnemyArchetypeDescriptor RaceCondition = new(
+            "race_condition",
+            "Race Condition",
+            5,
+            7,
+            EnemyBehaviorFlags.RacePair,
+            new[]
+            {
+                new EnemyIntent(EnemyIntentKind.Attack, 2, 3, Language.C, "racy strike", "~")
+            });
+
+        private static readonly EnemyArchetypeDescriptor Rootkit = new(
+            "rootkit",
+            "Rootkit",
+            14,
+            18,
+            EnemyBehaviorFlags.RootkitMasked,
+            new[]
+            {
+                new EnemyIntent(EnemyIntentKind.Attack, 1, 2, Language.C, "masked hit", "?")
+            });
+
        public static EnemyArchetypeDescriptor Get(string id)
        {
            return id switch
@@ -131,6 +185,10 @@ namespace KernelPanic.Combat
                "daemon" => Daemon,
                "firewalld" => Defender,
                "cron_job" => CronJob,
+                "orphan_process" => OrphanProcess,
+                "segfault" => Segfault,
+                "race_condition" => RaceCondition,
+                "rootkit" => Rootkit,
                _ => ZombieProcess
            };
        }
@@ -24,7 +24,9 @@ namespace KernelPanic.Combat
                _intentPool.AddRange(Archetype.IntentPool);
            }

-            CountdownRemaining = HasBehavior(EnemyBehaviorFlags.Countdown) ? EnemyArchetypeCatalog.CronInitialCountdown : 0;
+            CountdownRemaining = HasBehavior(EnemyBehaviorFlags.Countdown)
+                ? EnemyArchetypeCatalog.CronInitialCountdown
+                : HasBehavior(EnemyBehaviorFlags.SegfaultOnDeath) ? EnemyArchetypeCatalog.SegfaultInitialCountdown : 0;
        }

        public string Name { get; }
@@ -42,7 +44,16 @@ namespace KernelPanic.Combat
        public bool PendingRevive { get; private set; }
        public bool Reaped { get; private set; }
        public bool LethalHitThisTurn { get; private set; }
+        public int PairId { get; private set; } = -1;
+        public int RaceEnrageStacks { get; private set; }
+        public bool SpawnedFromDeath { get; private set; }
        public bool HasPendingMarker => PendingRevive || HasRevived;
+        public bool HasSpecialSignal => HasSplitSignal || HasSegfaultSignal || HasRaceSignal || HasRootkitSignal || HasEliteSignal || SpawnedFromDeath;
+        public bool HasSplitSignal => HasBehavior(EnemyBehaviorFlags.Split);
+        public bool HasSegfaultSignal => HasBehavior(EnemyBehaviorFlags.SegfaultOnDeath);
+        public bool HasRaceSignal => HasBehavior(EnemyBehaviorFlags.RacePair);
+        public bool HasRootkitSignal => HasBehavior(EnemyBehaviorFlags.RootkitMasked);
+        public bool HasEliteSignal => HasBehavior(EnemyBehaviorFlags.Elite);
        public EnemyIntent DisplayIntent => BuildDisplayIntent();

        public void PickNextIntent()
@@ -61,6 +72,12 @@ namespace KernelPanic.Combat
                return;
            }

+            if (HasBehavior(EnemyBehaviorFlags.SegfaultOnDeath) && CountdownRemaining > 0)
+            {
+                CurrentIntent = new EnemyIntent(EnemyIntentKind.Special, CountdownRemaining, CountdownRemaining, KernelPanic.Core.Language.C, "segfault in", "!");
+                return;
+            }
+
            if (_intentPool.Count == 0)
            {
                CurrentIntent = default;
@@ -72,7 +89,9 @@ namespace KernelPanic.Combat
            if (HasBehavior(EnemyBehaviorFlags.Grow))
            {
                int growth = TurnsAlive * EnemyArchetypeCatalog.MemoryLeakAttackGrowthPerTurn;
-                CurrentIntent = CurrentIntent.WithValues(CurrentIntent.MinValue + growth, CurrentIntent.MaxValue + growth, "growing leak");
+                int minValue = UnityEngine.Mathf.Min(CurrentIntent.MinValue + growth, EnemyArchetypeCatalog.MemoryLeakAttackCapMin);
+                int maxValue = UnityEngine.Mathf.Min(CurrentIntent.MaxValue + growth, EnemyArchetypeCatalog.MemoryLeakAttackCapMax);
+                CurrentIntent = CurrentIntent.WithValues(minValue, maxValue, "growing leak");
            }
        }

@@ -94,6 +113,21 @@ namespace KernelPanic.Combat
            TurnsAlive++;
        }

+        public void SetPairId(int pairId)
+        {
+            PairId = pairId;
+        }
+
+        public void MarkSpawnedFromDeath()
+        {
+            SpawnedFromDeath = true;
+        }
+
+        public void EnrageRaceSurvivor()
+        {
+            RaceEnrageStacks++;
+        }
+
        public void ResetTurnLethalMarker()
        {
            LethalHitThisTurn = false;
@@ -142,6 +176,14 @@ namespace KernelPanic.Combat
                : UnityEngine.Mathf.Max(0, CountdownRemaining - 1);
        }

+        public void AdvanceSegfaultCountdown()
+        {
+            if (HasBehavior(EnemyBehaviorFlags.SegfaultOnDeath))
+            {
+                CountdownRemaining = UnityEngine.Mathf.Max(0, CountdownRemaining - 1);
+            }
+        }
+
        private EnemyIntent BuildDisplayIntent()
        {
            if (PendingRevive)
@@ -13,7 +13,7 @@ namespace KernelPanic.Combat
        private static readonly Dictionary<StatusType, StatusDescriptor> Descriptors = new()
        {
            [StatusType.MemoryLeak] = new(StatusType.MemoryLeak, "Memory Leak", "leak", false, StatusStackingRule.Intensity, StatusTickTiming.StartOfTurn, "Takes damage equal to stacks at start of turn."),
-            [StatusType.Segfault] = new(StatusType.Segfault, "Segfault", "segv", false, StatusStackingRule.Unique, StatusTickTiming.StartOfTurn, "Loses one cycle this turn. TODO: lock a random card slot."),
+            [StatusType.Segfault] = new(StatusType.Segfault, "Segfault", "segv", false, StatusStackingRule.Unique, StatusTickTiming.StartOfTurn, "Loses one cycle this turn. Segfault events corrupt a random hand card until fixed."),
            [StatusType.RaceCondition] = new(StatusType.RaceCondition, "Race Condition", "race", false, StatusStackingRule.Refresh, StatusTickTiming.None, "Randomizes multi-target resolution order where supported."),
            [StatusType.Deprecated] = new(StatusType.Deprecated, "Deprecated", "dep", false, StatusStackingRule.Duration, StatusTickTiming.StartOfTurn, "A temporary positive value decays. Currently reduces shield by 1."),
            [StatusType.DependencyError] = new(StatusType.DependencyError, "Dependency Error", "deps", false, StatusStackingRule.Unique, StatusTickTiming.None, "Registered for off-support card cost rules. TODO: connect draw-time cost path."),