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

Merge pull request 'tower-sell' (#12) from tower-sell into main

Browse source 
Reviewed-on: #12
This commit is contained in:
matt 2026-07-14 23:54:08 -07:00
commit 52f7bfdf51
28 changed files with 5746 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Assets/_Project/Scripts/Gameplay/Draft/PlayerDraft.cs
View file

@ -137,7 +137,7 @@ namespace TD.Gameplay.Draft
// ----- Owner → server RPCs ----------------------------------------
/// <summary>Owning client: pick one of the offered options by id.</summary>
[Rpc(SendTo.Server, RequireOwnership = true)]
[Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Owner)]
public void RequestPickRpc(int optionId)
{
ServerResolve(optionId);
@ -148,7 +148,7 @@ namespace TD.Gameplay.Draft
/// afford it or already has an unresolved draft (resolve the current one first so a
/// free pick is never silently overwritten).
/// </summary>
[Rpc(SendTo.Server, RequireOwnership = true)]
[Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Owner)]
public void RequestBuyRerollRpc()
{
if (HasActiveDraft) return; // resolve the pending draft before buying another

20
Assets/_Project/Scripts/Gameplay/EnemyMovement.cs
View file

@ -21,8 +21,10 @@ namespace TD.Gameplay
/// and stores the tile waypoint list.</item>
/// <item>Each frame: moves toward the world center of <c>remainingPath[0]</c>.
/// When within snap distance, pops the waypoint and checks for zone transitions.</item>
/// <item>When <see cref="PathfindingService.OnPathsInvalidated"/> fires (tower placed /
/// sold), <see cref="RecomputePath"/> reruns A* from the current tile.</item>
/// <item>When the maze changes (tower placed / sold), <see cref="PathfindingService"/>'s
/// budgeted scheduler calls <see cref="RecomputePath"/> (registered via
/// <see cref="PathfindingService.RegisterMover"/>), rerunning A* from the current
/// tile — spread across frames so a full wave never spikes.</item>
/// <item>When <c>remainingPath</c> is empty after a pop, the enemy has reached the
/// goal — <see cref="OnReachedGoal"/> fires and the enemy is despawned.</item>
/// </list>
@ -168,15 +170,18 @@ namespace TD.Gameplay
// Recompute when a tower is placed or sold — grounded enemies only.
// Flyers path on the static baked grid, so tower changes can never affect
// their route; subscribing would just trigger needless recomputes.
// their route; registering would just trigger needless recomputes.
// Registration (not a direct event subscription) lets PathfindingService
// spread the recomputes across frames under a per-frame budget, so a maze
// change with a full wave present never spikes a single frame.
if (!isFlying && PathfindingService.Instance != null)
PathfindingService.Instance.OnPathsInvalidated += RecomputePath;
PathfindingService.Instance.RegisterMover(this);
}
public override void OnNetworkDespawn()
{
if (PathfindingService.Instance != null)
PathfindingService.Instance.OnPathsInvalidated -= RecomputePath;
PathfindingService.Instance.UnregisterMover(this);
}
// ----- Server update --------------------------------------------------
@ -274,8 +279,9 @@ namespace TD.Gameplay
// ----- Path invalidation ----------------------------------------------
// Called on server when LevelLoader.OnWalkabilityChanged fires (tower placed/sold).
private void RecomputePath()
// Called by PathfindingService's budgeted scheduler after a walkability change
// (tower placed/sold). Public so the scheduler can drive it across frames.
public void RecomputePath()
{
if (!IsServer) return;

88
Assets/_Project/Scripts/Gameplay/PathfindingService.cs
View file

@ -26,13 +26,15 @@ namespace TD.Gameplay
/// <b>Who calls this:</b>
/// <list type="bullet">
/// <item><see cref="EnemyMovement"/> calls <see cref="ComputePath"/> once on
/// spawn and again whenever <see cref="OnPathsInvalidated"/> fires.</item>
/// spawn, then registers via <see cref="RegisterMover"/> to be re-pathed when
/// the maze changes.</item>
/// </list>
///
/// <b>Invalidation:</b> Subscribes to <see cref="LevelLoader.OnWalkabilityChanged"/>.
/// When a tower is placed or sold, <c>LevelLoader.SetWalkable</c> fires that event
/// and <see cref="OnPathsInvalidated"/> is relayed to all active enemies, which
/// each recompute their own path from their current tile.
/// When a tower is placed or sold, <c>LevelLoader.SetWalkable</c> fires that event; the
/// service then enqueues every registered grounded enemy and recomputes them under a
/// per-frame time budget (<c>recomputeBudgetMs</c>), draining across frames so a maze
/// change with a full wave present never spikes a single frame.
///
/// <b>Goal tile set:</b> Built once on <c>Start</c> from
/// <c>LevelLoader.LevelData.Goals[].TileArea</c>. Goal tiles never change at
@ -52,7 +54,10 @@ namespace TD.Gameplay
/// <summary>
/// Fired on every peer when the walkability grid changes (tower placed/sold).
/// <see cref="EnemyMovement"/> subscribes per-instance to recompute its path.
/// Enemies no longer subscribe here — they register with the budgeted re-path
/// scheduler (<see cref="RegisterMover"/>) so recomputes spread across frames.
/// This event remains as an extension point for any non-enemy listener that wants
/// immediate notification of a maze change.
/// </summary>
public event System.Action OnPathsInvalidated;
@ -79,6 +84,28 @@ namespace TD.Gameplay
private readonly Dictionary<Vector2Int, float> gScore = new Dictionary<Vector2Int, float>();
private readonly SimplePriorityQueue openSet = new SimplePriorityQueue();
// ----- Deferred re-path scheduler ---------------------------------
//
// Grounded enemies register here (flyers never re-path — baked grid). On a
// walkability change we enqueue every registered enemy and recompute a
// TIME-BUDGETED number of them per frame, draining the backlog over subsequent
// frames. Recomputing them all synchronously on the change frame spiked to ~0.5s
// with a full wave on this large grid whenever a tower was sold/placed — this
// caps the per-frame cost so no single frame ever hitches. The maze can only be
// opened (sell) or narrowed with a guaranteed remaining route (placement, BFS-
// validated), so an enemy briefly following its slightly-stale path for a few
// frames until its turn comes up is safe and visually negligible.
[Tooltip("Max wall-clock milliseconds spent recomputing enemy paths per frame " +
"after a maze change. The backlog drains over following frames; at least " +
"one enemy is always processed per frame so it converges. Lower = smoother " +
"but slower to fully update; higher = faster to update but larger frame cost.")]
[SerializeField] private float recomputeBudgetMs = 1.5f;
private readonly HashSet<EnemyMovement> movers = new HashSet<EnemyMovement>();
private readonly Queue<EnemyMovement> recomputeQueue = new Queue<EnemyMovement>();
private readonly HashSet<EnemyMovement> queued = new HashSet<EnemyMovement>();
// ----- Lifecycle --------------------------------------------------
private void Awake()
@ -115,6 +142,48 @@ namespace TD.Gameplay
loader.OnWalkabilityChanged -= HandleWalkabilityChanged;
}
// Drains the deferred re-path backlog under a per-frame time budget. Runs on all
// peers, but the queue is only ever populated on the server (clients never register
// movers), so this is a no-op cost on clients. At least one enemy is processed per
// frame whenever the queue is non-empty, so it always converges.
private void Update()
{
if (recomputeQueue.Count == 0) return;
double startMs = Time.realtimeSinceStartupAsDouble * 1000.0;
do
{
var mover = recomputeQueue.Dequeue();
if (!queued.Remove(mover)) continue; // unregistered/cancelled after enqueue
if (mover != null) mover.RecomputePath(); // reads the CURRENT grid state
}
while (recomputeQueue.Count > 0
&& Time.realtimeSinceStartupAsDouble * 1000.0 - startMs < recomputeBudgetMs);
}
// ----- Deferred re-path scheduler API -----------------------------
/// <summary>
/// Registers a grounded enemy to be re-pathed (budgeted, over following frames)
/// whenever the maze changes. Flyers must NOT register — their baked-grid route
/// never changes. Called on the server from <see cref="EnemyMovement"/>.
/// </summary>
public void RegisterMover(EnemyMovement mover)
{
if (mover != null) movers.Add(mover);
}
/// <summary>
/// Removes an enemy from the scheduler (on despawn). Any stale entry still sitting
/// in the pending queue is skipped when dequeued (the <c>queued</c> membership check).
/// </summary>
public void UnregisterMover(EnemyMovement mover)
{
if (mover == null) return;
movers.Remove(mover);
queued.Remove(mover);
}
// ----- Public API -------------------------------------------------
/// <summary>
@ -471,7 +540,16 @@ namespace TD.Gameplay
private void HandleWalkabilityChanged()
{
// Notify any non-enemy listeners immediately (kept for API compatibility).
OnPathsInvalidated?.Invoke();
// Enqueue every registered grounded enemy for a budgeted, deferred recompute
// instead of recomputing them all on this frame. Already-queued enemies are
// deduped, so rapid successive maze changes just lengthen the drain rather
// than compounding into a spike.
foreach (var mover in movers)
if (queued.Add(mover))
recomputeQueue.Enqueue(mover);
}
}

