Assets/_Project/Art/Materials/M_Gold.mat

@@ -1,138 +0,0 @@
-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!21 &2100000
-Material:
-  serializedVersion: 8
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_Name: M_Gold
-  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
-  m_Parent: {fileID: 0}
-  m_ModifiedSerializedProperties: 0
-  m_ValidKeywords:
-  - _EMISSION
-  m_InvalidKeywords: []
-  m_LightmapFlags: 2
-  m_EnableInstancingVariants: 1
-  m_DoubleSidedGI: 0
-  m_CustomRenderQueue: -1
-  stringTagMap:
-    RenderType: Opaque
-  disabledShaderPasses:
-  - MOTIONVECTORS
-  m_LockedProperties: 
-  m_SavedProperties:
-    serializedVersion: 3
-    m_TexEnvs:
-    - _BaseMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _BumpMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DetailAlbedoMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DetailMask:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DetailNormalMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _EmissionMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _MainTex:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _MetallicGlossMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _OcclusionMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _ParallaxMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _SpecGlossMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - unity_Lightmaps:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - unity_LightmapsInd:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - unity_ShadowMasks:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    m_Ints: []
-    m_Floats:
-    - _AddPrecomputedVelocity: 0
-    - _AlphaClip: 0
-    - _AlphaToMask: 0
-    - _Blend: 0
-    - _BlendModePreserveSpecular: 1
-    - _BumpScale: 1
-    - _ClearCoatMask: 0
-    - _ClearCoatSmoothness: 0
-    - _Cull: 2
-    - _Cutoff: 0.5
-    - _DetailAlbedoMapScale: 1
-    - _DetailNormalMapScale: 1
-    - _DstBlend: 0
-    - _DstBlendAlpha: 0
-    - _EnvironmentReflections: 1
-    - _GlossMapScale: 0
-    - _Glossiness: 0
-    - _GlossyReflections: 0
-    - _Metallic: 0.3
-    - _OcclusionStrength: 1
-    - _Parallax: 0.005
-    - _QueueOffset: 0
-    - _ReceiveShadows: 1
-    - _Smoothness: 0.85
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _SrcBlendAlpha: 1
-    - _Surface: 0
-    - _WorkflowMode: 1
-    - _XRMotionVectorsPass: 1
-    - _ZWrite: 1
-    m_Colors:
-    - _BaseColor: {r: 0.83137256, g: 0.6862745, b: 0.21568628, a: 1}
-    - _Color: {r: 0.83137256, g: 0.68627447, b: 0.2156862, a: 1}
-    - _EmissionColor: {r: 2, g: 0.6755797, b: 0.031372547, a: 1}
-    - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}
-  m_BuildTextureStacks: []
-  m_AllowLocking: 1
---- !u!114 &1062544154538963945
-MonoBehaviour:
-  m_ObjectHideFlags: 11
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 0}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: Unity.RenderPipelines.Universal.Editor::UnityEditor.Rendering.Universal.AssetVersion
-  version: 10

Assets/_Project/Art/Materials/M_Gold.mat.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: 915f376be23f20941837c0809626fa5f
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/_Project/Art/Models/Blend Files.meta

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

Assets/_Project/Art/Models/Coin.fbx.meta

