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

{tilemap_editor-3.2.6/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.6
+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.6 → tilemap_editor-3.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.2.6"
+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.6 → 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.6 → 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.6 → 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.6 → 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.6
+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.6 → 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.6 → 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]):
@@ -615,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)
@@ -775,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
@@ -799,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))