tilemap-editor 3.2.5__tar.gz → 3.2.7__tar.gz

{tilemap_editor-3.2.5/src/tilemap_editor.egg-info → tilemap_editor-3.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 3.2.5
+Version: 3.2.7
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-3.2.5 → tilemap_editor-3.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.2.5"
+version = "3.2.7"
 description = "Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools"
 readme = "README.md"
 requires-python = ">=3.10"

{tilemap_editor-3.2.5 → tilemap_editor-3.2.7}/src/editor.py

@@ -27,6 +27,7 @@ from widgets.tile_grid import TileGrid
 from widgets.layer_selector import LayerSelector
 from widgets.ui.fileinput import FilenameInput
 from widgets.ui.tileset_type_dialog import TilesetTypeDialog
+from widgets.ui.confirm_dialog import ConfirmDialog
 from widgets.ui.layer_type_dialog import LayerTypeDialog
 from widgets.ui.menubar import MenuBar
 from widgets.ui.toolbar import Toolbar
@@ -208,6 +209,7 @@ class Editor:
             on_cancel=lambda: None,
         )
         self.tileset_type_dialog = TilesetTypeDialog(editor_rect)
+        self.confirm_dialog = ConfirmDialog(editor_rect)
         self.layer_type_dialog = LayerTypeDialog(editor_rect)
 
         self.menubar = MenuBar(self, self.width, 30)
@@ -542,6 +544,8 @@ class Editor:
 
         if hasattr(self, "tileset_type_dialog") and self.tileset_type_dialog:
             self.tileset_type_dialog.editor_rect = rect_full
+        if hasattr(self, "confirm_dialog") and self.confirm_dialog:
+            self.confirm_dialog.editor_rect = rect_full
         if hasattr(self, "layer_type_dialog") and self.layer_type_dialog:
             self.layer_type_dialog.editor_rect = rect_full
 
@@ -1052,6 +1056,10 @@ class Editor:
                 self.tileset_type_dialog.handle_event(event)
                 continue
 
+            if self.confirm_dialog.active:
+                self.confirm_dialog.handle_event(event)
+                continue
+
             if self.layer_type_dialog.active:
                 self.layer_type_dialog.handle_event(event)
                 continue
@@ -1261,6 +1269,11 @@ class Editor:
                 overlay.fill((0, 0, 0, 150))
                 self.screen.blit(overlay, (0, 0))
                 self.tileset_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))
+                self.screen.blit(overlay, (0, 0))
+                self.confirm_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))

{tilemap_editor-3.2.5 → tilemap_editor-3.2.7}/src/plugins/character_collision/shape_editor.py

@@ -294,8 +294,8 @@ class ShapeEditor:
                     self._dragging_shape = False
                     return True
                 
-                # Check if clicking on move icon
-                if self._is_on_move_icon(mouse) and not self._pan_mode:
+                # Check if clicking inside the shape body (but not on a handle)
+                if self._is_inside_shape(mouse) and not self._pan_mode:
                     self._dragging_shape = True
                     self._drag_start = mouse
                     self._save_shape_positions()
@@ -462,7 +462,7 @@ class ShapeEditor:
         elif self.shape_type == "circle":
             return self._sprite_to_screen((self.circle_x, self.circle_y - self.circle_radius))
         elif self.shape_type == "capsule":
-            return self._sprite_to_screen((self.capsule_x, self.capsule_y))
+            return self._sprite_to_screen((self.capsule_x, self.capsule_y + self.capsule_height / 2))
         elif self.shape_type == "polygon" and len(self.polygon_vertices) >= 3:
             # Top-center of polygon bounding box
             min_y = min(v[1] for v in self.polygon_vertices)

{tilemap_editor-3.2.5 → tilemap_editor-3.2.7}/src/plugins/sprite_animation/editor.py

@@ -168,6 +168,7 @@ class SpriteAnimationEditor:
         self.timeline.on_frames_changed = self._on_frames_changed
         self.timeline.on_markers_changed = self._on_markers_changed
         self.preview.on_playback_fps_changed = self._on_preview_fps_changed