2
Assets/_Project/Scripts/Gameplay/PlayerBuffManager.cs
View file

@ -146,7 +146,7 @@ namespace TD.Gameplay
/// a random buff from the category at <paramref name="categoryIndex"/>.
/// The server validates gold and adds the buff if the purchase succeeds.
/// </summary>
[Rpc(SendTo.Server, RequireOwnership = true)]
[Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Owner)]
public void RequestPurchaseBuffRpc(int categoryIndex)
{
if (categories == null || categoryIndex < 0 || categoryIndex >= categories.Length)

16
Assets/_Project/Scripts/Gameplay/PlayerGoldManager.cs
View file

@ -143,11 +143,17 @@ namespace TD.Gameplay
/// <summary>
/// Server-side entry point for awarding gold (wave clear, enemy kill).
/// Direct call — not Rpc-wrapped — because awards always originate
/// from server-authoritative game events. Also increments
/// <see cref="GoldEarnedThisWave"/> so the HUD's per-wave counter reflects
/// it; spending does not decrement that counter (it tracks earnings, not balance).
/// from server-authoritative game events. When <paramref name="countAsEarned"/>
/// is true (the default) it also increments <see cref="GoldEarnedThisWave"/> so the
/// HUD's per-wave counter reflects it; spending does not decrement that counter (it
/// tracks earnings, not balance).
/// </summary>
public void AwardGold(int amount)
/// <param name="countAsEarned">
/// Pass false for gold returned to the player that isn't income — e.g. a tower-sell
/// refund. The player's balance still rises, but the per-wave "earned" counter does not,
/// so refunds don't inflate round-income stats.
/// </param>
public void AwardGold(int amount, bool countAsEarned = true)
{
if (!IsServer)
{
@ -158,7 +164,7 @@ namespace TD.Gameplay
if (amount <= 0) return;
currentGold.Value += amount;
goldEarnedThisWave.Value += amount;
if (countAsEarned) goldEarnedThisWave.Value += amount;
}
/// <summary>

119
Assets/_Project/Scripts/Gameplay/TowerInstance.cs
View file

@ -1,4 +1,5 @@
// Assets/_Project/Scripts/Gameplay/TowerInstance.cs
using System.Collections.Generic;
using Unity.Netcode;
using UnityEngine;
using TD.Core;
@ -105,6 +106,24 @@ namespace TD.Gameplay
readPerm: NetworkVariableReadPermission.Everyone,
writePerm: NetworkVariableWritePermission.Server);
// Total gold sunk into this tower: its placement cost plus any gold later spent
// upgrading it. Set on the server at spawn (= placement cost) and grown by the
// (future) upgrade system via ServerAddUpgradeInvestment. Replicated so the HUD's
// Sell button can preview the exact refund without a server round-trip.
private readonly NetworkVariable<int> goldInvested =
new NetworkVariable<int>(
0,
readPerm: NetworkVariableReadPermission.Everyone,
writePerm: NetworkVariableWritePermission.Server);
// Number of upgrades applied to this tower. 0 = never upgraded. Drives the Wall's
// "full refund only while un-upgraded" rule and will back tier display later.
private readonly NetworkVariable<int> upgradeCount =
new NetworkVariable<int>(
0,
readPerm: NetworkVariableReadPermission.Everyone,
writePerm: NetworkVariableWritePermission.Server);
// ----- Local resolved state -------------------------------------------
// Resolved on every client in OnNetworkSpawn from definitionTypeId via the catalog.
@ -144,6 +163,12 @@ namespace TD.Gameplay
/// <summary>The footprint anchor tile (SW corner, world-tile coords).</summary>
public Vector2Int AnchorTile => anchorTile.Value;
/// <summary>Total gold sunk into this tower so far (placement + upgrades).</summary>
public int GoldInvested => goldInvested.Value;
/// <summary>How many upgrades have been applied to this tower (0 = never upgraded).</summary>
public int UpgradeCount => upgradeCount.Value;
/// <summary>World-unit height the post-construction drop animation falls from.</summary>
public float DropHeight => dropHeight;
@ -254,6 +279,11 @@ namespace TD.Gameplay
anchorTile.Value = pendingAnchor;
ownerSlot.Value = pendingOwner;
// Seed invested gold with the placement cost — the same amount
// TowerPlacementManager deducted to build this tower. The upgrade system
// grows this later via ServerAddUpgradeInvestment.
goldInvested.Value = pendingDefinition != null ? pendingDefinition.GoldCost : 0;
// Clear the pending data — it's now committed to NetworkVariables.
hasPendingInit = false;
}
@ -345,6 +375,84 @@ namespace TD.Gameplay
// Re-tint on every client (and the server) when the replicated paint color changes.
private void HandlePaintColorChanged(PaintColor previous, PaintColor current) => ApplyTint();
// ----- Selling --------------------------------------------------------
// Server-only guard: a fast double-click could deliver two sell RPCs before the
// despawn propagates. Mirrors BuildSiteVisual.serverCancelled.
private bool serverSold;
/// <summary>
/// Gold returned if this tower is sold right now. Single source of truth for both
/// the server (which awards it) and the HUD (which labels the Sell button). By
/// default this is <see cref="TowerDefinition.SellRefundPercent"/> of everything
/// invested; a tower flagged <see cref="TowerDefinition.FullRefundIfUnupgraded"/>
/// (the Wall) returns the full amount while it has never been upgraded.
/// </summary>
public int ComputeSellRefund()
{
int invested = goldInvested.Value;
if (resolvedDefinition == null)
return Mathf.RoundToInt(invested * 0.75f);
if (resolvedDefinition.FullRefundIfUnupgraded && upgradeCount.Value == 0)
return invested;
return Mathf.RoundToInt(invested * resolvedDefinition.SellRefundPercent);
}
/// <summary>
/// Server-only: records gold spent upgrading this tower (so a later sell refunds a
/// share of it) and marks the tower upgraded — which forfeits any
/// full-refund-while-unupgraded rule. The upgrade system calls this when it lands.
/// </summary>
public void ServerAddUpgradeInvestment(int cost)
{
if (!IsServer) return;
if (cost > 0) goldInvested.Value += cost;
upgradeCount.Value += 1;
}
/// <summary>
/// Client → server request to sell this tower. Accepted only from the tower's owner
/// (same ownership rule as placement and paint). The server refunds gold, broadcasts
/// the sell VFX/SFX from a persistent object, then despawns the tower —
/// <see cref="OnNetworkDespawn"/> restores the footprint's grid state and clears
/// selection on every peer.
/// </summary>
[Rpc(SendTo.Server)]
public void RequestSellServerRpc(RpcParams rpcParams = default)
{
if (!IsServer) return;
if (serverSold) return; // idempotent guard against a double-click
ulong senderClientId = rpcParams.Receive.SenderClientId;
PlayerSlot senderSlot = PlayerMatchState.SlotForClient(senderClientId);
if (senderSlot == PlayerSlot.None || senderSlot != ownerSlot.Value)
{
Debug.Log($"[TowerInstance] Sell rejected: client {senderClientId} " +
$"({senderSlot}) does not own tower owned by {ownerSlot.Value}.");
return;
}
serverSold = true;
int refund = ComputeSellRefund();
var goldManager = PlayerGoldManager.GetForClient(senderClientId);
if (goldManager != null && refund > 0)
// countAsEarned: false — a sell refund returns spent gold, it is not round
// income, so it must not inflate the per-wave "earned" counter.
goldManager.AwardGold(refund, countAsEarned: false);
// Broadcast VFX/SFX from the persistent placement manager, capturing the world
// position NOW — this NetworkObject despawns below, so it can't carry the RPC to
// remote peers itself (same reason WaveManager routes kill/leak popups).
var pm = TowerPlacementManager.Instance;
if (pm != null) pm.BroadcastSellEffect(transform.position);
if (NetworkObject != null && NetworkObject.IsSpawned)
NetworkObject.Despawn(destroy: true);
}
// ----- IMinimapEntity -------------------------------------------------
//
// Towers are static, so WorldPosition is cheap (no movement to track). Color reflects
@ -404,11 +512,20 @@ namespace TD.Gameplay
? resolvedDefinition.FootprintSize
: new Vector2Int(2, 2);
// Collect the footprint, then stamp walkability as a BATCH so a single
// OnWalkabilityChanged fires for the whole footprint. Per-tile SetWalkable fires
// that event once PER TILE — on despawn (sell) that meant up to 4 full enemy A*
// re-paths for a 2×2 tower in one frame, which was the sell hitch. Placement
// batches for the same reason (TowerPlacementManager.StampWalkable). Occupancy
// doesn't fire walkability events, so it stays per-tile.
var footprint = new List<Vector2Int>(footprintSize.x * footprintSize.y);
foreach (var tile in GridCoordinates.GetFootprintTiles(anchorTile.Value, footprintSize))
{
loader.SetWalkable(tile, walkable);
footprint.Add(tile);
loader.SetOccupied(tile, occupied);
}
loader.SetWalkableBatch(footprint, walkable);
}
// Reused per-instance across color updates to avoid per-call GC allocation.

