tilemap-editor 4.3.9__tar.gz → 5.0.0__tar.gz

{tilemap_editor-4.3.9 → tilemap_editor-5.0.0}/CHANGELOG.md

@@ -1,6 +1,40 @@
 # Changelog
 
 <!-- towncrier release notes start -->
+# tilemap_editor 5.0.0 (2026-08-25)
+
+## What's New
+
+- **Try maps safely in a sandbox** — open an external map in an isolated workspace, experiment, then export it to your project when ready. Your original project stays untouched if the export has a problem, and images are copied alongside the new map automatically.
+- **Drag & drop images into the sprite editor** — drop files from your desktop or copy a file path and paste (`Cmd/Ctrl+V`). New sheets are added next to your current work without overwriting it, and you can undo. Works with filenames that have spaces and with shared network drives on Windows.
+- **Smarter sprite sheets** — sheets stack neatly (stack vertically or horizontally), filenames sort naturally (`s1, s2, s10` not `s1, s10, s2`), and the canvas grows automatically when you paste outside it. Move, select, and add text directly on the canvas.
+- **Cleaner animation editing** — smoother zoom/pan gestures and clearer controls for frame size (`px` or `cells`).
+- **Organize tilesets** — group tilesets into folders, keep missing images as placeholders so your map doesn't scramble, and pick the draw order with y-sort.
+
+## Fixes & Polish
+
+- Saving is now safer — the editor checks for problems before writing and keeps your project intact if something fails.
+- Sprite editor feels smoother: canvas sizing, undo/redo, and switching tools no longer conflict with typing.
+- Better look and feel: updated themes, tidier toolbars, and a draggable splitter between panels.
+
+## Breaking Changes
+
+- No intentional breaking changes yet — file format and workflow stay compatible with `4.x`. Any required migration steps will be listed here before `5.0.0` ships.
+
+## Upgrading from 4.x
+
+- Just update — no steps needed yet. If you use maps with missing tilesets, they now stay in place as placeholders instead of shifting other tiles.
+
+# tilemap_editor 4.4.0 (2026-08-19)
+
+## Features
+
+- Property editor: added a remove button for individual properties and object-level property support. Right-clicking a map object, tileset image, or tree row now opens the property editor through a context dispatch system, and object properties can be edited on the placed object directly. (context-property-editor)
+
+## Bug Fixes
+
+- Object picking on object layers now hits the visually topmost overlapping object: right-click property open and left-click variant select test objects in reverse draw order. (object-pick-order)
+
 # tilemap_editor 4.3.9 (2026-08-04)
 
 ## Bug Fixes

