Merge branch 'enemy-upgrades'

Assets/_Project/Scripts/Gameplay/EnemyAbilities.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 1c918164b61faf1d5af9f782c5237a60
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityDefinition.cs

@@ -0,0 +1,55 @@
+// Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityDefinition.cs
+using UnityEngine;
+using TD.Core;
+
+namespace TD.Gameplay.EnemyAbilities
+{
+    /// <summary>
+    /// Base class for one enemy ability (e.g. "split into smaller enemies on death"). Rolled
+    /// at random for each spawned enemy by <see cref="EnemyAbilityPool.RollRandom"/> and applied
+    /// via <see cref="EnemyAbility.InitializeServer"/>.
+    /// </summary>
+    /// <remarks>
+    /// <para><b>One asset per kind.</b> <see cref="Kind"/> is fixed per subclass, same as
+    /// <see cref="BuilderSpells.BuilderSpellDefinition"/>. <see cref="EnemyAbilityPool"/> uses
+    /// it to build a fixed-size, enum-indexed lookup table.</para>
+    ///
+    /// <para><b>Server-only hooks.</b> All three hooks below only ever run on the server —
+    /// <see cref="EnemyAbility"/> only calls them when <c>IsServer</c> is true. <see
+    /// cref="ServerOnSpawn"/> and <see cref="ServerTick"/> are no-ops for abilities that don't
+    /// need spawn-time setup or a per-frame timer (e.g. Split on Death uses neither); they exist
+    /// so a future cooldown-driven ability (disable towers, teleport) doesn't need a base-class
+    /// change.</para>
+    /// </remarks>
+    public abstract class EnemyAbilityDefinition : ScriptableObject
+    {
+        /// <summary>Which enemy ability this asset's data belongs to.</summary>
+        public abstract EnemyAbilityKind Kind { get; }
+
+        [Header("Presentation")]
+        [Tooltip("Name shown in debug logs and future enemy-info UI.")]
+        public string DisplayName;
+
+        [Tooltip("Short description shown in future enemy-info UI.")]
+        [TextArea(2, 4)]
+        public string Description;
+
+        [Header("Selection")]
+        [Tooltip("Relative weight of this ability being rolled, vs. the pool's other abilities " +
+                 "and its no-ability chance. Same semantics as DraftOption.Weight.")]
+        [Min(0f)]
+        public float Weight = 1f;
+
+        /// <summary>Server-only: called once, right after this ability is assigned (before the
+        /// enemy's NetworkObject is spawned to clients). Default no-op.</summary>
+        public virtual void ServerOnSpawn(EnemyAbility instance) { }
+
+        /// <summary>Server-only: called every frame this ability is active on a live enemy.
+        /// Default no-op.</summary>
+        public virtual void ServerTick(EnemyAbility instance, float dt) { }
+
+        /// <summary>Server-only: called the instant the enemy's HP reaches zero, before the
+        /// death animation/despawn sequence plays. Default no-op.</summary>
+        public virtual void ServerOnDeath(EnemyAbility instance, EnemyHealth health) { }
+    }
+}

Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityDefinition.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 855f7f0848d3086868816d25295fcdd6

Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs

@@ -0,0 +1,102 @@
+// Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs
+using System;
+using UnityEngine;
+using TD.Core;
+
+namespace TD.Gameplay.EnemyAbilities
+{
+    /// <summary>
+    /// Scene singleton holding every <see cref="EnemyAbilityDefinition"/> available this match,
+    /// authored as a flat array in the inspector for convenience. Internally it builds a
+    /// fixed-size table indexed by <see cref="EnemyAbilityKind"/> so lookups are a single array
+    /// access, not a scan. Mirrors <see cref="BuilderSpells.BuilderSpellPool"/> exactly.
+    /// </summary>
+    /// <remarks>
+    /// Plain MonoBehaviour: identical on every peer (same assets), so there is nothing to sync.
+    /// Only the server calls <see cref="RollRandom"/> (at enemy spawn time, in
+    /// <c>WaveManager.SpawnEnemy</c>).
+    /// </remarks>
+    public class EnemyAbilityPool : MonoBehaviour
+    {
+        public static EnemyAbilityPool Instance { get; private set; }
+
+        [Tooltip("Every EnemyAbilityDefinition asset available this match. One entry per " +
+                 "EnemyAbilityKind — order doesn't matter, Kind on the asset itself decides " +
+                 "its slot.")]
+        [SerializeField] private EnemyAbilityDefinition[] abilities;
+
+        [Tooltip("Relative weight of an enemy rolling no ability at all, vs. the combined " +
+                 "weight of every entry in 'abilities'. Higher = abilities are rarer.")]
+        [Min(0f)]
+        [SerializeField] private float noAbilityWeight = 100f;
+
+        // Fixed-size, enum-indexed lookup built once in Awake. Sized to the enum's entry count,
+        // not authored count, so an out-of-range Kind is a compile-time impossibility rather
+        // than a bounds check we'd otherwise need on every Get().
+        private EnemyAbilityDefinition[] byKind;
+
+        private void Awake()
+        {
+            if (Instance != null && Instance != this)
+            {
+                Debug.LogError("[EnemyAbilityPool] Multiple instances detected. Only one per scene.");
+                return;
+            }
+            Instance = this;
+
+            int kindCount = Enum.GetValues(typeof(EnemyAbilityKind)).Length;
+            byKind = new EnemyAbilityDefinition[kindCount];
+            if (abilities == null) return;
+
+            for (int i = 0; i < abilities.Length; i++)
+            {
+                var def = abilities[i];
+                if (def == null) continue;
+                byKind[(int)def.Kind] = def;
+            }
+        }
+
+        private void OnDestroy()
+        {
+            if (Instance == this) Instance = null;
+        }
+
+        /// <summary>Returns the ability asset for <paramref name="kind"/>, or null if none is
+        /// authored in this pool.</summary>
+        public EnemyAbilityDefinition Get(EnemyAbilityKind kind)
+        {
+            int i = (int)kind;
+            return (byKind != null && i >= 0 && i < byKind.Length) ? byKind[i] : null;
+        }
+
+        /// <summary>
+        /// Server-only: weighted random draw across every authored ability plus the
+        /// no-ability bucket. Returns null when "no ability" is drawn, or when the pool has
+        /// nothing authored.
+        /// </summary>
+        public EnemyAbilityDefinition RollRandom()
+        {
+            if (abilities == null || abilities.Length == 0) return null;
+
+            float total = noAbilityWeight;
+            for (int i = 0; i < abilities.Length; i++)
+                if (abilities[i] != null) total += abilities[i].Weight;
+
+            if (total <= 0f) return null;
+
+            float roll = UnityEngine.Random.Range(0f, total);
+            if (roll < noAbilityWeight) return null;
+            roll -= noAbilityWeight;
+
+            for (int i = 0; i < abilities.Length; i++)
+            {
+                var def = abilities[i];
+                if (def == null) continue;
+                if (roll < def.Weight) return def;
+                roll -= def.Weight;
+            }
+
+            return null;
+        }
+    }
+}

Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4409eb25a8be555de8dc3a73d4ed95db

Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs

@@ -0,0 +1,52 @@
+// Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs
+using UnityEngine;
+using TD.Core;
+
+namespace TD.Gameplay.EnemyAbilities
+{
+    /// <summary>
+    /// On death, spawns <see cref="SplitCount"/> smaller copies of the dying enemy's own type at
+    /// the corpse's position, continuing on toward the goal instead of restarting from the wave's
+    /// spawner. There's no separate "minion" EnemyDefinition to author — the mini copies reuse
+    /// whichever EnemyDefinition/prefab the dying enemy itself was spawned from, scaled down by
+    /// <see cref="HpMultiplier"/>/<see cref="ScaleMultiplier"/>.
+    /// </summary>
+    [CreateAssetMenu(fileName = "SplitOnDeathAbility", menuName = "TD/Enemy Abilities/Split On Death")]
+    public class SplitOnDeathAbilityDefinition : EnemyAbilityDefinition
+    {
+        public override EnemyAbilityKind Kind => EnemyAbilityKind.SplitOnDeath;
+
+        [Header("Split")]
+        [Tooltip("How many mini copies spawn on death.")]
+        [Min(1)]
+        public int SplitCount = 2;
+
+        [Tooltip("Each mini copy's MaxHp = the dying enemy's own MaxHp * this multiplier.")]
+        [Range(0.01f, 1f)]
+        public float HpMultiplier = 0.5f;
+
+        [Tooltip("Uniform transform scale applied to each mini copy, relative to the normal " +
+                 "prefab scale. Requires the enemy prefab's NetworkTransform to sync scale, " +
+                 "or the mini will render full-size on remote peers.")]
+        [Range(0.1f, 1f)]
+        public float ScaleMultiplier = 0.6f;
+
+        [Tooltip("Random scatter radius (world units) applied to each split spawn so they don't " +
+                 "spawn exactly on top of each other.")]
+        [Min(0f)]
+        public float ScatterRadius = 0.5f;
+
+        public override void ServerOnDeath(EnemyAbility instance, EnemyHealth health)
+        {
+            var def = health.Definition;
+            if (def == null) return;
+
+            var movement = instance.GetComponent<EnemyMovement>();
+            var atTile = GridCoordinates.WorldToGrid(instance.transform.position);
+            var ownerSlot = movement != null ? movement.OriginZone : PlayerSlot.None;
+
+            WaveManager.Instance?.ServerSpawnSplitEnemies(
+                def, SplitCount, atTile, ownerSlot, ScatterRadius, HpMultiplier, ScaleMultiplier);
+        }
+    }
+}

Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 21543cb1b54f0b16e9c80584f68988b3

Assets/_Project/Scripts/Gameplay/EnemyAbility.cs