@@ -1,110 +0,0 @@
-fileFormatVersion: 2
-guid: 280a727da941fc544b9aab7df7fe9f2d
-ModelImporter:
-  serializedVersion: 24200
-  internalIDToNameTable: []
-  externalObjects: {}
-  materials:
-    materialImportMode: 2
-    materialName: 0
-    materialSearch: 1
-    materialLocation: 1
-  animations:
-    legacyGenerateAnimations: 4
-    bakeSimulation: 0
-    resampleCurves: 1
-    optimizeGameObjects: 0
-    removeConstantScaleCurves: 0
-    motionNodeName: 
-    animationImportErrors: 
-    animationImportWarnings: 
-    animationRetargetingWarnings: 
-    animationDoRetargetingWarnings: 0
-    importAnimatedCustomProperties: 0
-    importConstraints: 0
-    animationCompression: 1
-    animationRotationError: 0.5
-    animationPositionError: 0.5
-    animationScaleError: 0.5
-    animationWrapMode: 0
-    extraExposedTransformPaths: []
-    extraUserProperties: []
-    clipAnimations: []
-    isReadable: 0
-  meshes:
-    lODScreenPercentages: []
-    globalScale: 1
-    meshCompression: 0
-    addColliders: 0
-    useSRGBMaterialColor: 1
-    sortHierarchyByName: 1
-    importPhysicalCameras: 1
-    importVisibility: 1
-    importBlendShapes: 1
-    importCameras: 1
-    importLights: 1
-    nodeNameCollisionStrategy: 1
-    fileIdsGeneration: 2
-    swapUVChannels: 0
-    generateSecondaryUV: 0
-    useFileUnits: 1
-    keepQuads: 0
-    weldVertices: 1
-    bakeAxisConversion: 0
-    preserveHierarchy: 0
-    skinWeightsMode: 0
-    maxBonesPerVertex: 4
-    minBoneWeight: 0.001
-    optimizeBones: 1
-    generateMeshLods: 0
-    meshLodGenerationFlags: 0
-    maximumMeshLod: -1
-    meshOptimizationFlags: -1
-    indexFormat: 0
-    secondaryUVAngleDistortion: 8
-    secondaryUVAreaDistortion: 15.000001
-    secondaryUVHardAngle: 88
-    secondaryUVMarginMethod: 1
-    secondaryUVMinLightmapResolution: 40
-    secondaryUVMinObjectScale: 1
-    secondaryUVPackMargin: 4
-    useFileScale: 1
-    strictVertexDataChecks: 0
-  tangentSpace:
-    normalSmoothAngle: 60
-    normalImportMode: 0
-    tangentImportMode: 3
-    normalCalculationMode: 4
-    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
-    blendShapeNormalImportMode: 1
-    normalSmoothingSource: 0
-  referencedClips: []
-  importAnimation: 1
-  humanDescription:
-    serializedVersion: 3
-    human: []
-    skeleton: []
-    armTwist: 0.5
-    foreArmTwist: 0.5
-    upperLegTwist: 0.5
-    legTwist: 0.5
-    armStretch: 0.05
-    legStretch: 0.05
-    feetSpacing: 0
-    globalScale: 1
-    rootMotionBoneName: 
-    hasTranslationDoF: 0
-    hasExtraRoot: 0
-    skeletonHasParents: 1
-  lastHumanDescriptionAvatarSource: {instanceID: 0}
-  autoGenerateAvatarMappingIfUnspecified: 1
-  animationType: 2
-  humanoidOversampling: 1
-  avatarSetup: 0
-  addHumanoidExtraRootOnlyWhenUsingAvatar: 1
-  importBlendShapeDeformPercent: 1
-  remapMaterialsIfMaterialImportModeIsNone: 0
-  additionalBone: 0
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/_Project/Art/VFX/FX_SellTower.prefab.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 31f8d8c320b42c54d886d610fb13a1e7
-PrefabImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/_Project/Audio/Sound Effects.meta

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

Assets/_Project/Audio/Sound Effects/SellSoundEffect.ogg.meta

@@ -1,23 +0,0 @@
-fileFormatVersion: 2
-guid: 778b3d5981f4c3045a475794435f43cc
-AudioImporter:
-  externalObjects: {}
-  serializedVersion: 8
-  defaultSettings:
-    serializedVersion: 2
-    loadType: 0
-    sampleRateSetting: 0
-    sampleRateOverride: 44100
-    compressionFormat: 1
-    quality: 1
-    conversionMode: 0
-    preloadAudioData: 0
-  platformSettingOverrides: {}
-  forceToMono: 0
-  normalize: 1
-  loadInBackground: 0
-  ambisonic: 0
-  3D: 1
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Assets/_Project/Scenes/Levels/9Player.unity

@@ -15492,7 +15492,6 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: de7d013503af0f74c950f215f8dae1c0, type: 3}
   m_Name: 
   m_EditorClassIdentifier: Assembly-CSharp::TD.Gameplay.PathfindingService
-  recomputeBudgetMs: 1.5
 --- !u!4 &1149980841
 Transform:
   m_ObjectHideFlags: 0

Assets/_Project/Scripts/Gameplay/Draft/PlayerDraft.cs