{tilemap_editor-4.3.9/src/tilemap_editor.egg-info → tilemap_editor-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 4.3.9
+Version: 5.0.0
 Summary: Pygame tilemap editor with collision, animation, sprite & particle tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-4.3.9 → tilemap_editor-5.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "4.3.9"
+version = "5.0.0"
 description = "Pygame tilemap editor with collision, animation, sprite & particle tools"
 readme = "README.md"
 requires-python = ">=3.11"

{tilemap_editor-4.3.9 → tilemap_editor-5.0.0}/src/editor.py

@@ -2,6 +2,7 @@ import json
 import logging
 import os
 import queue
+import shutil
 import subprocess
 import sys
 import threading
@@ -21,6 +22,7 @@ from constants import BASE_PATH
 from node_manager import NodeManager
 from tilemap import Tilemap
 from utils import error_context, error_handler
+from utils.context_dispatch import PropertyContextDispatcher
 from utils.property_suggestions import PropertySuggestionRegistry
 from utils.standalone import launch_standalone
 from widgets.autotiler import AutotileRuleDesigner
@@ -157,17 +159,42 @@ def _load_project_config() -> tuple[Path, Path, dict]:
 _launch_standalone_module = launch_standalone
 
 
+def _display_load_path(path: Path) -> Path:
+    """Path shown in the SANDBOX load toast: CWD-relative when possible."""
+    try:
+        return path.resolve().relative_to(Path.cwd())
+    except ValueError:
+        return path
+
+
 class Editor:
     def __init__(
         self,
         size: tuple[int, int] | None = None,
         fps=60,
         theme: str | None = None,
+        sandbox_dir: Path | None = None,
     ):
         self.base_path, self.data_root, self.config = _load_project_config()
         logger.info(f"Project base_path: {self.base_path}")
         logger.info(f"Data root: {self.data_root}")
 
+        self.is_sandbox = sandbox_dir is not None
+        self._project_data_root = self.data_root
+        self._sandbox_root: Path | None = None
+        self._sandbox_map_path: Path | None = None
+        if sandbox_dir is not None:
+            sandbox = Path(sandbox_dir)
+            self._sandbox_root = sandbox
+            self._sandbox_map_path = sandbox / "map.json"
+            self.data_root = sandbox
+            log_root = sandbox / "logs"
+            log_root.mkdir(parents=True, exist_ok=True)
+            from utils.error_handler import init_error_handler
+
+            init_error_handler(log_root=log_root, config=self.config["error_handler"])
+            logger.info(f"Sandbox mode: data_root redirected to {sandbox}")
+
         theme_name = theme or self.config.get("theme", "dark")
         tm = get_theme_manager()
         if not tm.set_theme(theme_name):
@@ -175,7 +202,9 @@ class Editor:
             tm.set_theme("dark")
 
         pygame.init()
-        pygame.display.set_caption("Pure Pygame Editor")
+        pygame.display.set_caption(
+            "Tilemap Editor - SANDBOX" if self.is_sandbox else "Pure Pygame Editor"
+        )
 
         self.fps = fps
         self.running = False
@@ -214,6 +243,7 @@ class Editor:
         self.notifications = NotificationManager(self)
         self.tooltip = TooltipManager()
         self.suggestion_registry = PropertySuggestionRegistry()
+        self.context_dispatch = PropertyContextDispatcher()
         self.error_console_process: subprocess.Popen | None = None
         self.property_editor: PropertyEditor | None = None
         self.particle_config_dialog: ParticleConfigDialog | None = None
@@ -448,16 +478,199 @@ class Editor:
 
     def do_save_as(self, filename: str):
         try:
+            if self.is_sandbox:
+                target = self._project_data_root / filename
+                self._sandbox_save_as(target)
+                return
             self.tilemap.save_map(filename)
         except Exception as e:
             error_handler.capture(e, context="save_map_as")
 
     def on_map_save_selected(self, path: Path):
         try:
+            if self.is_sandbox:
+                self._sandbox_save_as(path)
+                return
             self.tilemap.save_map(path)
         except Exception as e:
             error_handler.capture(e, context="save_map_selected")
 
+    def _sandbox_save_as(self, path: Path):
+        """Save As from sandbox: copy assets into the target map dir first.
+
+        Assets must land next to the saved map BEFORE save_map runs, and each
+        loaded tileset path must be re-pointed at the copied file, so the saved
+        JSON gets clean project-relative 'assets/...' paths instead of
+        '../sandbox/...' escapes.
+        """
+        assets_src = self._sandbox_root / "assets"
+        if not assets_src.is_dir():
+            self.notifications.error("Export failed", "No assets/ directory in sandbox")
+            return
+        assets_dst = Path(path).parent / "assets"
+        conflicts = []
+        if assets_dst.is_dir():
+            conflicts = [p.name for p in assets_src.iterdir() if p.is_file() and (assets_dst / p.name).exists()]
+        if conflicts:
+            names = ", ".join(sorted(conflicts)[:5])
+            more = f" (+{len(conflicts) - 5} more)" if len(conflicts) > 5 else ""
+            self.confirm_dialog.show(
+                title="Overwrite Assets?",
+                message=(
+                    f"{len(conflicts)} asset file(s) already exist in {assets_dst.name}/: "
+                    f"{names}{more}\nThey will be overwritten by the sandbox copies."
+                ),
+                on_confirm=lambda: self._sandbox_export_map(path, assets_src, assets_dst),
+                on_cancel=lambda: None,
+            )
+            return
+        self._sandbox_export_map(path, assets_src, assets_dst)
+
+    def _sandbox_export_map(self, path: Path, assets_src: Path, assets_dst: Path):
+        redirected: list[tuple[object, Path]] = []
+        newly_copied: list[Path] = []
+        # Snapshot staged outputs before any writes
+        map_existed = path.exists()
+        try:
+            proj_nodes_dir = self._project_data_root / self.config.get(
+                "nodes_path", "nodes"
+            )
+            sidecar_path = proj_nodes_dir / f"{path.stem}.nodes.json"
+            sidecar_existed = sidecar_path.exists()
+        except Exception:
+            sidecar_path = None
+            sidecar_existed = False
+        try:
+            assets_dst.mkdir(parents=True, exist_ok=True)
+            for src in assets_src.iterdir():
+                if src.is_file():
+                    dst = assets_dst / src.name
+                    existed = dst.exists()
+                    shutil.copy2(src, dst)
+                    if not existed:
+                        newly_copied.append(dst)
+
+            ts_widget = getattr(self, "tileset_widget", None)
+            if ts_widget is not None and self._sandbox_root is not None:
+                sandbox_root = self._sandbox_root.resolve()
+                for ts in ts_widget.tilesets:
+                    ts_path = getattr(ts, "path", None)
+                    if ts_path is None:
+                        continue
+                    try:
+                        inside_sandbox = ts_path.resolve().is_relative_to(sandbox_root)
+                    except OSError:
+                        inside_sandbox = False
+                    if inside_sandbox:
+                        redirected.append((ts, Path(ts_path)))
+                        ts.path = assets_dst / ts_path.name
+
+            # Restore real-data context BEFORE saving so the node sidecar is
+            # written next to the exported map (NodeManager falls back to
+            # <map>.nodes.json once the sandbox pointer is cleared).  Prior
+            # state is reinstated if the save fails.
+            prev_data_root = self.data_root
+            prev_is_sandbox = self.is_sandbox
+            prev_nodes_dir = (
+                getattr(self.node_manager, "_nodes_dir", None)
+                if hasattr(self, "node_manager")
+                else None
+            )
+            prev_active_sidecar = getattr(
+                self.node_manager, "_active_sidecar", None
+            )
+            prev_project_path = self.tilemap.active_project_path
+            self.data_root = self._project_data_root
+            self.is_sandbox = False
+            if hasattr(self, "node_manager"):
+                self.node_manager.reset_nodes_dir()
+
+            try:
+                ok = self.tilemap.save_map(path)
+                if not ok:
+                    self.data_root = prev_data_root
+                    self.is_sandbox = prev_is_sandbox
+                    if hasattr(self, "node_manager"):
+                        self.node_manager._nodes_dir = prev_nodes_dir
+                        self.node_manager._active_sidecar = prev_active_sidecar
+                    self.tilemap.active_project_path = prev_project_path
+                    for ts, original in redirected:
+                        try:
+                            ts.path = original
+                        except Exception:
+                            pass
+                    # Remove staged outputs created for this export
+                    if not map_existed:
+                        try:
+                            path.unlink(missing_ok=True)
+                        except Exception:
+                            pass
+                    if sidecar_path is not None and not sidecar_existed:
+                        try:
+                            sidecar_path.unlink(missing_ok=True)
+                        except Exception:
+                            pass
+                    for dst in newly_copied:
+                        try:
+                            dst.unlink(missing_ok=True)
+                        except Exception:
+                            pass
+                    return
+            except Exception:
+                self.data_root = prev_data_root
+                self.is_sandbox = prev_is_sandbox
+                if hasattr(self, "node_manager"):
+                    self.node_manager._nodes_dir = prev_nodes_dir
+                    self.node_manager._active_sidecar = prev_active_sidecar
+                self.tilemap.active_project_path = prev_project_path
+                if not map_existed:
+                    try:
+                        path.unlink(missing_ok=True)
+                    except Exception:
+                        pass
+                if sidecar_path is not None and not sidecar_existed:
+                    try:
+                        sidecar_path.unlink(missing_ok=True)
+                    except Exception:
+                        pass
+                for dst in newly_copied:
+                    try:
+                        dst.unlink(missing_ok=True)
+                    except Exception:
+                        pass
+                raise
+
+            self.notifications.success(f"Exported to {path.name}")
+            logger.info(f"Sandbox session exported to {path}; data_root restored to {self.data_root}")
+        except Exception as e:
+            # undo path redirection so the editor keeps working off the sandbox
+            for ts, original in redirected:
+                try:
+                    ts.path = original
+                except Exception:
+                    error_handler.capture(e, context="sandbox_restore_paths")
+            # Remove staged outputs that were newly created for this export
+            for dst in newly_copied:
+                try:
+                    dst.unlink(missing_ok=True)
+                except Exception:
+                    pass
+            if not map_existed:
+                try:
+                    path.unlink(missing_ok=True)
+                except Exception:
+                    pass
+            if sidecar_path is not None and not sidecar_existed:
+                try:
+                    sidecar_path.unlink(missing_ok=True)
+                except Exception:
+                    pass
+            error_handler.capture(e, context="sandbox_export")
+            self.notifications.error(
+                "Export failed",
+                f"{e} Copied asset files may remain in {assets_dst}.",
+            )
+
     def export_selection_as_png(self):
         if self.tile_grid_widget is None:
             self.notifications.notify("No tile grid available", duration=2.0)
@@ -570,6 +783,10 @@ class Editor:
         try:
             self.handle_resize(self.width, self.height)
             self.tilemap.apply_map_payload(path, payload_or_error)
+            if getattr(self, "is_sandbox", False):
+                self.notifications.notify(
+                    f"SANDBOX map loaded: {path.name}", duration=4.0
+                )
         except Exception as e:
             error_handler.capture(e, context="load_map_apply")
             import traceback
@@ -613,11 +830,8 @@ class Editor:
         self.width = width
         self.height = height
 
-        menu_h = 30
-        toolbar_h = 35
-
         if hasattr(self, "menubar") and self.menubar:
-            self.menubar.resize(width)
+            self.menubar.resize(0, 0, width, self.menubar.rect.height)
 
         if hasattr(self, "toolbar") and self.toolbar:
             self.toolbar.resize(width)
@@ -1263,6 +1477,18 @@ class Editor:
     def run(self):
         self.running = True
         frame_count = 0
+        if self._sandbox_map_path is not None:
+            map_path = self._sandbox_map_path
+            self._sandbox_map_path = None
+            try:
+                if map_path.is_file():
+                    self.start_async_load_map(map_path)
+                    self.notifications.notify(
+                        f"SANDBOX mode: loading {_display_load_path(map_path)}...",
+                        duration=4.0,
+                    )
+            except Exception as e:
+                logger.warning(f"Sandbox auto-load failed: {e}")
         while self.running:
             self._poll_async_load()
             self._poll_file_manager_result()
@@ -1291,14 +1517,14 @@ class Editor:
             if self.autotiler:
                 if self.autotiler.visible:
                     overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
-                    overlay.fill((0, 0, 0, 100))
+                    overlay.fill((*COLORS.overlay, 100))
                     self.screen.blit(overlay, (0, 0))
                 self.autotiler.draw(self.screen)
 
             if self.regex_automap_designer:
                 if self.regex_automap_designer.visible:
                     overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
-                    overlay.fill((0, 0, 0, 100))
+                    overlay.fill((*COLORS.overlay, 100))
                     self.screen.blit(overlay, (0, 0))
                 self.regex_automap_designer.draw(self.screen)
 
@@ -1306,7 +1532,7 @@ class Editor:
 
             if self.map_setup_widget and self.map_setup_widget.visible:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
-                overlay.fill((0, 0, 0, 150))
+                overlay.fill((*COLORS.overlay, 140))
                 self.screen.blit(overlay, (0, 0))
                 self.map_setup_widget.draw(self.screen)
 
@@ -1317,25 +1543,25 @@ class Editor:
                 self.save_input.draw(self.screen)
             if self.tileset_type_dialog.active:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
-                overlay.fill((0, 0, 0, 150))
+                overlay.fill((*COLORS.overlay, 140))
                 self.screen.blit(overlay, (0, 0))
                 self.tileset_type_dialog.draw(self.screen)
             if self.resize_map_dialog and self.resize_map_dialog.active:
                 self.resize_map_dialog.draw(self.screen)
             if self.layer_type_dialog.active:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
-                overlay.fill((0, 0, 0, 150))
+                overlay.fill((*COLORS.overlay, 140))
                 self.screen.blit(overlay, (0, 0))
                 self.layer_type_dialog.draw(self.screen)
             if self.confirm_dialog.active:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
-                overlay.fill((0, 0, 0, 150))
+                overlay.fill((*COLORS.overlay, 140))
                 self.screen.blit(overlay, (0, 0))
                 self.confirm_dialog.draw(self.screen)
 
             if self.loading_state["active"]:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
-                overlay.fill((0, 0, 0, 180))
+                overlay.fill((*COLORS.overlay, 170))
                 self.screen.blit(overlay, (0, 0))
 
                 msg = self.loading_state.get("message", "Loading...")

{tilemap_editor-4.3.9 → tilemap_editor-5.0.0}/src/node_manager.py

@@ -25,6 +25,7 @@ class NodeManager:
         self.groups: list[str] = []
         self.default_node_type: str = "area"
         self._nodes_dir: Path | None = None
+        self._active_sidecar: Path | None = None
 
     @property
     def nodes_dir(self) -> Path:
@@ -34,6 +35,11 @@ class NodeManager:
             self._nodes_dir = self.editor.data_root / rel
         return self._nodes_dir
 
+    def reset_nodes_dir(self) -> None:
+        """Drop the cached dir so the next access re-derives from data_root."""
+        self._nodes_dir = None
+        self._active_sidecar = None
+
     def _sidecar_path_for(self, map_path: Path) -> Path:
         return self.nodes_dir / f"{map_path.stem}.nodes.json"
 
@@ -42,9 +48,16 @@ class NodeManager:
         self.groups.clear()
         self.active_node_id = None
         self.active_group_name = None
+        self._active_sidecar: Path | None = None
         sidecar = self._sidecar_path_for(map_path)
         if not sidecar.is_file():
-            return
+            fallback = map_path.parent / f"{map_path.stem}.nodes.json"
+            if fallback.is_file():
+                sidecar = fallback
+            else:
+                self._active_sidecar = None
+                return
+        self._active_sidecar = sidecar
         try:
             raw = json.loads(sidecar.read_text(encoding="utf-8"))
             if not isinstance(raw, dict):
@@ -65,7 +78,13 @@ class NodeManager:
             logging.warning(f"Failed to load nodes from {sidecar}")
 
     def save(self, map_path: Path) -> None:
-        sidecar = self._sidecar_path_for(map_path)
+        # Trust the loaded sidecar only while it IS the canonical one for the
+        # requested map.  A diverged pointer (e.g. left over from a sandbox
+        # session) must never swallow writes aimed elsewhere: after an export
+        # the canonical location wins so the sandbox copy stays frozen.
+        fallback = self._sidecar_path_for(map_path)
+        active = self._active_sidecar
+        sidecar = fallback if (active is None or active != fallback) else active
         self.nodes_dir.mkdir(parents=True, exist_ok=True)
         rs = self.editor.tilemap.render_scale
         orig_areas: dict[str, tuple[int, int]] = {}
@@ -73,14 +92,20 @@ class NodeManager:
             orig_areas[nid] = (node.area.x, node.area.y)
             node.area.x = int(node.area.x / rs)
             node.area.y = int(node.area.y / rs)
+        tmp_sidecar = sidecar.with_name(f".{sidecar.name}.tmp")
         try:
             data: dict[str, Any] = {
                 "version": SIDECAR_VERSION,
                 "groups": self.groups,
                 "nodes": [node.to_dict() for node in self.nodes.values()],
             }
-            sidecar.write_text(json.dumps(data, indent=2), encoding="utf-8")
+            tmp_sidecar.write_text(json.dumps(data, indent=2), encoding="utf-8")
+            tmp_sidecar.replace(sidecar)
         finally:
+            try:
+                tmp_sidecar.unlink(missing_ok=True)
+            except Exception:
+                pass
             for nid, (ox, oy) in orig_areas.items():
                 self.nodes[nid].area.x = ox
                 self.nodes[nid].area.y = oy

{tilemap_editor-4.3.9 → tilemap_editor-5.0.0}/src/plugins/character_collision/editor.py

@@ -1,6 +1,7 @@
 
 from __future__ import annotations
 
+import os
 import re
 from pathlib import Path
 
@@ -119,16 +120,41 @@ class CharacterCollisionEditor:
             x += 100 + 8
 
     def _rel_path(self, path: Path) -> str:
+        resolved = path.resolve()
         try:
-            return str(path.relative_to(self._data_root)) if self._data_root else str(path.resolve())
+            if self._data_root:
+                rel = os.path.relpath(resolved, self._data_root.resolve())
+                # relpath happily emits '../' escapes for paths outside the
+                # root — only trust the relative form when it stays inside
+                if not rel.split(os.sep)[0].startswith(".."):
+                    return rel
+            return str(resolved)
         except ValueError:
-            return str(path.resolve())
+            return str(resolved)
 
-    def _resolve_image_path(self, image_path: str) -> Path | None:
+    def _resolve_image_path(
+        self, image_path: str, base: Path | None = None
+    ) -> Path | None:
+        """Resolve an image reference, mirroring animation runtime_load.
+
+        Tries, in order: relative to *base* and each of its ancestors (the
+        collision file's directory, so ``../../`` refs resolve), relative to
+        the data root, then CWD-relative / absolute as-is.
+        """
         p = Path(image_path)
-        if not p.is_absolute() and self._data_root:
-            p = self._data_root / p
-        return p if p.exists() else None
+        if p.is_absolute():
+            return p if p.exists() else None
+        candidates: list[Path] = []
+        if base is not None:
+            candidates.append(base / p)
+            candidates.extend(parent / p for parent in base.parents)
+        if self._data_root is not None:
+            candidates.append(self._data_root / p)
+        candidates.append(p)
+        for cand in candidates:
+            if cand.exists():
+                return cand
+        return None
 
     def _load_sprite_from_path(self, path: Path) -> bool:
         try:
@@ -297,8 +323,14 @@ class CharacterCollisionEditor:
             },
         )
 
