yeahweregames/UnityTowerDefense
4
0
Fork 0
Code Issues Pull requests Projects 1 Releases Packages Wiki Activity Actions

First pass at full refactor to 2.0 design

Browse source 
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>
This commit is contained in:
Matt F 2026-07-30 17:45:11 -07:00
parent 7e5c3a8279
commit 4892d7253d
64 changed files with 4023 additions and 344 deletions
Download patch file Download diff file Expand all files Collapse all files

66
Assets/_Project/Scripts/Gameplay/Draft/TowerUpgradeDraftOption.cs
View file

@ -5,52 +5,62 @@ using TD.Towers;
namespace TD.Gameplay.Draft
{
/// <summary>
/// Draft choice — "upgrade a tower you already have". Replaces <see cref="BaseTower"/>
/// with <see cref="UpgradedTower"/> in the player's <see cref="PlayerTowerDeck"/>: every
/// tower of that type placed from now on is the upgraded version. Already-placed towers
/// are unaffected.
/// Draft choice — "unlock an upgrade". Adds <see cref="UpgradedTower"/> to the player's
/// <see cref="PlayerTowerUpgrades"/> set, letting them spend gold converting a placed
/// <see cref="BaseTower"/> into it. The base tower stays buildable.
/// </summary>
/// <remarks>
/// Mirrors <see cref="NewTowerDraftOption"/>, but swaps rather than adds. Only offered
/// while the player currently has <see cref="BaseTower"/> unlocked — once taken,
/// <see cref="BaseTower"/> is removed from the deck, which automatically makes this option
/// (and any sibling upgrade branching off the same base) invalid for future drafts.
/// <para><b>Unlock, not swap.</b> This option used to replace the base tower in the player's
/// deck, which made the draft pick itself the whole upgrade — free, instant, and retroactive to
/// every tower built afterward. The 2.0 model splits it: the draft grants <i>access</i>, gold
/// grants the <i>tower</i>. So the deck is untouched here and already-placed towers are
/// upgraded one at a time, each paid for.</para>
///
/// <para><b>Prerequisites fall out of the tree.</b> An upgrade is offerable only once its
/// parent is reachable — either the parent is a base tower in the player's deck, or it's an
/// upgrade node they've already unlocked. That single rule is what gates deep nodes behind
/// shallow ones without any explicit prerequisite list: authoring the tree in
/// <see cref="TowerDefinition.UpgradePaths"/> is enough.</para>
/// </remarks>
[CreateAssetMenu(fileName = "TowerUpgradeOption", menuName = "TD/Draft/Tower Upgrade Option")]
public class TowerUpgradeDraftOption : DraftOption
{
[Header("Payload")]
[Tooltip("The tower this option upgrades from. Must be present in the player's deck " +
"for this option to be offered.")]
[Tooltip("The tower this upgrade branches from — the tree node that must already be " +
"reachable (in the player's deck, or itself an unlocked upgrade) for this " +
"option to be offered.")]
public TowerDefinition BaseTower;
[Tooltip("The tower this option upgrades to. Must also be present in the " +
"TowerPlacementManager catalog (that's where its TowerTypeId comes from).")]
[Tooltip("The tower this option unlocks as an upgrade target. Must be in the " +
"TowerPlacementManager catalog (that's where its TowerTypeId comes from) and " +
"should be listed in BaseTower's UpgradePaths so the conversion is legal.")]
public TowerDefinition UpgradedTower;
public override bool IsValidFor(ulong clientId)
{
var deck = PlayerTowerDeck.GetForClient(clientId);
var pm = TowerPlacementManager.Instance;
if (deck == null || pm == null || BaseTower == null || UpgradedTower == null) return false;
var deck = PlayerTowerDeck.GetForClient(clientId);
var upgrades = PlayerTowerUpgrades.GetForClient(clientId);
var pm = TowerPlacementManager.Instance;
if (!pm.TryGetTypeId(BaseTower, out int baseTypeId)) return false;
if (deck == null || upgrades == null || pm == null) return false;
if (BaseTower == null || UpgradedTower == null) return false;
return deck.Contains(baseTypeId);
if (!pm.TryGetTypeId(BaseTower, out int baseTypeId)) return false;
if (!pm.TryGetTypeId(UpgradedTower, out int upgradedTypeId)) return false;
// Already unlocked — offering it again would waste the pick.
if (upgrades.Contains(upgradedTypeId)) return false;
// The parent must be reachable: a base tower they can build, or an upgrade they've
// already taken. This is the whole prerequisite mechanism.
return deck.Contains(baseTypeId) || upgrades.Contains(baseTypeId);
}
public override bool ServerApply(ulong clientId)
{
var deck = PlayerTowerDeck.GetForClient(clientId);
var pm = TowerPlacementManager.Instance;
if (deck == null || pm == null || BaseTower == null || UpgradedTower == null) return false;
if (!pm.TryGetTypeId(BaseTower, out int baseTypeId))
{
Debug.LogError($"[TowerUpgradeDraftOption] '{BaseTower.name}' is not in the tower " +
$"catalog; cannot apply. Add it to TowerPlacementManager.towerDefinitions.");
return false;
}
var upgrades = PlayerTowerUpgrades.GetForClient(clientId);
var pm = TowerPlacementManager.Instance;
if (upgrades == null || pm == null || UpgradedTower == null) return false;
if (!pm.TryGetTypeId(UpgradedTower, out int upgradedTypeId))
{
@ -60,7 +70,7 @@ namespace TD.Gameplay.Draft
return false;
}
return deck.ServerUpgradeTower(baseTypeId, upgradedTypeId);
return upgrades.ServerUnlock(upgradedTypeId);
}
/// <summary>Inherits the upgraded tower's icon unless this option assigns an override.</summary>