@@ -0,0 +1,87 @@
+// Assets/_Project/Scripts/Gameplay/EnemyAbility.cs
+using Unity.Netcode;
+using UnityEngine;
+using TD.Core;
+using TD.Gameplay.EnemyAbilities;
+
+namespace TD.Gameplay
+{
+    /// <summary>
+    /// Per-enemy ability slot. Holds the <see cref="EnemyAbilityDefinition"/> rolled for this
+    /// instance (if any) and drives its server-only hooks.
+    /// </summary>
+    /// <remarks>
+    /// <b>Initialization:</b> Call <see cref="InitializeServer"/> on the server immediately after
+    /// <c>Instantiate</c> and before <c>NetworkObject.Spawn()</c>, following the same pattern as
+    /// <c>EnemyHealth.InitializeServer</c> / <c>EnemyMovement.InitializeServer</c>.
+    ///
+    /// <b>Optional component:</b> Not required by <c>EnemyHealth</c> or <c>EnemyMovement</c> —
+    /// <c>WaveManager.SpawnEnemy</c> only rolls and assigns an ability when this component is
+    /// present on the prefab, so existing enemy prefabs are unaffected until it's added to them.
+    ///
+    /// <b>On-death hook is not event-driven:</b> <c>WaveManager.HandleEnemyKilled</c> calls
+    /// <see cref="EnemyAbilityDefinition.ServerOnDeath"/> directly (via <see cref="Definition"/>)
+    /// rather than this component subscribing to <c>EnemyHealth.OnDied</c> itself — that keeps a
+    /// split-spawn's <c>activeEnemyCount</c> increment ordered before the triggering kill's
+    /// decrement, regardless of NetworkBehaviour subscription order.
+    /// </remarks>
+    [RequireComponent(typeof(NetworkObject))]
+    public class EnemyAbility : NetworkBehaviour
+    {
+        private readonly NetworkVariable<byte> kind = new NetworkVariable<byte>(
+            (byte)EnemyAbilityKind.None,
+            NetworkVariableReadPermission.Everyone,
+            NetworkVariableWritePermission.Server);
+
+        // ----- Pre-spawn init (server-local) ----------------------------------
+
+        private EnemyAbilityDefinition pendingDefinition;
+        private bool                   hasPendingInit;
+
+        // ----- Public state -----------------------------------------------------
+
+        /// <summary>The ability rolled for this enemy, or null if none was rolled.</summary>
+        public EnemyAbilityDefinition Definition { get; private set; }
+
+        /// <summary>Replicated kind of the rolled ability. <see cref="EnemyAbilityKind.None"/> if
+        /// none was rolled.</summary>
+        public EnemyAbilityKind Kind => (EnemyAbilityKind)kind.Value;
+
+        // ----- Server-only pre-spawn init -------------------------------------
+
+        /// <summary>
+        /// Called by <c>WaveManager</c> on the server after <c>Instantiate</c> and before
+        /// <c>NetworkObject.Spawn()</c>. <paramref name="definition"/> may be null, meaning no
+        /// ability was rolled for this enemy.
+        /// </summary>
+        public void InitializeServer(EnemyAbilityDefinition definition)
+        {
+            pendingDefinition = definition;
+            hasPendingInit    = true;
+        }
+
+        // ----- NGO lifecycle --------------------------------------------------
+
+        public override void OnNetworkSpawn()
+        {
+            if (!IsServer || !hasPendingInit) return;
+
+            Definition     = pendingDefinition;
+            kind.Value     = (byte)(Definition != null ? Definition.Kind : EnemyAbilityKind.None);
+            hasPendingInit = false;
+
+            if (Definition != null)
+                Debug.Log($"[EnemyAbility] {name} rolled {Definition.Kind}.");
+
+            Definition?.ServerOnSpawn(this);
+        }
+
+        // ----- Server tick ------------------------------------------------
+
+        private void Update()
+        {
+            if (!IsServer || Definition == null) return;
+            Definition.ServerTick(this, Time.deltaTime);
+        }
+    }
+}

Assets/_Project/Scripts/Gameplay/EnemyAbility.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9d1a26a32e8969cd29bce6010126a5f6

Assets/_Project/Scripts/Gameplay/EnemyMovement.cs

@@ -73,6 +73,11 @@ namespace TD.Gameplay
         // the goal). Without this, every zone crossing was counted as a leak; only
         // the originating player should be credited a leak per the design.
         private PlayerSlot        originZone    = PlayerSlot.None;
+
+        /// <summary>The zone (player) this enemy was originally spawned for — see
+        /// <see cref="InitializeServer"/>. Used by on-death abilities (e.g. Split on Death) so
+        /// spawned children preserve the same leak attribution as their parent.</summary>
+        public PlayerSlot OriginZone => originZone;
         // Latches once the enemy has crossed its origin zone's leak volume, so we
         // never double-count a leak if the enemy re-enters its origin (rare but
         // possible if pathing is dynamic).

Assets/_Project/Scripts/Gameplay/WaveManager.cs

@@ -5,6 +5,7 @@ using UnityEngine;
 using TD.Core;
 using TD.Gameplay.BuilderEffects;
 using TD.Gameplay.Draft;
+using TD.Gameplay.EnemyAbilities;
 using TD.Levels;
 using TD.UI;
 
@@ -456,7 +457,8 @@ namespace TD.Gameplay
 
         private void SpawnEnemy(EnemyDefinition def, Vector2Int spawnerTile, PlayerSlot ownerSlot,
                                 float xHalfExtent = 0f, float zHalfExtent = 0f, bool held = false,
-                                Direction facing = Direction.South)
+                                Direction facing = Direction.South, bool canRollAbility = true,
+                                float hpMultiplier = 1f, float visualScale = 1f)
         {
             if (def.EnemyPrefab == null)
             {
@@ -490,6 +492,12 @@ namespace TD.Gameplay
                 spawnPos,
                 Quaternion.Euler(0f, yaw, 0f));
 
+            // Scales the whole prefab hierarchy uniformly (used for split-on-death minions).
+            // Relies on the enemy prefab's NetworkTransform syncing scale to clients — verify
+            // that's enabled if a scaled spawn doesn't look smaller on remote peers.
+            if (visualScale != 1f)
+                go.transform.localScale *= visualScale;
+
             var health   = go.GetComponent<EnemyHealth>();
             var movement = go.GetComponent<EnemyMovement>();
 
@@ -501,8 +509,17 @@ namespace TD.Gameplay
                 return;
             }
 
