diff --git a/Assets/_Project/Scripts/Core/EnemyAbilityKind.cs b/Assets/_Project/Scripts/Core/EnemyAbilityKind.cs new file mode 100644 index 0000000..3bc7bd1 --- /dev/null +++ b/Assets/_Project/Scripts/Core/EnemyAbilityKind.cs @@ -0,0 +1,16 @@ +namespace TD.Core +{ + /// + /// Identifies which enemy ability a + /// represents. Mirrors + /// — a stable, enum-indexed identifier used by + /// instead of an asset reference. + /// + public enum EnemyAbilityKind : byte + { + /// No ability rolled. Never a real pool entry — only the sentinel value + /// reports before/absent a roll. + None = 0, + SplitOnDeath = 1, + } +} diff --git a/Assets/_Project/Scripts/Core/EnemyAbilityKind.cs.meta b/Assets/_Project/Scripts/Core/EnemyAbilityKind.cs.meta new file mode 100644 index 0000000..18dd995 --- /dev/null +++ b/Assets/_Project/Scripts/Core/EnemyAbilityKind.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: ec52a6b404fed65dfa48a63b5535373d \ No newline at end of file diff --git a/Assets/_Project/Scripts/Gameplay/EnemyAbilities.meta b/Assets/_Project/Scripts/Gameplay/EnemyAbilities.meta new file mode 100644 index 0000000..099a1ab --- /dev/null +++ b/Assets/_Project/Scripts/Gameplay/EnemyAbilities.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 1c918164b61faf1d5af9f782c5237a60 +folderAsset: yes +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityDefinition.cs b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityDefinition.cs new file mode 100644 index 0000000..349b0ee --- /dev/null +++ b/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 +{ + /// + /// Base class for one enemy ability (e.g. "split into smaller enemies on death"). Rolled + /// at random for each spawned enemy by and applied + /// via . + /// + /// + /// One asset per kind. is fixed per subclass, same as + /// . uses + /// it to build a fixed-size, enum-indexed lookup table. + /// + /// Server-only hooks. All three hooks below only ever run on the server — + /// only calls them when IsServer is true. and 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. + /// + public abstract class EnemyAbilityDefinition : ScriptableObject + { + /// Which enemy ability this asset's data belongs to. + 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; + + /// Server-only: called once, right after this ability is assigned (before the + /// enemy's NetworkObject is spawned to clients). Default no-op. + public virtual void ServerOnSpawn(EnemyAbility instance) { } + + /// Server-only: called every frame this ability is active on a live enemy. + /// Default no-op. + public virtual void ServerTick(EnemyAbility instance, float dt) { } + + /// Server-only: called the instant the enemy's HP reaches zero, before the + /// death animation/despawn sequence plays. Default no-op. + public virtual void ServerOnDeath(EnemyAbility instance, EnemyHealth health) { } + } +} diff --git a/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityDefinition.cs.meta b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityDefinition.cs.meta new file mode 100644 index 0000000..b94f8dd --- /dev/null +++ b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityDefinition.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 855f7f0848d3086868816d25295fcdd6 \ No newline at end of file diff --git a/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs new file mode 100644 index 0000000..cc9270e --- /dev/null +++ b/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 +{ + /// + /// Scene singleton holding every available this match, + /// authored as a flat array in the inspector for convenience. Internally it builds a + /// fixed-size table indexed by so lookups are a single array + /// access, not a scan. Mirrors exactly. + /// + /// + /// Plain MonoBehaviour: identical on every peer (same assets), so there is nothing to sync. + /// Only the server calls (at enemy spawn time, in + /// WaveManager.SpawnEnemy). + /// + 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 = 20f; + + // 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; + } + + /// Returns the ability asset for , or null if none is + /// authored in this pool. + public EnemyAbilityDefinition Get(EnemyAbilityKind kind) + { + int i = (int)kind; + return (byKind != null && i >= 0 && i < byKind.Length) ? byKind[i] : null; + } + + /// + /// 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. + /// + 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; + } + } +} diff --git a/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs.meta b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs.meta new file mode 100644 index 0000000..a951ada --- /dev/null +++ b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/EnemyAbilityPool.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 4409eb25a8be555de8dc3a73d4ed95db \ No newline at end of file diff --git a/Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs new file mode 100644 index 0000000..364e16b --- /dev/null +++ b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs @@ -0,0 +1,40 @@ +// Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs +using UnityEngine; +using TD.Core; + +namespace TD.Gameplay.EnemyAbilities +{ + /// + /// On death, spawns copies of at the corpse's + /// position, continuing on toward the goal instead of restarting from the wave's spawner. + /// + [CreateAssetMenu(fileName = "SplitOnDeathAbility", menuName = "TD/Enemy Abilities/Split On Death")] + public class SplitOnDeathAbilityDefinition : EnemyAbilityDefinition + { + public override EnemyAbilityKind Kind => EnemyAbilityKind.SplitOnDeath; + + [Header("Split")] + [Tooltip("Smaller enemy type spawned when this enemy dies.")] + public EnemyDefinition SplitInto; + + [Tooltip("How many copies of SplitInto spawn on death.")] + [Min(1)] + public int SplitCount = 2; + + [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) + { + if (SplitInto == null) return; + + var movement = instance.GetComponent(); + var atTile = GridCoordinates.WorldToGrid(instance.transform.position); + var ownerSlot = movement != null ? movement.OriginZone : PlayerSlot.None; + + WaveManager.Instance?.ServerSpawnSplitEnemies(SplitInto, SplitCount, atTile, ownerSlot, ScatterRadius); + } + } +} diff --git a/Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs.meta b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs.meta new file mode 100644 index 0000000..8c2a4f3 --- /dev/null +++ b/Assets/_Project/Scripts/Gameplay/EnemyAbilities/SplitOnDeathAbilityDefinition.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 21543cb1b54f0b16e9c80584f68988b3 \ No newline at end of file diff --git a/Assets/_Project/Scripts/Gameplay/EnemyAbility.cs b/Assets/_Project/Scripts/Gameplay/EnemyAbility.cs new file mode 100644 index 0000000..34c7d79 --- /dev/null +++ b/Assets/_Project/Scripts/Gameplay/EnemyAbility.cs @@ -0,0 +1,84 @@ +// Assets/_Project/Scripts/Gameplay/EnemyAbility.cs +using Unity.Netcode; +using UnityEngine; +using TD.Core; +using TD.Gameplay.EnemyAbilities; + +namespace TD.Gameplay +{ + /// + /// Per-enemy ability slot. Holds the rolled for this + /// instance (if any) and drives its server-only hooks. + /// + /// + /// Initialization: Call on the server immediately after + /// Instantiate and before NetworkObject.Spawn(), following the same pattern as + /// EnemyHealth.InitializeServer / EnemyMovement.InitializeServer. + /// + /// Optional component: Not required by EnemyHealth or EnemyMovement — + /// WaveManager.SpawnEnemy 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. + /// + /// On-death hook is not event-driven: WaveManager.HandleEnemyKilled calls + /// directly (via ) + /// rather than this component subscribing to EnemyHealth.OnDied itself — that keeps a + /// split-spawn's activeEnemyCount increment ordered before the triggering kill's + /// decrement, regardless of NetworkBehaviour subscription order. + /// + [RequireComponent(typeof(NetworkObject))] + public class EnemyAbility : NetworkBehaviour + { + private readonly NetworkVariable kind = new NetworkVariable( + (byte)EnemyAbilityKind.None, + NetworkVariableReadPermission.Everyone, + NetworkVariableWritePermission.Server); + + // ----- Pre-spawn init (server-local) ---------------------------------- + + private EnemyAbilityDefinition pendingDefinition; + private bool hasPendingInit; + + // ----- Public state ----------------------------------------------------- + + /// The ability rolled for this enemy, or null if none was rolled. + public EnemyAbilityDefinition Definition { get; private set; } + + /// Replicated kind of the rolled ability. if + /// none was rolled. + public EnemyAbilityKind Kind => (EnemyAbilityKind)kind.Value; + + // ----- Server-only pre-spawn init ------------------------------------- + + /// + /// Called by WaveManager on the server after Instantiate and before + /// NetworkObject.Spawn(). may be null, meaning no + /// ability was rolled for this enemy. + /// + 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; + + Definition?.ServerOnSpawn(this); + } + + // ----- Server tick ------------------------------------------------ + + private void Update() + { + if (!IsServer || Definition == null) return; + Definition.ServerTick(this, Time.deltaTime); + } + } +} diff --git a/Assets/_Project/Scripts/Gameplay/EnemyAbility.cs.meta b/Assets/_Project/Scripts/Gameplay/EnemyAbility.cs.meta new file mode 100644 index 0000000..3562455 --- /dev/null +++ b/Assets/_Project/Scripts/Gameplay/EnemyAbility.cs.meta @@ -0,0 +1,2 @@ +fileFormatVersion: 2 +guid: 9d1a26a32e8969cd29bce6010126a5f6 \ No newline at end of file diff --git a/Assets/_Project/Scripts/Gameplay/EnemyMovement.cs b/Assets/_Project/Scripts/Gameplay/EnemyMovement.cs index 96a6e30..7eec0d1 100644 --- a/Assets/_Project/Scripts/Gameplay/EnemyMovement.cs +++ b/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; + + /// The zone (player) this enemy was originally spawned for — see + /// . Used by on-death abilities (e.g. Split on Death) so + /// spawned children preserve the same leak attribution as their parent. + 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). diff --git a/Assets/_Project/Scripts/Gameplay/WaveManager.cs b/Assets/_Project/Scripts/Gameplay/WaveManager.cs index d1d889b..67beb6c 100644 --- a/Assets/_Project/Scripts/Gameplay/WaveManager.cs +++ b/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; @@ -503,6 +504,13 @@ namespace TD.Gameplay health.InitializeServer(def.MaxHp, 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. + var ability = go.GetComponent(); + if (ability != null) + ability.InitializeServer(EnemyAbilityPool.Instance?.RollRandom()); + if (held) heldEnemies.Add(health); health.OnDied += HandleEnemyKilled; @@ -514,6 +522,22 @@ namespace TD.Gameplay go.GetComponent().Spawn(); } + /// + /// Server-only: spawns copies of at + /// , continuing that tile's A* path onward rather than + /// restarting from a wave spawner. Used by on-death abilities (e.g. + /// SplitOnDeathAbilityDefinition) to spawn smaller enemies from a corpse's + /// position. Reuses so split children get the same + /// activeEnemyCount/event-wiring bookkeeping as any other spawn. + /// + public void ServerSpawnSplitEnemies(EnemyDefinition def, int count, Vector2Int atTile, + PlayerSlot ownerSlot, float scatterRadius) + { + if (!IsServer) return; + for (int i = 0; i < count; i++) + SpawnEnemy(def, atTile, ownerSlot, scatterRadius, scatterRadius); + } + // ----- Enemy event handlers (server-only) ------------------------- private void HandleEnemyKilled(EnemyHealth health) @@ -551,6 +575,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(); + ability?.Definition?.ServerOnDeath(ability, health); + UnsubscribeEnemy(health); DecrementAndCheckComplete(); }