38
Assets/_Project/Scripts/Gameplay/TowerPlacementManager.cs
View file

@ -5,6 +5,7 @@ using UnityEngine;
using TD.Core;
using TD.Levels;
using TD.Towers;
using TD.VFX;
namespace TD.Gameplay
{
@ -350,6 +351,43 @@ namespace TD.Gameplay
$"client {req.SenderClientId} ({placingSlot}) at anchor {req.Anchor}.");
}
// ----- Sell effects (persistent broadcaster) ----------------------
/// <summary>
/// Server-only: tells every peer to play the tower-sold VFX/SFX at
/// <paramref name="worldPos"/>. Called by <see cref="TowerInstance"/> as it sells,
/// because the tower's own NetworkObject despawns the same frame — a persistent
/// object must carry the broadcast so it isn't dropped.
/// </summary>
public void BroadcastSellEffect(Vector3 worldPos)
{
if (!IsServer) return;
PlaySellEffectRpc(worldPos);
}
// One-time guard so a missing spawner warns once per peer instead of on every sale.
private static bool s_warnedNoSellSpawner;
[Rpc(SendTo.Everyone)]
private void PlaySellEffectRpc(Vector3 worldPos)
{
var spawner = SellEffectSpawner.Instance;
if (spawner == null)
{
if (!s_warnedNoSellSpawner)
{
Debug.LogWarning("[TowerPlacementManager] A tower was sold, but there is no " +
"SellEffectSpawner in the scene — no coin VFX or sell sound " +
"will play. Add a SellEffectSpawner GameObject to each Match " +
"scene (assign its Sell Sound clip; the coin burst works even " +
"with no VFX prefab).");
s_warnedNoSellSpawner = true;
}
return;
}
spawner.Play(worldPos);
}
// ----- Server-side commit hooks called by Builder ------------------
/// <summary>