+        self.preview.on_loop_changed = self._on_preview_loop_changed
 
         # Create a default animation (now safe — widgets exist)
         self._create_new_animation("idle")
@@ -1566,6 +1567,12 @@ class SpriteAnimationEditor:
             self.preview.authoring_fps = float(fps)
             self._notify_animation_modified()
 
+    def _on_preview_loop_changed(self, loop: bool) -> None:
+        anim = self._get_active()
+        if anim:
+            anim.loop = loop
+            self._notify_animation_modified()
+
     def _metadata_apply_add(self, anim: Animation) -> None:
         key = self._meta_key_input.strip()
         if not key:

{tilemap_editor-3.2.5 → tilemap_editor-3.2.7}/src/plugins/sprite_animation/preview.py

@@ -58,10 +58,13 @@ class AnimationPreview:
         self.frames: List[AnimationFrame] = []
         self.playing = False
         self.loop = True
+        self.grid_offset_x: int = 0
+        self.grid_offset_y: int = 0
         self.playback_fps: float = 60.0
         self.show_onion = False
 
         self.on_playback_fps_changed: Optional[Callable[[float], None]] = None
+        self.on_loop_changed: Optional[Callable[[bool], None]] = None
         self.authoring_fps: float = 60.0
 
         self.current_frame: int = 0
@@ -221,6 +224,8 @@ class AnimationPreview:
                 return True
             if self._btn_loop.collidepoint(mouse):
                 self.loop = not self.loop
+                if self.on_loop_changed:
+                    self.on_loop_changed(self.loop)
                 return True
             if self._btn_onion.collidepoint(mouse):
                 self.show_onion = not self.show_onion
@@ -411,10 +416,12 @@ class AnimationPreview:
 
     def _extract_tile(self, variant_id: int) -> Optional[pygame.Surface]:
         tw, th = self.tile_size