-            health.InitializeServer(def.MaxHp, def.LivesCost, def.IsFlying, held);
+            health.InitializeServer(def.MaxHp * hpMultiplier, def.LivesCost, def.IsFlying, held);
             movement.InitializeServer(def.MoveSpeed, spawnerTile, ownerSlot, def.IsFlying);
+
+            // Optional — only prefabs with an EnemyAbility component roll an ability. See
+            // EnemyAbility's remarks for why on-death abilities aren't event-subscription driven.
+            // canRollAbility is false for split-spawned minions (see ServerSpawnSplitEnemies) so
+            // they can never chain into further splits or pick up any other ability.
+            var ability = go.GetComponent<EnemyAbility>();
+            if (ability != null)
+                ability.InitializeServer(canRollAbility ? EnemyAbilityPool.Instance?.RollRandom() : null);
+
             if (held) heldEnemies.Add(health);
 
             health.OnDied         += HandleEnemyKilled;
@@ -514,6 +531,29 @@ namespace TD.Gameplay
             go.GetComponent<NetworkObject>().Spawn();
         }
 
+        /// <summary>
+        /// Server-only: spawns <paramref name="count"/> copies of <paramref name="def"/> at
+        /// <paramref name="atTile"/>, continuing that tile's A* path onward rather than
+        /// restarting from a wave spawner. Used by on-death abilities (e.g.
+        /// <c>SplitOnDeathAbilityDefinition</c>) to spawn smaller enemies from a corpse's
+        /// position. Reuses <see cref="SpawnEnemy"/> so split children get the same
+        /// <c>activeEnemyCount</c>/event-wiring bookkeeping as any other spawn.
+        /// </summary>
+        /// <remarks>
+        /// Split-spawned minions never roll an ability of their own — they're always plain,
+        /// so a split can't chain into further splits (or any other ability) regardless of
+        /// which EnemyDefinition/prefab is used for <paramref name="def"/>.
+        /// </remarks>
+        public void ServerSpawnSplitEnemies(EnemyDefinition def, int count, Vector2Int atTile,
+                                            PlayerSlot ownerSlot, float scatterRadius,
+                                            float hpMultiplier = 1f, float visualScale = 1f)
+        {
+            if (!IsServer) return;
+            for (int i = 0; i < count; i++)
+                SpawnEnemy(def, atTile, ownerSlot, scatterRadius, scatterRadius, canRollAbility: false,
+                          hpMultiplier: hpMultiplier, visualScale: visualScale);
+        }
+
         // ----- Enemy event handlers (server-only) -------------------------
 
         private void HandleEnemyKilled(EnemyHealth health)
@@ -551,6 +591,13 @@ namespace TD.Gameplay
             if (totalReward > 0)
                 ShowGoldRewardClientRpc(health.transform.position, totalReward);
 
+            // Resolve any on-death ability BEFORE unsubscribing/decrementing. A split-spawn's
+            // activeEnemyCount++ (inside ServerSpawnSplitEnemies -> SpawnEnemy) must land before
+            // this kill's activeEnemyCount-- below, or a split on a wave's last enemy could let
+            // CheckWaveComplete see activeEnemyCount hit 0 and advance the wave prematurely.
+            var ability = health.GetComponent<EnemyAbility>();
+            ability?.Definition?.ServerOnDeath(ability, health);
+
             UnsubscribeEnemy(health);
             DecrementAndCheckComplete();
         }