16
Assets/_Project/Scripts/Towers/TowerDefinition.cs
View file

@ -47,6 +47,22 @@ namespace TD.Towers
"successful server-side placement validation.")]
public int GoldCost;
// -------------------------------------------------------------------
// Selling
// -------------------------------------------------------------------
[Header("Selling")]
[Tooltip("Portion of the gold INVESTED in this tower (placement cost plus any gold " +
"later spent upgrading it) that is refunded when it is sold, as a 0–1 factor. " +
"Default 0.75 = 75%.")]
[Range(0f, 1f)]
public float SellRefundPercent = 0.75f;
[Tooltip("When true, this tower refunds 100% of its invested gold while it has never " +
"been upgraded (upgradeCount == 0); once upgraded it falls back to " +
"SellRefundPercent. Set on the Wall so a fresh wall can be re-mazed for free.")]
public bool FullRefundIfUnupgraded = false;
// -------------------------------------------------------------------
// Construction
// -------------------------------------------------------------------

29
Assets/_Project/Scripts/UI/HUDController.cs
View file

@ -1327,19 +1327,30 @@ namespace TD.UI
return btn;
}
// Sell action for a completed tower. Refund is computed on the TowerInstance (single
// source of truth shared with the server) so the badge shows exactly what the player
// gets back. Hotkey is Key.None: the bottom-right slot's letter (B) is already the
// global buff-menu toggle — see CreateBuffMenuButton — so binding it here would fire
// both. The button stays click-only.
private VisualElement CreateSellButton(TowerInstance tower, Key hotkey)
{
int sellValue = tower.Definition != null
? Mathf.RoundToInt(tower.Definition.GoldCost * 0.7f)
: 0;
// Only the tower's owner can sell it (the server enforces this too). A non-owner
// may have this tower view-selected — show the slot disabled with no refund badge
// so the action reads as unavailable rather than misleading.
bool ownedByLocal = tower != null
&& PlayerMatchState.Local != null
&& tower.Owner == PlayerMatchState.Local.Slot;
int sellValue = ownedByLocal ? tower.ComputeSellRefund() : 0;
var btn = CreateActionButton(
costText: sellValue > 0 ? $"+{sellValue}g" : "",
hotkey: hotkey,
hotkey: Key.None,
onClick: () =>
{
/* TODO: sell flow */
if (tower != null)
tower.RequestSellServerRpc();
});
btn.SetEnabled(false);
btn.SetEnabled(ownedByLocal);
return btn;
}
@ -1586,7 +1597,11 @@ namespace TD.UI
ttStats.text = "(stats pending)";
}
int sellValue = Mathf.RoundToInt(def.GoldCost * 0.7f);
// Sell preview for a freshly placed (un-upgraded) tower: mirrors
// TowerInstance.ComputeSellRefund for invested == GoldCost, upgradeCount == 0.
int sellValue = def.FullRefundIfUnupgraded
? def.GoldCost
: Mathf.RoundToInt(def.GoldCost * def.SellRefundPercent);
ttCost.text = $"Cost: {def.GoldCost}g · Sell: {sellValue}g";
}

