diff --git a/Assets/Scripts/GameMode/NormalGameMode.cs b/Assets/Scripts/GameMode/NormalGameMode.cs
index 2df2454..a148992 100644
--- a/Assets/Scripts/GameMode/NormalGameMode.cs
+++ b/Assets/Scripts/GameMode/NormalGameMode.cs
@@ -87,6 +87,7 @@ public class NormalGameMode : IGameMode
     {
         player.IsColliding = true;
 
+        Debug.Log(collision.gameObject.tag.ToString());
         if (collision.gameObject.CompareTag("Kill"))
         {
             SceneManager.LoadScene(SceneManager.GetActiveScene().name);
diff --git a/Assets/Scripts/LevelEditor.cs b/Assets/Scripts/LevelEditor.cs
index 9f3653e..06e29dd 100644
--- a/Assets/Scripts/LevelEditor.cs
+++ b/Assets/Scripts/LevelEditor.cs
@@ -8,7 +8,7 @@ public class LevelEditor : MonoBehaviour
     [Header("Placement")]
     private GameObject currentBlock;
     private bool isPlacingBlock = false;
-    private Vector3 currentScale = new Vector3(1f, 1f, 1);
+    private Vector3 currentScale = Vector3.one;
     private float scaleStep = 0.1f;
 
     [Header("UI")]
@@ -28,9 +28,12 @@ public class LevelEditor : MonoBehaviour
 
     private enum ResizeAxis { None, Horizontal, Vertical }
     private ResizeAxis currentResizeAxis = ResizeAxis.None;
+    private Transform persistentBlockContainer;
 
     void Start()
     {
+        persistentBlockContainer = new GameObject("PlacedBlocks").transform;
+        DontDestroyOnLoad(persistentBlockContainer.gameObject);
         LoadPrefabs();
         GenerateButtons();
     }
@@ -52,83 +55,70 @@ public class LevelEditor : MonoBehaviour
 
     void LoadPrefabs()
     {
-        blockPrefabs.AddRange(Resources.LoadAll<GameObject>("Prefabs"));
+        var all = Resources.LoadAll<GameObject>("Prefabs");
+        blockPrefabs.Clear();
+        foreach (var prefab in all)
+        {
+            var name = prefab.name.ToLower();
+            if (name == "ground" || name == "winnerwall") continue;
+            blockPrefabs.Add(prefab);
+        }
     }
 
     void GenerateButtons()
     {
         ClearCurrentButtons();
-
         if (blockGroupContainer == null || buttonPrefabTemplate == null)
         {
-            Debug.LogError("UI Container ou prefab de bouton manquant.");
+            Debug.LogError("UI Container ou prefab manquant.");
             return;
         }
-
         int start = currentPage * buttonsPerPage;
         int end = Mathf.Min(start + buttonsPerPage, blockPrefabs.Count);
-
         for (int i = start; i < end; i++)
         {
-            GameObject button = Instantiate(buttonPrefabTemplate, blockGroupContainer);
-            button.SetActive(true);
-
-            SetupButtonVisual(button.transform, blockPrefabs[i], i - start);
-
-            GameObject prefab = blockPrefabs[i];
-            button.GetComponent<Button>().onClick.AddListener(() => SelectPrefab(prefab));
-            currentButtons.Add(button);
+            var btn = Instantiate(buttonPrefabTemplate, blockGroupContainer);
+            btn.SetActive(true);
+            SetupButtonVisual(btn.transform, blockPrefabs[i], i - start);
+            var prefab = blockPrefabs[i];
+            btn.GetComponent<Button>().onClick.AddListener(() => SelectPrefab(prefab));
+            currentButtons.Add(btn);
         }
     }
 
-    void SetupButtonVisual(Transform buttonTransform, GameObject prefab, int index)
+    void SetupButtonVisual(Transform t, GameObject prefab, int idx)
     {
-        Transform canvas = buttonTransform.Find("Canvas");
-        Transform bg = canvas?.Find("BlankSquare");
-        Transform icon = canvas?.Find("PrefabIcon");
-
-        if (bg == null || icon == null)
-        {
-            Destroy(buttonTransform.gameObject);
-            return;
-        }
-
-        float xOffset = -375f + index * 125f;
-        bg.GetComponent<RectTransform>().anchoredPosition = new Vector2(xOffset, bg.GetComponent<RectTransform>().anchoredPosition.y);
-        icon.GetComponent<RectTransform>().anchoredPosition = new Vector2(xOffset, icon.GetComponent<RectTransform>().anchoredPosition.y);
-
+        var canvas = t.Find("Canvas");
+        var bg = canvas?.Find("BlankSquare");
+        var icon = canvas?.Find("PrefabIcon");
+        if (bg == null || icon == null) { Destroy(t.gameObject); return; }
+        float xOff = -375f + idx * 125f;
+        var bgRt = bg.GetComponent<RectTransform>();
+        var icRt = icon.GetComponent<RectTransform>();
+        bgRt.anchoredPosition = new Vector2(xOff, bgRt.anchoredPosition.y);
+        icRt.anchoredPosition = new Vector2(xOff, icRt.anchoredPosition.y);
         bg.GetComponent<Image>().sprite = Resources.Load<Sprite>("InGame/ButtonSkin/BlankSquare");
         icon.GetComponent<Image>().sprite = prefab.GetComponent<SpriteRenderer>()?.sprite;
-
-        icon.GetComponent<RectTransform>().sizeDelta = prefab.name.ToLower().Contains("small")
+        icRt.sizeDelta = prefab.name.ToLower().Contains("small")
             ? new Vector2(50, 25)
             : new Vector2(50, 50);
     }
 
     void ClearCurrentButtons()
     {
-        foreach (var button in currentButtons)
-            Destroy(button);
+        foreach (var b in currentButtons) Destroy(b);
         currentButtons.Clear();
     }
 
     public void NextPage()
     {
-        int maxPage = Mathf.CeilToInt(blockPrefabs.Count / (float)buttonsPerPage);
-        if (currentPage < maxPage - 1)
-        {
-            currentPage++;
-            GenerateButtons();
-        }
+        int max = Mathf.CeilToInt(blockPrefabs.Count / (float)buttonsPerPage);
+        if (currentPage < max - 1) { currentPage++; GenerateButtons(); }
     }
 
     public void PreviousPage()
     {
-        if (currentPage > 0)
-        {
-            currentPage--;
-            GenerateButtons();
-        }
+        if (currentPage > 0) { currentPage--; GenerateButtons(); }
     }
 
     #endregion
@@ -138,7 +128,6 @@ public class LevelEditor : MonoBehaviour
     void SelectPrefab(GameObject prefab)
     {
         if (isPlacingBlock) return;
-
         currentScale = DetermineScaleFromName(prefab.name);
         InstantiateAndPrepare(prefab, currentScale);
     }
@@ -146,59 +135,49 @@ public class LevelEditor : MonoBehaviour
     Vector3 DetermineScaleFromName(string name)
     {
         name = name.ToLower();
-
         if (name.Contains("portal")) return new Vector3(0.5f, 0.5f, 1);
         if (name.Contains("small")) return new Vector3(0.15f, 0.07f, 1);
         if (name.Contains("spike")) return new Vector3(0.15f, 0.15f, 1);
         if (name.Contains("block")) return new Vector3(0.2f, 0.2f, 1);
         if (name.Contains("bonus")) return new Vector3(0.3f, 0.3f, 1);
-
-        return new Vector3(1f, 1f, 1);
+        return Vector3.one;
     }
 
     void HandleBlockPlacement()
     {
-        Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
-        currentBlock.transform.position = new Vector3(Mathf.Round(mousePos.x), Mathf.Round(mousePos.y), -1);
-
-        if (Input.GetKeyDown(KeyCode.R))
-            HandleBlockRotation();
-
+        Vector2 m = Camera.main.ScreenToWorldPoint(Input.mousePosition);
+        currentBlock.transform.position = new Vector3(Mathf.Round(m.x), Mathf.Round(m.y), -1);
+        if (Input.GetKeyDown(KeyCode.R)) HandleBlockRotation();
         if (!currentBlock.name.ToLower().Contains("portal"))
         {
-            float scroll = Input.GetAxis("Mouse ScrollWheel");
-            if (scroll != 0)
+            float s = Input.GetAxis("Mouse ScrollWheel");
+            if (s != 0)
             {
-                float newScale = Mathf.Max(0.1f, currentScale.x + scroll * scaleStep);
-                currentScale = new Vector3(newScale, newScale, 1);
+                float ns = Mathf.Max(0.1f, currentScale.x + s * scaleStep);
+                currentScale = Vector3.one * ns;
                 currentBlock.transform.localScale = currentScale;
             }
         }
-
         if (Input.GetMouseButtonDown(0))
         {
             if (!IsPlacementValid())
             {
-                Debug.Log("Placement annulé : collision.");
+                Debug.Log("Placement invalide : collision.");
                 return;
             }
-
             PlaceBlock();
         }
     }
 
     bool IsPlacementValid()
     {
-        Collider2D[] overlaps = Physics2D.OverlapBoxAll(
-            currentBlock.transform.position,
-            currentBlock.GetComponent<Collider2D>().bounds.size,
-            0f
-        );
-
-        foreach (var col in overlaps)
+        var col = currentBlock.GetComponent<Collider2D>();
+        var hits = Physics2D.OverlapBoxAll(col.bounds.center, col.bounds.size, 0f);
+        foreach (var h in hits)
         {
-            if (col.transform.root == currentBlock.transform || col.CompareTag("Ground"))
-                continue;
+            if (h == col) continue;
+            if (h.CompareTag("Ground")) continue;
+            if (h.transform.IsChildOf(currentBlock.transform)) continue;
             return false;
         }
         return true;
@@ -206,140 +185,196 @@ public class LevelEditor : MonoBehaviour
 
     void HandleBlockSelection()
     {
-        if (Input.GetMouseButtonDown(0))
+        if (!Input.GetMouseButtonDown(0)) return;
+        Vector2 m = Camera.main.ScreenToWorldPoint(Input.mousePosition);
+        var hit = Physics2D.OverlapPoint(m);
+        if (hit != null && !hit.CompareTag("Ground"))
         {
-            Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
-            Collider2D hit = Physics2D.OverlapPoint(mousePos);
-
-            if (hit != null && !hit.CompareTag("Ground"))
-            {
-                currentBlock = hit.gameObject;
-                isPlacingBlock = true;
-                currentScale = currentBlock.transform.localScale;
-                Debug.Log($"Bloc sélectionné : {currentBlock.name}");
-            }
+            var sel = hit.gameObject;
+            if ((sel.name.Contains("ObstacleSafer") || sel.name.Contains("ObstacleKiller"))
+                && sel.transform.parent != null
+                && sel.transform.parent.name.Contains("ObstacleBlock"))
+                sel = sel.transform.parent.gameObject;
+            currentBlock = sel;
+            isPlacingBlock = true;
+            currentScale = currentBlock.transform.localScale;
+            Debug.Log($"🟢 Sélection : {sel.name}");
         }
     }
-
     void PlaceBlock()
     {
         string name = currentBlock.name.ToLower();
+        bool isSpikeType = name.Contains("spike") || name.Contains("smallspike") || name.Contains("killzone");
 
-        bool grounded = name.Contains("spike") || name.Contains("bonus") || name.Contains("smallobstacle");
-
-        if (grounded)
+        if (isSpikeType)
         {
-            StickBlockToGround();
-        }
-        else if (!ShouldSkipVerticalSnap(name))
-        {
-            SnapBlockVertically();
-            TrySnapToNearbyBlock(); // ✅ seulement ici
+            // 1) Bloquer si on perçoit un spike de même type dans la direction de snap
+            if (IsBlockedBySameTypeInSnapDirection())
+            {
+                Debug.LogError("❌ Impossible de poser un spike sur un autre spike !");
+                Destroy(currentBlock);
+            }
+            else
+            {
+                // 2) On snap dans la direction (down/left/up/right), et on détruit si aucun support
+                if (!SnapSpikeByRotation())
+                {
+                    Debug.LogError("❌ Impossible de poser un spike dans le vide !");
+                    Destroy(currentBlock);
+                }
+                else
+                {
+                    // 3) On fait l’ajustement fin (si besoin)
+                    TrySnapToNearbyBlock();
+                }
+            }
         }
         else
         {
-            TrySnapToNearbyBlock(); // ex: autres blocs
+            // tous les autres blocs
+            TrySnapToNearbyBlock();
         }
 
-
-        TrySnapToNearbyBlock();
-
         isPlacingBlock = false;
         currentBlock = null;
     }
-    void StickBlockToGround()
+
+    /// <summary>
+    /// Vérifie qu’il n’y ait pas déjà un spike/smallspike/killzone
+    /// juste devant le spike selon sa rotation.
+    /// </summary>
+    bool IsBlockedBySameTypeInSnapDirection()
     {
-        Collider2D col = currentBlock.GetComponent<Collider2D>();
-        Bounds bounds = col.bounds;
+        var col = currentBlock.GetComponent<Collider2D>();
+        var b = col.bounds;
 
-        Vector2 origin = new Vector2(bounds.center.x, bounds.min.y);
-        float rayLength = 100f; // on descend loin pour être sûr de toucher le sol
-
-        RaycastHit2D hit = Physics2D.Raycast(origin, Vector2.down, rayLength);
-
-        if (hit.collider != null && hit.collider.gameObject != currentBlock)
+        // 1) Détermine direction de snap (0→down,1→left,2→up,3→right)
+        int rot = (Mathf.RoundToInt(currentBlock.transform.eulerAngles.z / 90) % 4 + 4) % 4;
+        Vector2 dir = rot switch
         {
-            float topY = hit.collider.bounds.max.y;
-            float height = bounds.size.y;
-            float newY = topY + height / 2f;
+            1 => Vector2.right,
+            2 => Vector2.up,
+            3 => Vector2.left,
+            _ => Vector2.down
+        };
 
-            currentBlock.transform.position = new Vector3(currentBlock.transform.position.x, newY, -1f);
-            Debug.Log($"📌 Bloc descendu sur {hit.collider.name} à Y={newY}");
+        // 2) Origine : on place la « boîte » juste en bordure du sprite
+        float offset = 0.01f;
+        Vector2 origin = rot switch
+        {
+            1 => new Vector2(b.min.x - offset, b.center.y),    // gauche
+            3 => new Vector2(b.max.x + offset, b.center.y),    // droite
+            2 => new Vector2(b.center.x, b.max.y + offset), // haut
+            _ => new Vector2(b.center.x, b.min.y - offset)  // bas
+        };
+
+        // 3) On box‐cast exactement la taille du sprite pour 100 unités
+        RaycastHit2D[] hits = Physics2D.BoxCastAll(
+            origin,
+            b.size,
+            0f,
+            dir,
+            100f
+        );
+
+        foreach (var h in hits)
+        {
+            if (h.collider == null || h.collider.gameObject == currentBlock) continue;
+            if (h.collider.isTrigger) continue;
+
+            string me = currentBlock.name.ToLower();
+            string other = h.collider.gameObject.name.ToLower();
+
+            bool meIsSpikeFamily = me.Contains("spike") || me.Contains("killzone");
+            bool otherIsSpikeFamily = other.Contains("spike") || other.Contains("killzone");
+
+            if (meIsSpikeFamily && otherIsSpikeFamily)
+            {
+                // on bloque absolument tout chevauchement entre ces trois types
+                return true;
+            }
+
+            // si on tape autre chose (sol, block, bonus…), on arrête le scan
+            break;
+        }
+
+        return false;
+    }
+
+    bool SnapSpikeByRotation()
+    {
+        // Récupère bounds et demi-tailles
+        var col = currentBlock.GetComponent<Collider2D>();
+        var b = col.bounds;
+        float hw = b.extents.x;
+        float hh = b.extents.y;
+
+        // 1) Détermine la rotation en quarts de tour : 0→down, 1→left, 2→up, 3→right
+        int rot = ((Mathf.RoundToInt(currentBlock.transform.eulerAngles.z / 90f) % 4) + 4) % 4;
+        Vector2 dir;
+        switch (rot)
+        {
+            case 1: dir = Vector2.right; break;
+            case 2: dir = Vector2.up; break;
+            case 3: dir = Vector2.left; break;
+            default: dir = Vector2.down; break;
+        }
+
+        // 2) Calcule 3 origines le long de la face « avant » du spike
+        const float eps = 0.01f;
+        List<Vector2> origins = new List<Vector2>();
+        if (dir == Vector2.down || dir == Vector2.up)
+        {
+            // face inférieure ou supérieure → balaye l’axe X
+            float y0 = (dir == Vector2.down) ? b.min.y - eps : b.max.y + eps;
+            origins.Add(new Vector2(b.min.x + 0.1f * b.size.x, y0));
+            origins.Add(new Vector2(b.center.x, y0));
+            origins.Add(new Vector2(b.max.x - 0.1f * b.size.x, y0));
         }
         else
         {
-            Debug.Log("❗ Aucun support trouvé en dessous pour aligner le bloc.");
+            // face gauche ou droite → balaye l’axe Y
+            float x0 = (dir == Vector2.left) ? b.min.x - eps : b.max.x + eps;
+            origins.Add(new Vector2(x0, b.min.y + 0.1f * b.size.y));
+            origins.Add(new Vector2(x0, b.center.y));
+            origins.Add(new Vector2(x0, b.max.y - 0.1f * b.size.y));
         }
-    }
 
-    bool ShouldSkipVerticalSnap(string name)
-    {
-        name = name.ToLower();
-        return name.Contains("smallobstacle") || name.Contains("portal");
-    }
-
-    void SnapBlockVertically()
-    {
-        Collider2D col = currentBlock.GetComponent<Collider2D>();
-        Bounds bounds = col.bounds;
-
-        float snapThreshold = 0.1f; // ➜ 0.1 unité = environ 2 pixels
-
-        Vector2 checkStart = new Vector2(bounds.min.x, bounds.min.y - snapThreshold);
-        Vector2 checkEnd = new Vector2(bounds.max.x, bounds.min.y);
-
-        Collider2D[] hitsBelow = Physics2D.OverlapAreaAll(checkStart, checkEnd);
-
-        float highestY = -Mathf.Infinity;
-        GameObject bestTarget = null;
-
-        foreach (var hit in hitsBelow)
+        // 3) Pour chaque origine, on lance un RaycastAll et on garde le hit le plus proche
+        float bestDist = float.PositiveInfinity;
+        RaycastHit2D bestHit = default;
+        foreach (var o in origins)
         {
-            if (hit == null || hit.gameObject == currentBlock || hit.transform.IsChildOf(currentBlock.transform))
-                continue;
-
-            float top = hit.bounds.max.y;
-            if (top > highestY)
+            var hits = Physics2D.RaycastAll(o, dir, 100f);
+            foreach (var h in hits)
             {
-                highestY = top;
-                bestTarget = hit.gameObject;
+                if (h.collider == null || h.collider.gameObject == currentBlock) continue;
+                if (h.collider.isTrigger) continue;
+                if (h.distance < bestDist)
+                {
+                    bestDist = h.distance;
+                    bestHit = h;
+                }
             }
         }
 
-        if (bestTarget != null)
-        {
-            float blockHeight = bounds.size.y;
-            float snapY = highestY + blockHeight / 2f;
+        // 4) Aucun support trouvé → échec
+        if (bestHit.collider == null)
+            return false;
 
-            currentBlock.transform.position = new Vector3(currentBlock.transform.position.x, snapY, -1f);
-            Debug.Log($"✅ Snap vertical à {snapY} sur {bestTarget.name}");
-        }
-        else
-        {
-            Debug.Log("❌ Aucun bloc trouvé assez proche en dessous pour snap.");
-        }
+        // 5) Sinon, colle bord à bord
+        Vector3 p = currentBlock.transform.position;
+        if (dir == Vector2.down) p.y = bestHit.point.y + hh;
+        else if (dir == Vector2.up) p.y = bestHit.point.y - hh;
+        else if (dir == Vector2.left) p.x = bestHit.point.x + hw;
+        else if (dir == Vector2.right) p.x = bestHit.point.x - hw;
+
+        currentBlock.transform.position = new Vector3(p.x, p.y, -1f);
+        Debug.Log($"📌 Spike snapé {dir} sur « {bestHit.collider.name} » à {currentBlock.transform.position}");
+        return true;
     }
 
 
-    void InstantiateAndPrepare(GameObject prefab, Vector3? scaleOverride = null)
-    {
-        GameObject obj = Instantiate(prefab);
-        obj.transform.position = new Vector3(0, 0, -1);
-        obj.transform.localScale = scaleOverride ?? currentScale;
-
-        try { obj.tag = prefab.name; }
-        catch { Debug.LogWarning($"Le tag '{prefab.name}' est manquant."); }
-
-        currentBlock = obj;
-        isPlacingBlock = true;
-    }
-
-    void HandleBlockRotation()
-    {
-        currentBlock.transform.Rotate(0f, 0f, -90f);
-        Debug.Log("🔄 Bloc pivoté de 90° !");
-    }
-
     #endregion
 
     #region Resizing & Deletion
@@ -348,173 +383,147 @@ public class LevelEditor : MonoBehaviour
     {
         if (Input.GetMouseButtonDown(0) && Input.GetKey(KeyCode.LeftShift) && !isPlacingBlock)
         {
-            Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
-            Collider2D hit = Physics2D.OverlapPoint(mousePos);
-
+            Vector2 m = Camera.main.ScreenToWorldPoint(Input.mousePosition);
+            var hit = Physics2D.OverlapPoint(m);
             if (hit != null && !hit.CompareTag("Ground"))
-            {
-                BeginResizing(hit.gameObject, mousePos);
-            }
+                BeginResizing(hit.gameObject, m);
         }
-
         if (isResizing && resizingTarget != null)
-        {
             PerformResizing();
-        }
     }
 
-    void BeginResizing(GameObject target, Vector2 mousePos)
+    void BeginResizing(GameObject tgt, Vector2 mPos)
     {
-        resizingTarget = target;
-        originalMousePos = mousePos;
-        originalScale = target.transform.localScale;
-
-        Vector2 localClick = mousePos - (Vector2)target.transform.position;
-        float ratio = target.GetComponent<Collider2D>().bounds.size.x / target.GetComponent<Collider2D>().bounds.size.y;
-
-        currentResizeAxis = Mathf.Abs(localClick.x) > Mathf.Abs(localClick.y * ratio)
+        resizingTarget = tgt;
+        originalMousePos = mPos;
+        originalScale = tgt.transform.localScale;
+        Vector2 local = mPos - (Vector2)tgt.transform.position;
+        float ratio = tgt.GetComponent<Collider2D>().bounds.size.x / tgt.GetComponent<Collider2D>().bounds.size.y;
+        currentResizeAxis = Mathf.Abs(local.x) > Mathf.Abs(local.y * ratio)
             ? ResizeAxis.Horizontal
             : ResizeAxis.Vertical;
-
         isResizing = true;
-        Debug.Log($"🧰 Début du redimensionnement : {target.name} (axe : {currentResizeAxis})");
+        Debug.Log($"🧰 Début redim {tgt.name} (axe {currentResizeAxis})");
     }
 
     void PerformResizing()
     {
-        Vector3 currentMousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
-        Vector3 delta = currentMousePos - originalMousePos;
-
-        Vector3 newScale = originalScale;
+        Vector3 m = Camera.main.ScreenToWorldPoint(Input.mousePosition);
+        Vector3 delta = m - originalMousePos;
+        Vector3 ns = originalScale;
         if (currentResizeAxis == ResizeAxis.Horizontal)
-            newScale.x = Mathf.Max(0.1f, originalScale.x + delta.x);
-        else if (currentResizeAxis == ResizeAxis.Vertical)
-            newScale.y = Mathf.Max(0.1f, originalScale.y + delta.y);
-
-        resizingTarget.transform.localScale = newScale;
-
+            ns.x = Mathf.Max(0.1f, originalScale.x + delta.x);
+        else
+            ns.y = Mathf.Max(0.1f, originalScale.y + delta.y);
+        resizingTarget.transform.localScale = ns;
         if (IsOverlapping(resizingTarget))
         {
             resizingTarget.transform.localScale = originalScale;
-            Debug.Log("❌ Redimensionnement annulé : collision.");
+            Debug.Log("❌ Redim annulé : collision");
         }
-
         if (Input.GetMouseButtonUp(0))
         {
             isResizing = false;
             resizingTarget = null;
             currentResizeAxis = ResizeAxis.None;
-            Debug.Log("✅ Fin du redimensionnement");
+            Debug.Log("✅ Fin redim");
         }
     }
 
     bool IsOverlapping(GameObject obj)
     {
-        Bounds bounds = obj.GetComponent<Collider2D>().bounds;
-        Collider2D[] overlaps = Physics2D.OverlapBoxAll(bounds.center, bounds.size, 0f);
-
-        foreach (var col in overlaps)
-        {
-            if (col.gameObject != obj)
-                return true;
-        }
+        var b = obj.GetComponent<Collider2D>().bounds;
+        foreach (var h in Physics2D.OverlapBoxAll(b.center, b.size, 0f))
+            if (h.gameObject != obj) return true;
         return false;
     }
 
     void HandleBlockDeletion()
     {
-        if (Input.GetMouseButtonDown(1))
+        if (!Input.GetMouseButtonDown(1)) return;
+        Vector2 m = Camera.main.ScreenToWorldPoint(Input.mousePosition);
+        var hit = Physics2D.OverlapPoint(m);
+        if (hit != null && !hit.CompareTag("Ground"))
         {
-            Vector2 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
-            Collider2D hit = Physics2D.OverlapPoint(mousePos);
-
-            if (hit != null && !hit.CompareTag("Ground"))
-            {
-                GameObject toDestroy = hit.gameObject;
-
-                // ✅ Cas spécial : ObstacleBlock ou ses enfants
-                if (toDestroy.name.Contains("ObstacleSafer") || toDestroy.name.Contains("ObstacleKiller"))
-                {
-                    Transform parent = toDestroy.transform.parent;
-                    if (parent != null && parent.name.Contains("ObstacleBlock"))
-                    {
-                        toDestroy = parent.gameObject;
-                    }
-                }
-
-                if (toDestroy == currentBlock)
-                {
-                    currentBlock = null;
-                    isPlacingBlock = false;
-                }
-
-                Destroy(toDestroy);
-                Debug.Log($"🗑️ Supprimé : {toDestroy.name}");
-            }
+            var toD = hit.gameObject;
+            if ((toD.name.Contains("ObstacleSafer") || toD.name.Contains("ObstacleKiller"))
+                && toD.transform.parent != null
+                && toD.transform.parent.name.Contains("ObstacleBlock"))
+                toD = toD.transform.parent.gameObject;
+            if (toD == currentBlock) { currentBlock = null; isPlacingBlock = false; }
+            Destroy(toD);
+            Debug.Log($"🗑️ Supprimé {toD.name}");
         }
     }
+
     #endregion
 
     #region Utility
 
     bool IsPointerOverUI()
-    {
-        return EventSystem.current != null && EventSystem.current.IsPointerOverGameObject();
-    }
+        => EventSystem.current != null && EventSystem.current.IsPointerOverGameObject();
 
     void TrySnapToNearbyBlock()
     {
         if (currentBlock == null) return;
 
-        Collider2D blockCollider = currentBlock.GetComponent<Collider2D>();
-        Bounds bounds = blockCollider.bounds;
+        var col = currentBlock.GetComponent<Collider2D>();
+        var b = col.bounds;
         float snapDistance = 1f;
+        float verticalEps = 0.05f; // petite marge pour exclure trop hauts ou trop bas
 
-        Vector2[] directions =
+        // Taille et positions des deux zones de recherche latérales
+        Vector2 boxSize = new Vector2(snapDistance, b.size.y - verticalEps * 2f);
+        // à droite
+        Vector2 rightCenter = new Vector2(b.max.x + snapDistance / 2f, b.center.y);
+        // à gauche
+        Vector2 leftCenter = new Vector2(b.min.x - snapDistance / 2f, b.center.y);
+
+        // Cherche à droite
+        var hits = Physics2D.OverlapBoxAll(rightCenter, boxSize, 0f);
+        foreach (var h in hits)
         {
-            Vector2.right, Vector2.left, Vector2.down, Vector2.up
-        };
-
-        foreach (var dir in directions)
-        {
-            Vector2 extent2D = new Vector2(bounds.extents.x, bounds.extents.y);
-            Vector2 start = (Vector2)bounds.center + dir * (extent2D + Vector2.one * (snapDistance / 2f));
-            Collider2D[] hits = Physics2D.OverlapCircleAll(start, snapDistance);
-
-            foreach (var hit in hits)
+            if (h != null && h.gameObject != currentBlock && !h.isTrigger)
             {
-                if (hit != null && hit.gameObject != currentBlock)
-                {
-                    SnapToTarget(hit, dir);
-                    return;
-                }
+                float newX = h.bounds.min.x - b.extents.x;
+                currentBlock.transform.position = new Vector3(newX, currentBlock.transform.position.y, -1f);
+                Debug.Log($"↔️ Snap horizontal à droite contre {h.name}");
+                return;
+            }
+        }
+
+        // Cherche à gauche
+        hits = Physics2D.OverlapBoxAll(leftCenter, boxSize, 0f);
+        foreach (var h in hits)
+        {
+            if (h != null && h.gameObject != currentBlock && !h.isTrigger)
+            {
+                float newX = h.bounds.max.x + b.extents.x;
+                currentBlock.transform.position = new Vector3(newX, currentBlock.transform.position.y, -1f);
+                Debug.Log($"↔️ Snap horizontal à gauche contre {h.name}");
+                return;
             }
         }
     }
-
-    void SnapToTarget(Collider2D hit, Vector2 dir)
+    void HandleBlockRotation()
     {
-        Bounds hitBounds = hit.bounds;
-        Bounds ourBounds = currentBlock.GetComponent<Collider2D>().bounds;
+        currentBlock.transform.Rotate(0, 0, -90f);
+        Debug.Log("🔄 Rotation 90°!");
+    }
 
-        Vector3 newPos = currentBlock.transform.position;
-
-        if (dir == Vector2.right)
-            newPos.x = hitBounds.min.x - ourBounds.size.x / 2f;
-        else if (dir == Vector2.left)
-            newPos.x = hitBounds.max.x + ourBounds.size.x / 2f;
-        else if (dir == Vector2.down)
-            newPos.y = hitBounds.max.y + ourBounds.size.y / 2f;
-        else if (dir == Vector2.up)
-            newPos.y = hitBounds.min.y - ourBounds.size.y / 2f;
-
-        currentBlock.transform.position = new Vector3(newPos.x, newPos.y, -1);
-        Debug.Log("✅ Snap à " + dir);
+    void InstantiateAndPrepare(GameObject prefab, Vector3? scaleOverride = null)
+    {
+        var obj = Instantiate(prefab, persistentBlockContainer);
+        obj.transform.position = new Vector3(0, 0, -1);
+        obj.transform.localScale = scaleOverride ?? currentScale;
+        currentBlock = obj;
+        currentBlock.tag = prefab.tag;
+        isPlacingBlock = true;
     }
 
     public void Save()
     {
-        // TODO : Sauvegarde du niveau
+        // TODO
     }
 
     #endregion
diff --git a/Assets/Scripts/PlayerCamera.cs b/Assets/Scripts/PlayerCamera.cs
index 42aa58e..d09c8d7 100644
--- a/Assets/Scripts/PlayerCamera.cs
+++ b/Assets/Scripts/PlayerCamera.cs
@@ -18,25 +18,29 @@ public class PlayerCamera : MonoBehaviour
 
     private void Update()
     {
-        if (isPlaying)
-        {
-            Player player = playerObject.GetComponent<Player>();
+        if (!isPlaying) return;
 
-            float minYFollow = normalMinYFollow;
-            if (player.CurrentGameMode is ShipGameMode)
-            {
-                minYFollow = shipMinYFollow;
-            }
+        Player player = playerObject.GetComponent<Player>();
 
-            float targetY = initialY;
-            if (playerObject.transform.position.y > minYFollow)
-            {
-                targetY = playerObject.transform.position.y;
-            }
+        // Choix du minY selon le mode de jeu
+        float minYFollow = (player.CurrentGameMode is ShipGameMode)
+            ? shipMinYFollow
+            : normalMinYFollow;
 
-            float newY = Mathf.Lerp(transform.position.y, targetY, smoothSpeed * Time.deltaTime);
+        // Calcul de la cible Y
+        float targetY = initialY;
+        if (playerObject.transform.position.y > minYFollow)
+            targetY = playerObject.transform.position.y;
 
-            transform.position = new Vector3(playerObject.transform.position.x, newY, transform.position.z);
-        }
+        // Interpolation douce
+        float newY = Mathf.Lerp(transform.position.y, targetY, smoothSpeed * Time.deltaTime);
+
+        // Clamp pour éviter de descendre sous Y = 0
+        newY = Mathf.Max(newY, 0f);
+
+        // On suit aussi l'axe X du joueur
+        float newX = playerObject.transform.position.x;
+
+        transform.position = new Vector3(newX, newY, transform.position.z);
     }
 }