@@ -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, InvokePermission = RpcInvokePermission.Owner)]
+        [Rpc(SendTo.Server, RequireOwnership = true)]
         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, InvokePermission = RpcInvokePermission.Owner)]
+        [Rpc(SendTo.Server, RequireOwnership = true)]
         public void RequestBuyRerollRpc()
         {
             if (HasActiveDraft) return; // resolve the pending draft before buying another

Assets/_Project/Scripts/Gameplay/EnemyMovement.cs

@@ -21,10 +21,8 @@ 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 the maze changes (tower placed / sold), <see cref="PathfindingService"/>'s
+    ///   <item>When <see cref="PathfindingService.OnPathsInvalidated"/> fires (tower placed /
-    ///         budgeted scheduler calls <see cref="RecomputePath"/> (registered via
+    ///         sold), <see cref="RecomputePath"/> reruns A* from the current tile.</item>
-    ///         <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>
@@ -170,18 +168,15 @@ 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; registering would just trigger needless recomputes.
+            // their route; subscribing 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.RegisterMover(this);
+                PathfindingService.Instance.OnPathsInvalidated += RecomputePath;
         }
 
         public override void OnNetworkDespawn()
         {
             if (PathfindingService.Instance != null)
-                PathfindingService.Instance.UnregisterMover(this);
+                PathfindingService.Instance.OnPathsInvalidated -= RecomputePath;
         }
 
         // ----- Server update --------------------------------------------------
@@ -279,9 +274,8 @@ namespace TD.Gameplay
 
         // ----- Path invalidation ----------------------------------------------
 
-        // Called by PathfindingService's budgeted scheduler after a walkability change
+        // Called on server when LevelLoader.OnWalkabilityChanged fires (tower placed/sold).
-        // (tower placed/sold). Public so the scheduler can drive it across frames.
+        private void RecomputePath()
-        public void RecomputePath()
         {
             if (!IsServer) return;
 

Assets/_Project/Scripts/Gameplay/PathfindingService.cs

@@ -26,15 +26,13 @@ namespace TD.Gameplay
     /// <b>Who calls this:</b>
     /// <list type="bullet">
     ///   <item><see cref="EnemyMovement"/> calls <see cref="ComputePath"/> once on
-    ///         spawn, then registers via <see cref="RegisterMover"/> to be re-pathed when
+    ///         spawn and again whenever <see cref="OnPathsInvalidated"/> fires.</item>
-    ///         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; the
+    /// When a tower is placed or sold, <c>LevelLoader.SetWalkable</c> fires that event
-    /// service then enqueues every registered grounded enemy and recomputes them under a
+    /// and <see cref="OnPathsInvalidated"/> is relayed to all active enemies, which
-    /// per-frame time budget (<c>recomputeBudgetMs</c>), draining across frames so a maze
+    /// each recompute their own path from their current tile.
-    /// 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
@@ -54,10 +52,7 @@ namespace TD.Gameplay
 
         /// <summary>
         /// Fired on every peer when the walkability grid changes (tower placed/sold).
-        /// Enemies no longer subscribe here — they register with the budgeted re-path
+        /// <see cref="EnemyMovement"/> subscribes per-instance to recompute its 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;
 
@@ -84,28 +79,6 @@ 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()
@@ -142,48 +115,6 @@ 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>
@@ -540,16 +471,7 @@ 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);
         }
     }
 

Assets/_Project/Scripts/Gameplay/PlayerBuffManager.cs