101
Assets/_Project/Scripts/VFX/CoinBurstVfx.cs Normal file
View file

@ -0,0 +1,101 @@
// Assets/_Project/Scripts/VFX/CoinBurstVfx.cs
using UnityEngine;
namespace TD.VFX
{
/// <summary>
/// Self-contained, code-configured gold-coin burst used as the zero-art placeholder for the
/// tower-sell effect. Configures its own <see cref="ParticleSystem"/> for a short radial
/// spray of gold specks thrown up in random arcs under gravity, then destroys itself.
/// </summary>
/// <remarks>
/// Instantiated at runtime by <see cref="SellEffectSpawner"/> when no authored VFX prefab is
/// assigned. It can also be dropped on a prefab in the editor and tuned. Replace with an
/// authored particle / VFX-graph prefab (assigned on the spawner) when art is ready — nothing
/// else needs to change.
/// </remarks>
[RequireComponent(typeof(ParticleSystem))]
public class CoinBurstVfx : MonoBehaviour
{
[Tooltip("How many coin specks to throw.")]
[SerializeField] private int coinCount = 14;
[Tooltip("Longest a speck lives (seconds). The whole effect self-destructs shortly after.")]
[SerializeField] private float lifetime = 0.6f;
[Tooltip("Gold tint applied to the specks.")]
[SerializeField] private Color coinColor = new Color(1f, 0.84f, 0.2f, 1f);
private void Awake()
{
var ps = GetComponent<ParticleSystem>();
if (ps == null) ps = gameObject.AddComponent<ParticleSystem>();
Configure(ps);
}
private void Configure(ParticleSystem ps)
{
// Reconfiguring modules requires the system to be stopped first.
ps.Stop(true, ParticleSystemStopBehavior.StopEmittingAndClear);
var main = ps.main;
main.duration = 0.1f;
main.loop = false;
main.playOnAwake = false;
main.startLifetime = new ParticleSystem.MinMaxCurve(lifetime * 0.6f, lifetime);
main.startSpeed = new ParticleSystem.MinMaxCurve(2.5f, 5f);
main.startSize = new ParticleSystem.MinMaxCurve(0.07f, 0.16f);
main.startRotation = new ParticleSystem.MinMaxCurve(0f, Mathf.PI * 2f);
main.startColor = coinColor;
main.gravityModifier = 2.5f; // arc up then fall back down quickly
main.simulationSpace = ParticleSystemSimulationSpace.World;
main.maxParticles = 64;
main.stopAction = ParticleSystemStopAction.None;
var emission = ps.emission;
emission.enabled = true;
emission.rateOverTime = 0f; // burst only, no continuous stream
emission.SetBursts(new[] { new ParticleSystem.Burst(0f, (short)coinCount) });
// Hemisphere pointing up → specks spray outward and upward in random directions.
var shape = ps.shape;
shape.enabled = true;
shape.shapeType = ParticleSystemShapeType.Hemisphere;
shape.radius = 0.12f;
// Fade the specks out over the back half of their life so they "decay quickly".
var col = ps.colorOverLifetime;
col.enabled = true;
var grad = new Gradient();
grad.SetKeys(
new[] { new GradientColorKey(coinColor, 0f), new GradientColorKey(coinColor, 1f) },
new[]
{
new GradientAlphaKey(1f, 0f),
new GradientAlphaKey(1f, 0.55f),
new GradientAlphaKey(0f, 1f),
});
col.color = new ParticleSystem.MinMaxGradient(grad);
// Give the specks a visible, transparent-capable material even with no assigned art.
var renderer = GetComponent<ParticleSystemRenderer>();
if (renderer != null)
{
renderer.renderMode = ParticleSystemRenderMode.Billboard;
if (renderer.sharedMaterial == null)
{
Shader shader = Shader.Find("Universal Render Pipeline/Particles/Unlit")
?? Shader.Find("Sprites/Default")
?? Shader.Find("Legacy Shaders/Particles/Alpha Blended Premultiply");
if (shader != null)
renderer.material = new Material(shader) { color = coinColor };
}
}
ps.Play();
// Tear down after the last speck has died (plus a small margin).
Destroy(gameObject, lifetime + 0.25f);
}
}
}

