(Feat) Add Remove Building

Assets/GAME/Script/Building/BuildRegistry.cs

@@ -99,6 +99,43 @@ namespace Ashwild.Building
 
         #endregion
 
+        #region Demolish Build
+
+        /// <summary>
+        /// Called by BuildManager when the local player demolishes a build they aimed at: resolves the
+        /// hit instance to its index in the replicated list and asks the server to remove it. The index
+        /// is a valid shared key because <see cref="spawned"/> stays aligned with <see cref="builds"/>
+        /// on every machine. No-op when the object is not one of our committed builds.
+        /// </summary>
+        public void RequestDemolish(GameObject builtInstance)
+        {
+            if (builtInstance == null) return;
+
+            int index = spawned.IndexOf(builtInstance);
+            if (index < 0)
+            {
+                Debug.LogWarning($"[BuildRegistry] '{builtInstance.name}' is not a committed build — nothing to demolish.", this);
+                return;
+            }
+            RequestDemolishServerRpc(index);
+        }
+
+        /// <summary>
+        /// Server-side: removes the record at this index, which replicates the removal (and the local
+        /// teardown + occupancy refresh) to every client. Range-guarded against a stale index from a
+        /// build that another player demolished during the round-trip.
+        /// </summary>
+        [ServerRpc(RequireOwnership = false)]
+        private void RequestDemolishServerRpc(int index, NetworkConnection conn = null)
+        {
+            if (index < 0 || index >= builds.Count) return;
+
+            // TODO: refund the builder's resources (conn → PlayerInventory) once build cost lands.
+            builds.RemoveAt(index);
+        }
+
+        #endregion
+
         #region Networked Ghost Preview
 
         /// <summary>
@@ -187,6 +224,7 @@ namespace Ashwild.Building
                 case SyncListOperation.RemoveAt:
                     DestroyAt(index);
                     spawned.RemoveAt(index);
+                    RecomputeOccupancy();
                     break;
 
                 case SyncListOperation.Clear:
@@ -210,7 +248,10 @@ namespace Ashwild.Building
                 Debug.LogWarning($"[BuildRegistry] Buildable id {record.buildableId} introuvable ou sans BuiltPrefab — rien de spawné.", this);
                 return null;
             }
-            return Instantiate(data.BuiltPrefab, record.position, record.rotation);
+
+            GameObject go = Instantiate(data.BuiltPrefab, record.position, record.rotation);
+            if (go.GetComponent<BuiltStructure>() == null) go.AddComponent<BuiltStructure>();
+            return go;
         }
 
         /// <summary>
@@ -246,6 +287,24 @@ namespace Ashwild.Building
                 MarkOccupancy(go);
         }
 
+        /// <summary>
+        /// Recomputes occupancy from scratch after a removal: clears every socket, then re-marks the
+        /// connected pairs across what remains. Without this a demolished piece would leave its former
+        /// neighbours' sockets stuck "occupied", so nothing could ever be snapped back into the gap.
+        /// </summary>
+        private void RecomputeOccupancy()
+        {
+            foreach (GameObject go in spawned)
+            {
+                if (go == null) continue;
+                foreach (BuildSnapPoint sp in go.GetComponentsInChildren<BuildSnapPoint>(true))
+                    sp.SetOccupied(false);
+            }
+
+            foreach (GameObject go in spawned)
+                MarkOccupancy(go);
+        }
+
         /// <summary>
         /// Marks the sockets a piece shares a position with — and the matching sockets on the pieces
         /// it touches — as occupied, so placement snapping skips them. Occupancy is derived purely