@@ -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, InvokePermission = RpcInvokePermission.Owner)]
+        [Rpc(SendTo.Server, RequireOwnership = true)]
         public void RequestPurchaseBuffRpc(int categoryIndex)
         {
             if (categories == null || categoryIndex < 0 || categoryIndex >= categories.Length)

Assets/_Project/Scripts/Gameplay/PlayerGoldManager.cs

@@ -143,17 +143,11 @@ 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. When <paramref name="countAsEarned"/>
+        /// from server-authoritative game events. Also increments
-        /// is true (the default) it also increments <see cref="GoldEarnedThisWave"/> so the
+        /// <see cref="GoldEarnedThisWave"/> so the HUD's per-wave counter reflects
-        /// HUD's per-wave counter reflects it; spending does not decrement that counter (it
+        /// it; spending does not decrement that counter (it tracks earnings, not balance).
-        /// tracks earnings, not balance).
         /// </summary>
-        /// <param name="countAsEarned">
+        public void AwardGold(int amount)
-        /// 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)
             {
@@ -164,7 +158,7 @@ namespace TD.Gameplay
 
             if (amount <= 0) return;
             currentGold.Value += amount;
-            if (countAsEarned) goldEarnedThisWave.Value += amount;
+            goldEarnedThisWave.Value += amount;
         }
 
         /// <summary>

Assets/_Project/Scripts/Gameplay/TowerInstance.cs

@@ -1,5 +1,4 @@
 // Assets/_Project/Scripts/Gameplay/TowerInstance.cs
-using System.Collections.Generic;
 using Unity.Netcode;
 using UnityEngine;
 using TD.Core;
@@ -106,24 +105,6 @@ 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.
@@ -163,12 +144,6 @@ 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;
 
@@ -279,11 +254,6 @@ 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;
             }
@@ -375,84 +345,6 @@ 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
@@ -512,20 +404,11 @@ 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))
             {
-                footprint.Add(tile);
+                loader.SetWalkable(tile, walkable);
                 loader.SetOccupied(tile, occupied);
             }
-
-            loader.SetWalkableBatch(footprint, walkable);
         }
 
         // Reused per-instance across color updates to avoid per-call GC allocation.

Assets/_Project/Scripts/Gameplay/TowerPlacementManager.cs

@@ -5,7 +5,6 @@ using UnityEngine;
 using TD.Core;
 using TD.Levels;
 using TD.Towers;
-using TD.VFX;
 
 namespace TD.Gameplay
 {
@@ -351,43 +350,6 @@ 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>

Assets/_Project/Scripts/Towers/TowerDefinition.cs

@@ -47,22 +47,6 @@ 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
         // -------------------------------------------------------------------

Assets/_Project/Scripts/UI/HUDController.cs

@@ -1327,30 +1327,19 @@ 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)
         {
-            // Only the tower's owner can sell it (the server enforces this too). A non-owner
+            int sellValue = tower.Definition != null
-            // may have this tower view-selected — show the slot disabled with no refund badge
+                ? Mathf.RoundToInt(tower.Definition.GoldCost * 0.7f)
-            // so the action reads as unavailable rather than misleading.
+                : 0;
-            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: Key.None,
+                hotkey: hotkey,
                 onClick: () =>
                 {
-                    if (tower != null)
+                    /* TODO: sell flow */
-                        tower.RequestSellServerRpc();
                 });
-            btn.SetEnabled(ownedByLocal);
+            btn.SetEnabled(false);
             return btn;
         }
 
@@ -1597,11 +1586,7 @@ namespace TD.UI
                 ttStats.text = "(stats pending)";
             }
 
-            // Sell preview for a freshly placed (un-upgraded) tower: mirrors
+            int sellValue = Mathf.RoundToInt(def.GoldCost * 0.7f);
-            // 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";
         }
 

Assets/_Project/Scripts/VFX/CoinBurstVfx.cs

@@ -1,101 +0,0 @@
-// 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);
-        }
-    }
-}

Assets/_Project/Scripts/VFX/CoinBurstVfx.cs.meta

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

Assets/_Project/Scripts/VFX/SellEffectSpawner.cs

@@ -1,91 +0,0 @@
-// 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);
-        }
-    }
-}

Assets/_Project/Scripts/VFX/SellEffectSpawner.cs.meta

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

Assets/_Project/Scripts/VFX/TransientEffect.cs

@@ -1,30 +0,0 @@
-// 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);
-    }
-}

Assets/_Project/Scripts/VFX/TransientEffect.cs.meta

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

Project_Context.md

@@ -4,7 +4,7 @@
 
 A snapshot of **where the project is and how it works** — the authoritative reference for current architecture, implemented systems, conventions, and known debt. It pairs with [`Project_Roadmap.md`](Project_Roadmap.md), which is the forward-looking plan. When the two disagree, this document describes *what exists today*; the roadmap describes *what's planned next*.
 
-Last substantial update: 2026-07-14.
+Last substantial update: 2026-06-24.
 
 ---
 