2
Assets/_Project/Scripts/VFX/CoinBurstVfx.cs.meta Normal file
View file

@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: bdff685029f23004796671150c7cf39b

91
Assets/_Project/Scripts/VFX/SellEffectSpawner.cs Normal file
View file

@ -0,0 +1,91 @@
// Assets/_Project/Scripts/VFX/SellEffectSpawner.cs
using UnityEngine;
using TD.Audio;
namespace TD.VFX
{
/// <summary>
/// Scene singleton that plays the "tower sold" feedback — a burst of gold coins plus a
/// coin-rustle sound — at a world position. Mirrors <see cref="TD.UI.FloatingTextSpawner"/>:
/// visual-only, plain <c>MonoBehaviour</c>, invoked on every peer via a ClientRpc so all
/// players see and hear a sale locally.
/// </summary>
/// <remarks>
/// <b>Who calls this:</b> <see cref="TD.Gameplay.TowerPlacementManager.BroadcastSellEffect"/>
/// routes a ClientRpc here when a tower is sold.
///
/// <b>Inspector setup:</b> drop this on a <c>SellEffectSpawner</c> GameObject in each Match
/// scene. The VFX prefab is OPTIONAL — leave it empty to use the built-in
/// <see cref="CoinBurstVfx"/> placeholder, or assign an authored particle/VFX-graph prefab.
/// Assign the coin-rustle clip on <see cref="sellSound"/>.
/// </remarks>
public class SellEffectSpawner : MonoBehaviour
{
// ----- Singleton --------------------------------------------------
public static SellEffectSpawner Instance { get; private set; }
// ----- Inspector --------------------------------------------------
[Tooltip("Optional authored VFX prefab spawned at the sale position. Leave empty to " +
"fall back to the built-in code-generated CoinBurstVfx placeholder.")]
[SerializeField] private GameObject coinBurstPrefab;
[Tooltip("Coin-rustle sound played (2D, via AudioManager) when a tower is sold.")]
[SerializeField] private SoundConfig sellSound;
[Tooltip("Vertical offset above the sale position where the coin burst originates, so " +
"it reads as coming from the tower body rather than the ground.")]
[SerializeField] private float verticalOffset = 0.75f;
// ----- Lifecycle --------------------------------------------------
private void Awake()
{
if (Instance != null && Instance != this)
{
Debug.LogWarning("[SellEffectSpawner] Duplicate instance detected. " +
"Only one should exist per scene.");
return;
}
Instance = this;
}
private void OnDestroy()
{
if (Instance == this) Instance = null;
}
// ----- Public API -------------------------------------------------
/// <summary>Plays the coin burst + rustle sound at <paramref name="worldPos"/>.</summary>
public void Play(Vector3 worldPos)
{
Vector3 spawnPos = worldPos + Vector3.up * verticalOffset;
if (coinBurstPrefab != null)
{
var instance = Instantiate(coinBurstPrefab, spawnPos, Quaternion.identity);
// Force the burst to play. The spawner's whole job is to play this effect, so
// it shouldn't depend on the prefab's ParticleSystem having "Play On Awake"
// ticked — if that's off, the effect would silently never appear. Harmless when
// Play On Awake is already on (a freshly instantiated one-shot just restarts at
// t=0). VFX Graph effects play from their own settings, so a null PS is fine.
var ps = instance.GetComponentInChildren<ParticleSystem>();
if (ps != null) ps.Play(withChildren: true);
}
else
{
// Zero-art fallback: a self-configuring, self-destroying particle burst.
var go = new GameObject("CoinBurst");
go.transform.position = spawnPos;
go.AddComponent<CoinBurstVfx>();
}
if (sellSound.clip != null)
AudioManager.Instance?.Play(sellSound.clip, AudioCategory.UI,
sellSound.RandomPitch(), sellSound.volume);
}
}
}