-    def load_collision_data(self, data: CharacterCollisionData) -> None:
-        """Load collision data + auto-resolve sprite from image_path"""
+    def load_collision_data(
+        self, data: CharacterCollisionData, resolve_base: Path | None = None
+    ) -> None:
+        """Load collision data + auto-resolve sprite from image_path.
+
+        resolve_base: directory the image_path is relative to (the loaded
+        collision file's parent); falls back to the data root.
+        """
         self.character_name = data.name
         self._name_input.text = data.name
         self._name_input.cursor_pos = len(data.name)
@@ -309,9 +341,10 @@ class CharacterCollisionEditor:
 
         self._image_path = data.image_path
         if self._image_path:
-            resolved = self._resolve_image_path(self._image_path)
+            resolved = self._resolve_image_path(self._image_path, base=resolve_base)
             if resolved:
                 self._load_sprite_from_path(resolved)
+                self._image_path = self._rel_path(resolved)
                 self._toast_manager.success(f"Sprite loaded: {resolved.name}")
 
         self.shape_editor.load_shape_data(data.shape.to_dict())
@@ -392,7 +425,7 @@ class CharacterCollisionEditor:
                 data_dict = json.load(f)
             self._validate_collision_data(data_dict)
             data = CharacterCollisionData.from_dict(data_dict)
-            self.load_collision_data(data)
+            self.load_collision_data(data, resolve_base=path.parent)
         except json.JSONDecodeError:
             raise ValueError("Invalid collision file: not valid JSON") from None
         except KeyError as e:
@@ -423,8 +456,6 @@ class CharacterCollisionEditor:
                 return True
             return True
 
-        mouse = pygame.mouse.get_pos()
-
         if self.layer_sidebar.handle_event(event):
             return True
 

{tilemap_editor-4.3.9 → tilemap_editor-5.0.0}/src/plugins/object_tileset_collision/editor.py

@@ -729,7 +729,7 @@ class ObjectTilesetCollisionEditor:
             return
 
         overlay = Surface(screen.get_size(), pygame.SRCALPHA)
-        overlay.fill((0, 0, 0, 180))
+        overlay.fill((*COLORS.overlay, 170))
         screen.blit(overlay, (0, 0))
 
         panel_w = 500