@@ -56,11 +56,10 @@ Unity **6.4 (6000.4.4f1)**, URP, IL2CPP, .NET Standard 2.1, Linear color space,
 - `TowerPlacementManager` (server-validated placement queue) — `SpawnTower` now **seats towers flush on the ground from their mesh bounds** (`SeatOnGround`), so any pivot works (replaced the old hard-coded y=0.5). `Builder` build queue with staged construction/pause/cancel/refund, RTS selection, owner tinting.
 - **Construction-phase build visuals:** `BuildSiteVisual` swaps between an ordered set of phase prefabs as a tower builds — `ConstructionPhaseSet` SO + optional per-tower `TowerDefinition.ConstructionPhases`, with a project-default set and a legacy cube Y-scale fallback. `BuildSiteVisual` resolves its def via `TowerTypeId` (catalog), like `TowerInstance`.
 - **Tesla Coil tower:** Electric, `AllInRange` (zaps every enemy in range each 0.5s tick). `TeslaArcVisual` draws arced, crackling, HDR `LineRenderer` bolts that flicker, plus **real point lights** (emitter flash + per-impact lights at struck enemies, capped) so the electricity actually illuminates the scene — emission/bloom alone don't cast light.
-- **Tower Sell** (branch `tower-sell`, verified in-engine 2026-07-14): selecting an owned, completed tower shows a **Sell** action in the command grid's **bottom-right** slot (owner-gated; a non-owner sees it disabled). `TowerInstance.RequestSellServerRpc` (owner-validated, like paint) refunds `TowerDefinition.SellRefundPercent` (default 0.75) of the tower's replicated `goldInvested` (placement + any future upgrade spend), except a `FullRefundIfUnupgraded` tower (the **Wall**) refunds 100% while `upgradeCount == 0`. The refund is **not** counted as round income — `PlayerGoldManager.AwardGold(amount, countAsEarned:false)`. Selling despawns the tower (`OnNetworkDespawn` un-stamps the footprint as a **batch** and clears selection) and broadcasts a coin **VFX + rustle SFX** through `SellEffectSpawner` (scene singleton mirroring `FloatingTextSpawner`) via `TowerPlacementManager.PlaySellEffectRpc` (routed off a persistent object because the tower despawns the same frame). `TowerInstance.ServerAddUpgradeInvestment` is the seam the future upgrade system writes to. The coin VFX is an **artist-authored** prefab (`FX_SellTower`: a Shuriken **mesh-particle** burst of the Blender `Coin` model with an **emissive** gold material — emissive so it survives the grimdark grade); `CoinBurstVfx` is the zero-art code-gen fallback, and new reusable `TransientEffect` self-destructs one-shot effect prefabs (for VFX-Graph effects that lack a Stop Action).
 
 ### Enemies & pathfinding
 - `EnemyHealth` (replicated HP, damage types, `IsFlying`, held state), `EnemyStatus` (lingering effects: slow/DoT), `EnemyMovement` (A* path following, zone-leak attribution, death/sink sequence).
-- `PathfindingService` (A* on the runtime walkability grid, octile heuristic, corner-cut prevention, line-of-sight path smoothing). **Re-paths via a budgeted scheduler:** grounded enemies `RegisterMover`/`UnregisterMover`; on a maze change the service enqueues them and recomputes under a per-frame `recomputeBudgetMs` (default 1.5 ms) drain, spreading the work across frames so a placement/sell with a full wave present no longer spikes a frame (was ~0.5 s). Safe because selling only opens the maze and placement is BFS-guaranteed to leave a route, so a few frames of slightly-stale path is invisible.
+- `PathfindingService` (A* on the runtime walkability grid, octile heuristic, corner-cut prevention, line-of-sight path smoothing; re-paths on tower placement/removal).
 - **Flying enemies:** path on the **baked terrain grid** (`LevelLoader.IsBaseWalkable`) so they soar over towers; compute once, never re-path; spawn elevated by `EnemyDefinition.FlightHeight`.
 - Content: ~10 enemy definitions/prefabs (Crystal Golem / Cyclops / Ent variants, Undead Drake = the flying test enemy), 10 wave definitions.
 