-        cols = max(1, self.surface.get_width() // tw)
+        ox, oy = self.grid_offset_x, self.grid_offset_y
+        available_w = self.surface.get_width() - ox
+        cols = max(1, available_w // tw)
         col = variant_id % cols
         row = variant_id // cols
-        src = Rect(col * tw, row * th, tw, th)
+        src = Rect(ox + col * tw, oy + row * th, tw, th)
         if self.surface.get_rect().contains(src):
             return self.surface.subsurface(src).copy()
         return None

{tilemap_editor-3.2.5 → tilemap_editor-3.2.7/src/tilemap_editor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 3.2.5
+Version: 3.2.7
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-3.2.5 → tilemap_editor-3.2.7}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -164,6 +164,7 @@ src/widgets/tile_grid.py
 src/widgets/tile_selector.py
 src/widgets/ui/collision_layer_mask.py
 src/widgets/ui/collision_layer_sidebar.py
+src/widgets/ui/confirm_dialog.py
 src/widgets/ui/draw_utils.py
 src/widgets/ui/fileinput.py
 src/widgets/ui/layer_type_dialog.py

{tilemap_editor-3.2.5 → tilemap_editor-3.2.7}/src/widgets/tile_grid.py

@@ -499,8 +499,10 @@ class TileGrid:
         start_sy = src_rect[1] // tile_h
 
         if active_layer.layer_type == "object":
-            pixel_x = self.hover_cell[0] * tile_w
-            pixel_y = self.hover_cell[1] * tile_h
+            mouse_pos = pygame.mouse.get_pos()
+            world_x, world_y = self.screen_to_world(mouse_pos)
+            pixel_x = world_x
+            pixel_y = world_y
             pixel_w = sel_w_tiles * tile_w
             pixel_h = sel_h_tiles * tile_h
 
@@ -1040,13 +1042,14 @@ class TileGrid:
 
         if active_layer.layer_type == "object":
             mouse_pos = pygame.mouse.get_pos()
-            self.screen_to_world(mouse_pos)
+            world_x, world_y = self.screen_to_world(mouse_pos)
+            rs = self.editor.tilemap.render_scale
 
-            sel_width = int(src_rect[2] * self.zoom_level)
-            sel_height = int(src_rect[3] * self.zoom_level)
+            sel_width = int(src_rect[2] * rs * self.zoom_level)
+            sel_height = int(src_rect[3] * rs * self.zoom_level)
 
-            screen_x = mouse_pos[0]
-            screen_y = mouse_pos[1]
+            screen_x = (world_x - self.scroll_x) * self.zoom_level + self.rect.x
+            screen_y = (world_y - self.scroll_y) * self.zoom_level + self.rect.y
 
             dest_rect = Rect(screen_x, screen_y, sel_width, sel_height)
             pygame.draw.rect(screen, (255, 255, 0), dest_rect, 2)
@@ -1336,12 +1339,12 @@ class TileGrid:
                         src_rect = Rect(src_x, src_y, obj_w, obj_h)
 
                     dest_x = (
-                        (obj_x * rs - self.scroll_x) * self.zoom_level
+                        (obj_x - self.scroll_x) * self.zoom_level
                         + self.rect.x
                         + draw_offset_x
                     )
                     dest_y = (
-                        (obj_y * rs - self.scroll_y) * self.zoom_level
+                        (obj_y - self.scroll_y) * self.zoom_level
                         + self.rect.y
                         + draw_offset_y
                     )
@@ -1565,11 +1568,11 @@ class TileGrid:
                 new_x = area["x"] + dx
                 new_y = area["y"] + dy
                 dest_x = (
-                    (new_x * rs - self.scroll_x) * self.zoom_level
+                    (new_x - self.scroll_x) * self.zoom_level
                     + self.rect.x
                 )
                 dest_y = (
-                    (new_y * rs - self.scroll_y) * self.zoom_level
+                    (new_y - self.scroll_y) * self.zoom_level
                     + self.rect.y
                 )
 

{tilemap_editor-3.2.5 → tilemap_editor-3.2.7}/src/widgets/tile_selector.py

@@ -61,6 +61,7 @@ class TileSelector:
         self.zoom: float = 1.0
 
         btn_y = y + h - 35
+        self.btn_export = Rect(x + w - 140, btn_y, 30, 30)
         self.btn_collision = Rect(x + w - 105, btn_y, 30, 30)
         self.btn_add = Rect(x + w - 70, btn_y, 30, 30)
         self.btn_rem = Rect(x + w - 35, btn_y, 30, 30)
@@ -80,6 +81,7 @@ class TileSelector:
             x, y + self.top_bar_h, w, h - self.top_bar_h - self.btm_bar_h
         )
         btn_y = y + h - 35
+        self.btn_export = Rect(x + w - 140, btn_y, 30, 30)
         self.btn_collision = Rect(x + w - 105, btn_y, 30, 30)
         self.btn_add = Rect(x + w - 70, btn_y, 30, 30)
         self.btn_rem = Rect(x + w - 35, btn_y, 30, 30)
@@ -162,6 +164,9 @@ class TileSelector:
             return True
 
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+            if self.btn_export.collidepoint(mouse_pos):
+                self._export_selected_as_png_dialog()
+                return True
             if self.btn_collision.collidepoint(mouse_pos):
                 self.open_collision_editor()
                 return True
@@ -246,6 +251,11 @@ class TileSelector:
                     ts.offset[1] += event.y * 20
                 return True
 
+        elif event.type == pygame.KEYDOWN and event.key == pygame.K_e:
+            if self.selected_tile and self.active_idx != -1:
+                self._export_selected_as_png_dialog()
+                return True
+
         return False
 
     def update_selection_rect(self, current_grid: Tuple[int, int]):
@@ -348,66 +358,56 @@ class TileSelector:
         if path.exists():
             try:
                 surf = pygame.image.load(path).convert_alpha()
-                if tileset_type == "object" or is_image_multipleof(
-                    surf.get_size(), self.editor.tilemap.tile_size
-                ):
-                    tileset_data = TilesetData(
-                        path.name, path, surf, tileset_type=tileset_type
-                    )
-                    tileset_data.properties = properties
-                    # Convert string keys back to int if necessary
-                    tileset_data.tile_properties = {
-                        int(k): v for k, v in tile_properties.items()
-                    }
-                    self._load_collision_data_for_tileset(tileset_data)
-
-                    self.tilesets.append(tileset_data)
-                    self.active_idx = len(self.tilesets) - 1
-                    self.tileset_map[self.active_idx] = tileset_data
-                    if tileset_type == "object":
-                        self.selected_tile = (0, 0, surf.get_width(), surf.get_height())
-                else:
-                    print("Tileset isnt multiple of tile size")
+                tileset_data = TilesetData(
+                    path.name, path, surf, tileset_type=tileset_type
+                )
+                tileset_data.properties = properties
+                tileset_data.tile_properties = {
+                    int(k): v for k, v in tile_properties.items()
+                }
+                self._load_collision_data_for_tileset(tileset_data)
+
+                self.tilesets.append(tileset_data)
+                self.active_idx = len(self.tilesets) - 1
+                self.tileset_map[self.active_idx] = tileset_data
+                if tileset_type == "object":
+                    self.selected_tile = (0, 0, surf.get_width(), surf.get_height())
             except Exception as e:
                 error_handler.capture(e, context="load_tileset_surface")
 
     def _on_tileset_type_selected(self, tileset_type: str):
         """Callback when user selects tileset type from dialog."""
-        print(f"DEBUG: Tileset type selected: {tileset_type}")
         if not hasattr(self, "_pending_tileset_path"):
-            print("DEBUG: No pending tileset path!")
             return
 
-        path = self._pending_tileset_path
         surf = self._pending_tileset_surf
 
         if tileset_type == "tile" and not is_image_multipleof(
             surf.get_size(), self.editor.tilemap.tile_size
         ):
-            self.editor.notifications.error(
-                "Tileset size must be multiple of tile size"
+            w, h = surf.get_size()
+            tw, th = self.editor.tilemap.tile_size
+            self.editor.confirm_dialog.show(
+                title="Tileset Size Warning",
+                message=f"Image size ({w}x{h}) is not an exact multiple of tile size ({tw}x{th}). "
+                f"Some pixels at the edges will be ignored. Proceed?",
+                on_confirm=lambda: self._commit_tileset_load(tileset_type),
+                on_cancel=self._on_tileset_type_cancel,
             )
-            delattr(self, "_pending_tileset_path")
-            delattr(self, "_pending_tileset_surf")
-            if self._pending_tileset_queue:
-                error_handler.capture(
-                    Exception(
-                        f"Queue error continuation: {len(self._pending_tileset_queue)} items"
-                    ),
-                    context="tileset_queue_error",
-                    severity="info",
-                )
-                # Delay slightly to allow dialog to fully close
-                pygame.time.set_timer(pygame.USEREVENT + 1, 100, 1)
-                self._queue_timer_active = True
             return
 
+        self._commit_tileset_load(tileset_type)
+
+    def _commit_tileset_load(self, tileset_type: str):
+        path = self._pending_tileset_path
+        surf = self._pending_tileset_surf
+
         tileset_data = TilesetData(path.name, path, surf, tileset_type=tileset_type)
         self._load_collision_data_for_tileset(tileset_data)
         self.tilesets.append(tileset_data)
         self.active_idx = len(self.tilesets) - 1
         self.tileset_map[self.active_idx] = tileset_data
-        print(f"DEBUG: Added tileset {path.name}, total tilesets: {len(self.tilesets)}")
+
         if tileset_type == "object":
             self.selected_tile = (0, 0, surf.get_width(), surf.get_height())
         else:
@@ -416,14 +416,8 @@ class TileSelector:
         delattr(self, "_pending_tileset_path")
         delattr(self, "_pending_tileset_surf")
         if self._pending_tileset_queue:
-            print(
-                f"DEBUG: Continuing queue, {len(self._pending_tileset_queue)} items remaining"
-            )
-            # Delay slightly to allow dialog to fully close
             pygame.time.set_timer(pygame.USEREVENT + 1, 100, 1)
             self._queue_timer_active = True
-        else:
-            print("DEBUG: Queue processing complete")
 
     def _load_collision_data_for_tileset(self, tileset_data: TilesetData) -> None:
         """Attach existing collision data for tilesets that have sidecar files."""
@@ -631,6 +625,27 @@ class TileSelector:
         self.selected_tile = (col * tw, row * th, tw, th)
         return True
 
+    def _export_selected_as_png_dialog(self):
+        if not self.selected_tile or self.active_idx == -1:
+            return
+        ts = self.tilesets[self.active_idx]
+        default = Path(ts.name).stem + "_extracted.png"
+        self.editor.open_file_manager(
+            on_save=self._on_export_selected_path,
+            allowed_exts=[".png"],
+            mode="save",
+            default_name=default,
+        )
+
+    def _on_export_selected_path(self, path: Path):
+        try:
+            sx, sy, sw, sh = self.selected_tile
+            ts = self.tilesets[self.active_idx]
+            extracted = ts.surface.subsurface(Rect(sx, sy, sw, sh)).copy()
+            pygame.image.save(extracted, str(path))
+        except Exception as e:
+            error_handler.capture(e, context="export_selected_png")
+
     def draw(self, screen: pygame.Surface):
         self.draw_background(screen)
         self.draw_view_area(screen)
@@ -791,6 +806,15 @@ class TileSelector:
         screen.blit(name_surf, (self.rect.x + 5, self.rect.bottom - 30))
 
     def draw_buttons(self, screen):
+        # Export selection as PNG button
+        pygame.draw.rect(
+            screen, COLORS.header, self.btn_export, border_radius=SHAPE.radius_sm
+        )
+        screen.blit(
+            self.font.render("E", True, COLORS.text),
+            (self.btn_export.x + 9, self.btn_export.y + 5),
+        )
+
         # Collision editor button
         pygame.draw.rect(
             screen, COLORS.header, self.btn_collision, border_radius=SHAPE.radius_sm
@@ -815,7 +839,9 @@ class TileSelector:
             (self.btn_rem.x + 10, self.btn_rem.y + 5),
         )
         mx, my = pygame.mouse.get_pos()
-        if self.btn_collision.collidepoint(mx, my):
+        if self.btn_export.collidepoint(mx, my):
+            self.editor.tooltip.show("E: Export selection as PNG", (mx + 10, my + 10))
+        elif self.btn_collision.collidepoint(mx, my):
             self.editor.tooltip.show("Edit Collision Shapes", (mx + 10, my + 10))
         elif self.btn_add.collidepoint(mx, my):
             self.editor.tooltip.show("Add Tileset", (mx + 10, my + 10))

tilemap_editor-3.2.7/src/widgets/ui/confirm_dialog.py

@@ -0,0 +1,149 @@
+import pygame
+from pygame import Rect, Surface
+from typing import Callable, Optional
+
+
+class ConfirmDialog:
+    def __init__(self, editor_rect: Rect):
+        self.editor_rect = editor_rect
+        self.rect = Rect(0, 0, 420, 180)
+        self.rect.center = editor_rect.center
+
+        self.active = False
+        self.title = ""
+        self.message = ""
+        self.on_confirm: Optional[Callable[[], None]] = None
+        self.on_cancel: Optional[Callable[[], None]] = None
+
+        self.bg_color = (40, 40, 40)
+        self.border_color = (100, 100, 100)
+        self.text_color = (255, 255, 255)
+        self.warn_color = (255, 200, 60)
+        self.button_color = (60, 100, 180)
+        self.button_hover_color = (80, 120, 200)
+
+        self.btn_proceed = Rect(0, 0, 110, 30)
+        self.btn_cancel = Rect(0, 0, 110, 30)
+
+        self.font_title = pygame.font.SysFont("Arial", 18, bold=True)
+        self.font_text = pygame.font.SysFont("Arial", 14)
+        self.font_btn = pygame.font.SysFont("Arial", 14, bold=True)
+
+        self.btn_proceed_hover = False
+        self.btn_cancel_hover = False
+        self._layout()
+
+    def _layout(self):
+        self.rect.center = self.editor_rect.center
+        btn_y = self.rect.bottom - 50
+        cx = self.rect.centerx
+        self.btn_cancel = Rect(cx - 120, btn_y, 110, 30)
+        self.btn_proceed = Rect(cx + 10, btn_y, 110, 30)
+
+    def show(
+        self,
+        title: str,
+        message: str,
+        on_confirm: Callable[[], None],
+        on_cancel: Callable[[], None],
+    ):
+        if self.active:
+            self.hide()
+        self.active = True
+        self.title = title
+        self.message = message
+        self.on_confirm = on_confirm
+        self.on_cancel = on_cancel
+        self.btn_proceed_hover = False
+        self.btn_cancel_hover = False
+        self._layout()
+
+    def hide(self):
+        self.active = False
+
+    def handle_event(self, event: pygame.event.Event) -> bool:
+        if not self.active:
+            return False
+
+        self._layout()
+        mouse_pos = pygame.mouse.get_pos()
+
+        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+            if self.btn_proceed.collidepoint(mouse_pos):
+                if self.on_confirm:
+                    self.on_confirm()
+                self.hide()
+                return True
+            if self.btn_cancel.collidepoint(mouse_pos):
+                if self.on_cancel:
+                    self.on_cancel()
+                self.hide()
+                return True
+
+        elif event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_ESCAPE:
+                if self.on_cancel:
+                    self.on_cancel()
+                self.hide()
+                return True
+            elif event.key == pygame.K_RETURN:
+                if self.on_confirm:
+                    self.on_confirm()
+                self.hide()
+                return True
+
+        elif event.type == pygame.MOUSEMOTION:
+            self.btn_proceed_hover = self.btn_proceed.collidepoint(mouse_pos)
+            self.btn_cancel_hover = self.btn_cancel.collidepoint(mouse_pos)
+
+        return False
+
+    def draw(self, surface: Surface):
+        if not self.active:
+            return
+
+        self._layout()
+        pygame.draw.rect(surface, self.bg_color, self.rect)
+        pygame.draw.rect(surface, self.border_color, self.rect, 2)
+
+        title_surf = self.font_title.render(self.title, True, self.warn_color)
+        title_rect = title_surf.get_rect(topleft=(self.rect.x + 20, self.rect.y + 15))
+        surface.blit(title_surf, title_rect)
+
+        lines = self._wrap_text(self.message, self.rect.width - 40)
+        y = self.rect.y + 50
+        for line in lines:
+            line_surf = self.font_text.render(line, True, self.text_color)
+            surface.blit(line_surf, (self.rect.x + 20, y))
+            y += 22
+
+        proceed_color = self.button_hover_color if self.btn_proceed_hover else self.button_color
+        cancel_color = self.button_hover_color if self.btn_cancel_hover else (60, 60, 60)
+
+        pygame.draw.rect(surface, cancel_color, self.btn_cancel)
+        pygame.draw.rect(surface, proceed_color, self.btn_proceed)
+
+        cancel_text = self.font_btn.render("Cancel", True, self.text_color)
+        proceed_text = self.font_btn.render("Proceed", True, self.text_color)
+
+        cancel_text_rect = cancel_text.get_rect(center=self.btn_cancel.center)
+        proceed_text_rect = proceed_text.get_rect(center=self.btn_proceed.center)
+
+        surface.blit(cancel_text, cancel_text_rect)
+        surface.blit(proceed_text, proceed_text_rect)
+
+    def _wrap_text(self, text: str, max_width: int):
+        words = text.split()
+        lines = []
+        current = ""
+        for word in words:
+            test = f"{current} {word}".strip()
+            if self.font_text.size(test)[0] <= max_width:
+                current = test
+            else:
+                if current:
+                    lines.append(current)
+                current = word
+        if current:
+            lines.append(current)
+        return lines