Matt F
4892d7253d
Restructures the game around the cyclical run loop from Game Design Doc V2: 5 waves = a cycle, 3 cycles = a phase, each phase ends in a boss. - New TD.Gameplay.Waves: WaveGroup / PhaseDefinition / RunDefinition author the run as draggable weighted pools; RunState owns phase/cycle position, the drawn wave slots, and the per-slot enemy buff sets. WaveManager's flat wave array is gone -- it now only runs the encounter RunState points at. - New TD.Gameplay.EnemyUpgrades: the post-wave enemy-buff vote, with public live-replicated ballots so the HUD can show who voted for what. - Inter-wave flow is now strictly sequential: draft -> vote -> build, each stage ending early once every player has acted. - Enemy abilities inverted from per-instance random rolls to deterministic, stacking per-wave-slot sets. Six cards ship: Split (reworked), Flight, Blink, No Bounty, Gold Theft, Double Up. - Tower upgrades are a two-step tree: a draft pick unlocks a node, gold converts an already-placed tower in place. - Boss encounters flag their enemies and drive a boss HP bar. - Player cap reduced to 3 via MatchRules.MaxPlayers. - GoldConfig is now keyed by global encounter number rather than wave index. Compiles clean; NOT yet verified in-engine. Editor wiring still required -- see Docs/2.0_Setup_Checklist.md. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
71 lines
3 KiB
C#
71 lines
3 KiB
C#
// 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.
|
|
///
|
|
/// <para><b>Lookup only — no rolling.</b> This pool used to draw a random ability per spawned
|
|
/// enemy against a "no ability" weight. Under the 2.0 design abilities are chosen by the
|
|
/// players' post-wave vote and apply to every enemy in the wave, so the draw moved to
|
|
/// <c>WaveVote</c> (over cards, not abilities) and this is purely the kind→asset table
|
|
/// <c>WaveManager</c> resolves against at spawn time.</para>
|
|
/// </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;
|
|
|
|
// 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;
|
|
}
|
|
}
|
|
}
|