@@ -103,4 +102,4 @@ Unity **6.4 (6000.4.4f1)**, URP, IL2CPP, .NET Standard 2.1, Linear color space,
 - **Catalog index 0 is a reserved sentinel** (valid `TowerTypeId`s start at 1) — easy to forget when wiring the catalog in the inspector.
 - **Catalog-index identifiers aren't session-stable** — blocks cross-match persistence until a stable ID is added.
 - **Paint system frozen**; **Race vs Builder** naming unresolved; the gold **"Buy Roll available any time"** rule is provisional and may change.
-- **Stubbed/unbuilt:** tower **Upgrade** action (HUD button still disabled; the `TowerInstance.ServerAddUpgradeInvestment` seam is ready for it), enemy resistances/weaknesses, in-match race-pick countdown. *(Tower **Sell** is now done — see Combat & towers.)*
+- **Stubbed/unbuilt:** tower Upgrade/Sell actions (HUD buttons disabled), enemy resistances/weaknesses, in-match race-pick countdown.

Project_Roadmap.md

@@ -4,7 +4,7 @@
 
 The **forward-looking plan**: what's done, what's next, and the sequencing. Current-state architecture and the full list of implemented systems live in [`Project_Context.md`](Project_Context.md) — read that first for "how things work today." This document focuses on direction and remaining work.
 
-Last substantial update: 2026-07-14.
+Last substantial update: 2026-06-24.
 
 ---
 
@@ -36,8 +36,6 @@ All players start with the **same three towers** — **Basic Arrow** (ground+air
 
 **Done & merged:** functional match loop end-to-end, HUD, lobby + race selection, economy, enemies + A* pathfinding, **flying enemies + air-targeting**, **per-player tower deck** (keystone #1), **draft Slice 1** (spine + "new tower"), **TowerRegistry removal** (towers replicate by `TowerTypeId`), **per-tower construction-phase build visuals**, **ground-seating from mesh bounds**, **Tesla Coil tower** (Electric + AllInRange + arc VFX with real flash/impact lights).
 
-**Done, on branch `tower-sell` (pushed to origin; NOT yet merged to `main`):** **Tower Sell** — owner-gated Sell action, refunds `SellRefundPercent` (default 75%) of invested gold, the **Wall refunds 100% while un-upgraded**, refund excluded from round income, coin **VFX** (artist-authored emissive mesh-particle `FX_SellTower`, with a `CoinBurstVfx` code-gen fallback) + rustle **SFX**. Also a **budgeted enemy re-path scheduler** in `PathfindingService` that removes the ~0.5 s frame hitch on any maze change (sell/placement) with a full wave present, plus a batched footprint un-stamp and the NGO `RequireOwnership`→`InvokePermission` deprecation cleanup. Verified in-engine 2026-07-14.
-
 **In progress (branch `feature/post-processing`):** project-wide **grimdark post-processing** grade + HDR; Tesla arc lighting polish. *(This branch was fast-forwarded onto the Tesla work; commit the post-processing assets + the `TeslaArcVisual` light additions.)*
 
 **Paused:** in-match Paint system (overlaps with systemic upgrades).
@@ -82,8 +80,7 @@ Player profile saving owned content; **win/loss reward pools** drawn server-side
 
 ## Part B — Functional gameplay remainder (not roguelike-specific)
 
-- **Tower Sell — ✅ DONE** (branch `tower-sell`): refund + despawn + coin VFX/SFX; 75% of invested gold, Wall 100% while un-upgraded, refund not counted as income; `TowerInstance.ServerAddUpgradeInvestment` records upgrade spend for the refund and is the seam the Upgrade system will write to.
+- **Tower Upgrade / Sell actions** — HUD buttons exist but are disabled. Sell first (refund + despawn), then per-tower upgrade if the systemic model leaves room for it.
-- **Tower Upgrade action** — HUD button still disabled. Build it once the systemic-upgrade model (A3) settles whether per-tower upgrade trees are wanted on top of the systemic modifiers.
 - **Enemy resistances / weaknesses** — `EnemyHealth.TakeDamage` has the stub slot; info panel has the placeholder.
 - **Terrain architecture decision** — Unity Terrain vs mesh vs ProBuilder. Builder code is terrain-agnostic; decide before heavy art.
 - **Camera polish** — cursor-anchored zoom near map edges, center-on-builder hotkey, race/phase-aware initial position.