Base<->Expedition ties: portal rooms, class-at-base, prep spend + Health.Max, C3/C4/Spitter (DR-046)

Portal-gated rooms: new RunLifecycle.RoomExplore loot window; room+nodes persist past the last kill; PortalInteractRequest -> server-only PortalCommand advances (client derives the portal pos). RunDirectorSystem moves teardown off the InRoom edge, relocates the boss-branch/route-gate into the RoomExplore exit, and advances an empty expedition immediately (incl. a boss clear). Class-at-base via a shared ClassSwapUtil (meta-band strip + per-class MetaTierState replay, so the base RPC and the dev SetClass can't drift); ClassSelectRequest Staging-gated. Per-run PREP buffs (PrepPurchaseRequest, PrepCatalog): once-per-run == the row's prep StatModifier band is present, TotalOf-before-Withdraw atomic, stripped on Returning beside the boon band. Health.Max promoted to [GhostField] (the one ghost-hash re-bake) so the boss + floating enemy HP bars read it directly. Feel: melee cone connect-thunk (C3), hit-stop throttle so a horde wipe can't stutter (C4), Spitter cornered-hold. 456/456 EditMode; two adversarial reviews (pre-code 13-confirmed folded; post-impl clean bar the RoomExplore boss-clear dead-time, fixed). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-06 10:37:24 -07:00
parent 35357faa7a
commit 304ee8c2a7
35 changed files with 860 additions and 110 deletions
@@ -0,0 +1,65 @@
+using Unity.Entities;
+
+namespace ProjectM.Simulation
+{
+    /// <summary>
+    /// The ONE in-place class-swap effect, shared by the editor dev tool (DebugOp.SetClass) and the player-facing
+    /// base ClassSelect (Staging). A class swap is much more than re-seeding: the pre-code review (DR-046) confirmed
+    /// that swapping only the class-seed band leaves the OLD class's PERMANENT META rows on the buffer and omits the
+    /// NEW class's — so a base swap would drain Aether into the wrong class's record and mis-set Max HP. This helper
+    /// mirrors the (previously editor-only) full swap: <see cref="ClassTraits.Reapply"/> (class-seed band) + the meta
+    /// band strip + per-class <see cref="MetaTierState"/> replay. The caller then writes AbilityRef/PlayerClass/
+    /// AbilityCooldown and calls <see cref="HealClamp"/> (a static can't resolve singletons or SystemAPI.SetComponent,
+    /// so the caller passes the resolved pieces). Server-authoritative + prediction-correct (StatRecomputeSystem
+    /// refolds EffectiveCharacterStats next tick).
+    /// </summary>
+    public static class ClassSwapUtil
+    {
+        /// <summary>Re-seed the class band + re-sync the permanent-meta band for <paramref name="rawClass"/> on
+        /// <paramref name="mods"/>. Returns the normalized class + its Fire ability id (the caller sets AbilityRef).
+        /// <paramref name="haveMeta"/> false (no catalog/record) skips the meta replay (the strip still runs).</summary>
+        public static void Apply(byte rawClass, DynamicBuffer<StatModifier> mods,
+            bool haveMeta, in MetaUpgradeCatalog metaCat, DynamicBuffer<MetaTierState> metaRecord,
+            out byte newClass, out byte newAbilityId)
+        {
+            newClass = ClassTraits.Normalize(rawClass);
+            ClassTraits.Reapply(newClass, mods);
+            newAbilityId = ClassTraits.AbilityFor(newClass);
+
+            // Strip the OLD class's meta rows (Reapply only touched the class-seed band), then replay the NEW class's
+            // persisted tiers (the GoInGame skip/clamp rules) so the permanent channel stays correct across the swap.
+            TimedModifierUtil.RemoveBySourceIdRange(mods, Tuning.MetaSourceIdBase,
+                Tuning.MetaSourceIdBase + Tuning.MetaSourceIdSpan);
+            if (haveMeta && metaCat.Value.IsCreated && metaRecord.IsCreated)
+            {
+                ref var metaPool = ref metaCat.Value.Value;
+                byte metaBit = BoonMath.MaskFor(newClass);
+                for (int mi = 0; mi < metaRecord.Length; mi++)
+                {
+                    if (metaRecord[mi].ClassId != newClass || metaRecord[mi].Tier == 0) continue;
+                    int defIdx = MetaMath.FindDef(ref metaPool, metaRecord[mi].UpgradeId);
+                    if (defIdx < 0) continue;
+                    if ((metaPool.Defs[defIdx].ClassMask & metaBit) == 0) continue;
+                    byte metaTier = metaRecord[mi].Tier < metaPool.Defs[defIdx].MaxTier
+                        ? metaRecord[mi].Tier : metaPool.Defs[defIdx].MaxTier;
+                    mods.Add(new StatModifier
+                    {
+                        Target = metaPool.Defs[defIdx].Target,
+                        Op = metaPool.Defs[defIdx].Op,
+                        Value = metaPool.Defs[defIdx].ValuePerTier * metaTier,
+                        SourceId = Tuning.MetaSourceIdBase + metaRecord[mi].UpgradeId,
+                    });
+                }
+            }
+        }
+
+        /// <summary>Heal/down-clamp a LIVING player's Current to the new class's full max (blob base folded with the
+        /// just-reseeded <paramref name="mods"/>, like StatRecomputeSystem). Doubles as the down-clamp when the new
+        /// class's max is lower (Warrior +30 HP vs Ranger -15%). No-op on a corpse (Current&lt;=0) — respawn refills.</summary>
+        public static void HealClamp(ref Health health, float baseMaxHealth, DynamicBuffer<StatModifier> mods)
+        {
+            if (health.Current > 0f)
+                health.Current = StatMath.Apply(baseMaxHealth, StatTarget.MaxHealth, mods);
+        }
+    }
+}