2
Assets/_Project/Scripts/VFX/SellEffectSpawner.cs.meta Normal file
View file

@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: e2708c6bac8136f45b48c899d3d40630

30
Assets/_Project/Scripts/VFX/TransientEffect.cs Normal file
View file

@ -0,0 +1,30 @@
// Assets/_Project/Scripts/VFX/TransientEffect.cs
using UnityEngine;
namespace TD.VFX
{
/// <summary>
/// Destroys its GameObject a fixed time after it spawns. Drop this onto any one-shot
/// effect prefab — a particle burst, a VFX Graph effect, a sound-only object — so it
/// cleans itself up without any bespoke code. Designed for prefabs spawned by
/// <see cref="SellEffectSpawner"/> (and any future effect spawner) that fire once and
/// should disappear.
/// </summary>
/// <remarks>
/// <b>Shuriken shortcut:</b> a plain <see cref="ParticleSystem"/> can instead self-destroy
/// with no component at all — set <i>Main → Stop Action → Destroy</i> and make sure Looping
/// is off. Use this component for <b>VFX Graph</b> effects (which have no Stop Action) or for
/// prefabs that combine several systems and need one predictable lifetime.
///
/// <para>Set <see cref="lifetime"/> to comfortably exceed the effect's visible duration so it
/// isn't cut off mid-play.</para>
/// </remarks>
public class TransientEffect : MonoBehaviour
{
[Tooltip("Seconds after spawn before this GameObject destroys itself. Set it a little " +
"longer than the effect's visible length so nothing is cut off.")]
[SerializeField, Min(0f)] private float lifetime = 1.5f;
private void Start() => Destroy(gameObject, lifetime);
}
}

2
Assets/_Project/Scripts/VFX/TransientEffect.cs.meta Normal file
View file

@ -0,0 +1,2 @@
fileFormatVersion: 2
guid: 739f3145f66002d47850b603164d07b8