tilemap-editor 3.3.3__tar.gz → 3.3.5__tar.gz

{tilemap_editor-3.3.3/src/tilemap_editor.egg-info → tilemap_editor-3.3.5}/PKG-INFO

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

{tilemap_editor-3.3.3 → tilemap_editor-3.3.5}/pyproject.toml

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

{tilemap_editor-3.3.3 → tilemap_editor-3.3.5}/src/plugins/sprite_animation/editor.py

@@ -310,11 +310,10 @@ class SpriteAnimationEditor:
                     )
                 elif event.type == pygame.KEYDOWN:
                     if event.key == pygame.K_ESCAPE:
-                        if self._info_tooltip_pinned:
-                            self._info_tooltip_pinned = False
+                        if self._file_manager is not None:
+                            self.handle_event(event)
                             continue
-                        # Don't close editor if file manager is open - let file manager handle ESC
-                        if self._file_manager is None:
+                        if not self.handle_event(event):
                             running = False
                         continue
                 self.handle_event(event)
@@ -383,6 +382,11 @@ class SpriteAnimationEditor:
             self._info_tooltip_pinned = False
             return True
 
+        # Close dropdown on Escape
+        if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE and self._dropdown_open:
+            self._dropdown_open = False
+            return True
+
         if self._meta_panel_open and self._route_meta_panel_event(event):
             return True
 
@@ -427,6 +431,14 @@ class SpriteAnimationEditor:
                 self._start_rename()
                 return True
 
+            # [ / ]: Cycle animations
+            elif event.key == pygame.K_LEFTBRACKET:
+                self._cycle_animation(-1)
+                return True
+            elif event.key == pygame.K_RIGHTBRACKET:
+                self._cycle_animation(1)
+                return True
+
         # Close dropdown on outside click
         if event.type == pygame.MOUSEBUTTONDOWN and self._dropdown_open:
             mouse = pygame.mouse.get_pos()
@@ -1240,13 +1252,32 @@ class SpriteAnimationEditor:
             screen.blit(text_surf, (tooltip_rect.x + padding, y))
             y += line_height
 
+    def _compute_dropdown_width(self, names: List[str]) -> int:
+        capped = self._active_anim_name or "(none)"
+        if len(capped) > 16:
+            capped = capped[:14] + ".."
+        cap_w = self._font.size(f"  {capped}")[0]
+        max_name_w = 0
+        max_badge_w = 0
+        for name in names:
+            w = self._font.size(name)[0]
+            if w > max_name_w:
+                max_name_w = w
+            anim = self.library.get_animation(name)
+            if anim:
+                bw = self._font_sm.size(f"{anim.frame_count()}f")[0]
+                if bw > max_badge_w:
+                    max_badge_w = bw
+        dd_w = max(cap_w, max_name_w + max_badge_w + 24)
+        return min(dd_w, 400)
+
     def _draw_dropdown(self, screen: pygame.Surface) -> None:
         names = self.library.animation_names()
         if not names:
             return
 
         item_h = 26
-        dd_w = self._btn_anim_selector.w
+        dd_w = self._compute_dropdown_width(names)
         dd_h = len(names) * item_h + 4
         dd_x = self._btn_anim_selector.x
         dd_y = self._btn_anim_selector.bottom + 2
@@ -1281,7 +1312,7 @@ class SpriteAnimationEditor:
                     screen, _COLORS["dropdown_hover"], item_rect, border_radius=3
                 )
 
-            display = name if len(name) < 18 else name[:16] + ".."
+            display = name
             color = _COLORS["accent"] if is_active else _COLORS["text"]
             lbl = self._font.render(display, True, color)
             screen.blit(lbl, (item_rect.x + 8, item_rect.y + 4))
@@ -1458,6 +1489,20 @@ class SpriteAnimationEditor:
             self.preview.grid_offset_x = gx
             self.preview.grid_offset_y = gy
 
+    def _cycle_animation(self, delta: int) -> None:
+        """Switch to next (delta=1) or previous (delta=-1) animation."""
+        names = self.library.animation_names()
+        if not names:
+            return
+        if self._active_anim_name is None or self._active_anim_name not in names:
+            idx = 0 if delta > 0 else len(names) - 1
+        else:
+            idx = (names.index(self._active_anim_name) + delta) % len(names)
+        self._active_anim_name = names[idx]
+        self._sync_active_animation()
+        if self._dropdown_open:
+            self._dropdown_hover_idx = idx
+
     def _sync_active_animation(self) -> None:
         """Push current animation data to sub-widgets."""
         anim = self._get_active()

{tilemap_editor-3.3.3 → tilemap_editor-3.3.5}/src/plugins/sprite_animation/frame_picker.py

@@ -81,9 +81,13 @@ class FramePicker:
         self._filter_input_rect = Rect(0, 0, 0, 0)
         self._btn_unused_rect = Rect(0, 0, 0, 0)
 
-        # Callback fired when user clicks a tile
+        # Callback fired when user clicks or drags over a tile
         self.on_frame_clicked: Optional[Callable[[int], None]] = None
 
+        # Drag selection state
+        self._selecting = False
+        self._last_drag_idx = -1
+
         # Fonts (created lazily so pygame.init() can happen anytime before draw)
         self._font: Optional[pygame.font.Font] = None
         self._font_sm: Optional[pygame.font.Font] = None
@@ -206,19 +210,39 @@ class FramePicker:
             self.offset_y = self._pan_start_offset[1] + dy
             return True
 
-        # Left-click to select a frame
+        # Left-click to select a frame (starts drag for multi-select)
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
             if (
                 self.rect.collidepoint(mouse)
                 and mouse[1] >= self.rect.y + TOP_BAR_TOTAL
             ):
                 idx = self._index_at(mouse)
-                if (
-                    idx >= 0
-                    and self._tile_matches_filter(idx)
-                    and self.on_frame_clicked
-                ):
-                    self.on_frame_clicked(idx)
+                if idx >= 0 and self._tile_matches_filter(idx):
+                    self._selecting = True
+                    self._last_drag_idx = idx
+                    if self.on_frame_clicked:
+                        self.on_frame_clicked(idx)
+                return True
+
+        # Drag to select/deselect multiple frames (toggles like single-click)
+        if event.type == pygame.MOUSEMOTION and self._selecting:
+            if pygame.mouse.get_pressed()[0]:
+                if self.rect.collidepoint(mouse) and mouse[1] >= self.rect.y + TOP_BAR_TOTAL:
+                    idx = self._index_at(mouse)
+                    if idx != self._last_drag_idx and idx >= 0 and self._tile_matches_filter(idx):
+                        self._last_drag_idx = idx
+                        if self.on_frame_clicked:
+                            self.on_frame_clicked(idx)
+                return True
+            else:
+                self._selecting = False
+                self._last_drag_idx = -1
+
+        # End drag selection
+        if event.type == pygame.MOUSEBUTTONUP and event.button == 1:
+            if self._selecting:
+                self._selecting = False
+                self._last_drag_idx = -1
                 return True
 
         # Scroll to pan / Ctrl+scroll to zoom

{tilemap_editor-3.3.3 → tilemap_editor-3.3.5}/src/plugins/sprite_editor/editor.py

@@ -149,6 +149,24 @@ class SpriteEditor:
                     if self.grid.redo():
                         self.grid.selected_indices.clear()
                     return True
+                elif event.key == pygame.K_c:
+                    if self.grid.has_selection():
+                        self._clipboard = self.grid.copy_selected()
+                        self._paste_mode = False
+                        self.grid.paste_preview_idx = -1
+                    return True
+                elif event.key == pygame.K_x:
+                    if self.grid.has_selection():
+                        self._clipboard = self.grid.cut_selected()
+                        self._paste_mode = False
+                        self.grid.paste_preview_idx = -1
+                    return True
+                elif event.key == pygame.K_v:
+                    if self._clipboard:
+                        self._paste_mode = not self._paste_mode
+                        if not self._paste_mode:
+                            self.grid.paste_preview_idx = -1
+                    return True
 
         # Toolbar clicks
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
@@ -156,19 +174,20 @@ class SpriteEditor:
                 if r.collidepoint(mouse):
                     return self._handle_tool(lbl)
 
-        # Paste mode: next grid click pastes
+        # Paste mode: click places (or exits if outside grid)
         if self._paste_mode and event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
             idx = self.grid.index_at_pos(mouse)
             if idx >= 0 and self.grid.rect.collidepoint(mouse):
                 self.grid.paste_at(idx, self._clipboard)
-                self._paste_mode = False
-                self.grid.paste_preview_idx = -1
-                return True
+            self._paste_mode = False
+            self.grid.paste_preview_idx = -1
+            return True
 
-        # Paste preview on hover
+        # Paste preview on hover (consume event to prevent grid overlap)
         if self._paste_mode and event.type == pygame.MOUSEMOTION:
             idx = self.grid.index_at_pos(mouse)
             self.grid.paste_preview_idx = idx if idx >= 0 else -1
+            return True
 
         return self.grid.handle_event(event)
 

{tilemap_editor-3.3.3 → tilemap_editor-3.3.5}/src/plugins/tileset_collision/collision_painter.py

@@ -117,7 +117,8 @@ class CollisionPainter:
         self.snap_to_grid = False
         self.grid_size = 8  # pixels
         self.show_grid = True
-        self.edge_draw_mode = False  # E key - straight line drawing
+        self.show_angle_hints = False  # show angle arcs at vertices
+        self.edge_draw_mode = False  # Ctrl+E - straight line drawing
         self._edge_start: Optional[Tuple[int, int]] = None  # Start point for edge draw
         self._shift_held = False
         
@@ -270,7 +271,66 @@ class CollisionPainter:
     def get_one_way_flags(self) -> List[bool]:
         """Get one-way collision flags for all polygons"""
         return list(self.polygon_one_way)
+
+    def toggle_one_way(self) -> None:
+        """Toggle one-way flag on the selected polygon"""
+        idx = self.selected_polygon_idx
+        if idx is not None and 0 <= idx < len(self.polygon_one_way):
+            self.polygon_one_way[idx] = not self.polygon_one_way[idx]
+            if self.on_polygon_modified:
+                self.on_polygon_modified(idx)
     
+    def _get_interior_angle(
+        self, polygon: List[Tuple[float, float]], idx: int
+    ) -> float:
+        """Compute interior angle (degrees) at polygon vertex idx."""
+        n = len(polygon)
+        if n < 3:
+            return 0.0
+        prev = polygon[(idx - 1) % n]
+        curr = polygon[idx]
+        nxt = polygon[(idx + 1) % n]
+        v1 = (prev[0] - curr[0], prev[1] - curr[1])
+        v2 = (nxt[0] - curr[0], nxt[1] - curr[1])
+        dot = v1[0] * v2[0] + v1[1] * v2[1]
+        mag1 = math.hypot(v1[0], v1[1])
+        mag2 = math.hypot(v2[0], v2[1])
+        if mag1 < 0.001 or mag2 < 0.001:
+            return 0.0
+        cos_a = max(-1.0, min(1.0, dot / (mag1 * mag2)))
+        return math.degrees(math.acos(cos_a))
+
+    def _draw_angle_hint(
+        self,
+        screen: pygame.Surface,
+        screen_pos: Tuple[int, int],
+        angle_deg: float,
+    ) -> None:
+        """Draw a small arc + angle text at a vertex."""
+        if angle_deg <= 0.5 or angle_deg >= 179.5:
+            return
+        arc_radius = 14
+        segments = max(4, int(angle_deg / 10))
+        angle_rad = math.radians(angle_deg)
+        pts = [screen_pos]
+        for i in range(segments + 1):
+            t = -angle_rad * i / segments
+            pts.append((
+                screen_pos[0] + arc_radius * math.cos(t),
+                screen_pos[1] + arc_radius * math.sin(t),
+            ))
+        if len(pts) >= 3:
+            wedge = pygame.Surface(self.rect.size, pygame.SRCALPHA)
+            pygame.draw.polygon(wedge, (*_COLORS["polygon_fill"], 60), pts)
+            screen.blit(wedge, self.rect.topleft)
+        label = self._font_sm.render(f"{angle_deg:.0f}°", True, _COLORS["text"])
+        label_x = screen_pos[0] + 10
+        label_y = screen_pos[1] - label.get_height() - 4
+        bg = pygame.Surface((label.get_width() + 4, label.get_height() + 2), pygame.SRCALPHA)
+        bg.fill((0, 0, 0, 180))
+        screen.blit(bg, (label_x - 2, label_y - 1))
+        screen.blit(label, (label_x, label_y))
+
     def clear_all(self) -> None:
         """Clear all polygons"""
         self.polygons = []
@@ -488,23 +548,26 @@ class CollisionPainter:
         
         # Keyboard shortcuts
         if event.type == pygame.KEYDOWN:
+            mods = pygame.key.get_mods()
+            ctrl = mods & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
+
             # Track Shift state for edge draw
             if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
                 self._shift_held = True
-            
-            # E - toggle edge draw mode
-            elif event.key == pygame.K_e:
+
+            # Ctrl+E - toggle edge draw mode
+            elif ctrl and event.key == pygame.K_e:
                 self.edge_draw_mode = not self.edge_draw_mode
                 if not self.edge_draw_mode:
                     self._edge_start = None
                 return True
-            
+
             # Enter - complete polygon
             elif event.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
                 if len(self.current_polygon) >= 3:
                     self._complete_polygon()
                     return True
-            
+
             # Escape - cancel current polygon or deselect or close help
             elif event.key == pygame.K_ESCAPE:
                 if self.show_help:
@@ -517,44 +580,45 @@ class CollisionPainter:
                     self.selected_polygon_idx = None
                     self.selected_vertex_idx = None
                     return True
-            
-            # Delete - remove selected polygon
+
+            # Delete/Backspace - remove selected polygon or last vertex
             elif event.key in (pygame.K_DELETE, pygame.K_BACKSPACE):
                 if self.selected_polygon_idx is not None:
                     self._delete_polygon(self.selected_polygon_idx)
                     return True
                 elif self.current_polygon:
-                    # Remove last vertex
                     self.current_polygon.pop()
                     return True
-            
-            # G - toggle grid
-            elif event.key == pygame.K_g:
+
+            # Ctrl+G - toggle grid
+            elif ctrl and event.key == pygame.K_g:
                 self.show_grid = not self.show_grid
                 return True
-            
-            # S - toggle snap (only if Ctrl is not held)
-            elif event.key == pygame.K_s:
-                mods = pygame.key.get_mods()
-                ctrl_held = mods & (pygame.KMOD_CTRL | pygame.KMOD_LMETA)
-                if not ctrl_held:
-                    self.snap_to_grid = not self.snap_to_grid
-                    return True
-            
-            # O - toggle one-way collision for selected polygon
-            elif event.key == pygame.K_o:
+
+            # Ctrl+Shift+S - toggle snap (Ctrl+S reserved for save)
+            elif ctrl and event.key == pygame.K_s and (mods & pygame.KMOD_SHIFT):
+                self.snap_to_grid = not self.snap_to_grid
+                return True
+
+            # Ctrl+O - toggle one-way collision for selected polygon
+            elif ctrl and event.key == pygame.K_o:
                 if self.selected_polygon_idx is not None:
                     idx = self.selected_polygon_idx
                     self.polygon_one_way[idx] = not self.polygon_one_way[idx]
                     if self.on_polygon_modified:
                         self.on_polygon_modified(idx)
                     return True
-            
-            # R - reset view
-            elif event.key == pygame.K_r:
+
+            # Ctrl+R - reset view
+            elif ctrl and event.key == pygame.K_r:
                 self._center_view()
                 self.zoom = 2.0
                 return True
+
+            # Ctrl+A - toggle angle hints
+            elif ctrl and event.key == pygame.K_a:
+                self.show_angle_hints = not self.show_angle_hints
+                return True
         
         if event.type == pygame.KEYUP:
             if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
@@ -744,20 +808,21 @@ class CollisionPainter:
                 ("Right-click / Enter", "Complete polygon"),
                 ("Escape", "Cancel current polygon"),
                 ("Shift (edge mode)", "Constrain to axis"),
-                ("E", "Toggle edge draw mode"),
+                ("Ctrl+E", "Toggle edge draw mode"),
             ]),
             ("SELECTION", [
                 ("Left-click polygon", "Select polygon"),
                 ("Left-click vertex", "Select & drag vertex"),
                 ("Delete / Backspace", "Remove selected polygon"),
-                ("O", "Toggle one-way collision"),
+                ("Ctrl+O", "Toggle one-way collision"),
             ]),
             ("VIEW", [
                 ("Mouse wheel", "Zoom in/out"),
                 ("Middle mouse / Space+LMB", "Pan view"),
-                ("G", "Toggle grid"),
-                ("S", "Toggle snap to grid"),
-                ("R", "Reset view"),
+                ("Ctrl+G", "Toggle grid"),
+                ("Ctrl+Shift+S", "Toggle snap to grid"),
+                ("Ctrl+R", "Reset view"),
+                ("Ctrl+A", "Toggle angle hints"),
             ]),
             ("MISC", [
                 ("Info button (top-right)", "Toggle this help panel"),
@@ -905,6 +970,24 @@ class CollisionPainter:
             radius = VERTEX_HOVER_RADIUS if is_hovered_vertex else VERTEX_RADIUS
             pygame.draw.circle(screen, color, (px, py), radius)
             pygame.draw.circle(screen, (0, 0, 0), (px, py), radius, 1)
+
+        # One-way badge on selected polygon
+        if selected and one_way and len(polygon) >= 3:
+            cx = int(sum(p[0] for p in screen_points) / len(screen_points))
+            cy = int(sum(p[1] for p in screen_points) / len(screen_points))
+            badge = self._font_sm.render("ONE-WAY", True, (255, 255, 255))
+            bx = cx - badge.get_width() // 2
+            by = cy - badge.get_height() // 2
+            bg = pygame.Surface((badge.get_width() + 8, badge.get_height() + 4), pygame.SRCALPHA)
+            bg.fill((_COLORS["one_way"][0], _COLORS["one_way"][1], _COLORS["one_way"][2], 200))
+            screen.blit(bg, (bx - 4, by - 2))
+            screen.blit(badge, (bx, by))
+
+        # Angle hints
+        if self.show_angle_hints:
+            for i, (px, py) in enumerate(screen_points):
+                angle = self._get_interior_angle(polygon, i)
+                self._draw_angle_hint(screen, (px, py), angle)
     
     def _draw_current_polygon(self, screen: pygame.Surface) -> None:
         """Draw the polygon currently being drawn"""
@@ -934,6 +1017,25 @@ class CollisionPainter:
             radius = VERTEX_HOVER_RADIUS if is_first else VERTEX_RADIUS
             pygame.draw.circle(screen, color, (px, py), radius)
             pygame.draw.circle(screen, (0, 0, 0), (px, py), radius, 1)
+
+        # Angle hints for vertices with both neighbors
+        if self.show_angle_hints and len(self.current_polygon) >= 3:
+            for i, (px, py) in enumerate(screen_points):
+                if i == 0 or i == len(screen_points) - 1:
+                    continue
+                poly = self.current_polygon
+                prev = poly[i - 1]
+                curr = poly[i]
+                nxt = poly[i + 1]
+                v1 = (prev[0] - curr[0], prev[1] - curr[1])
+                v2 = (nxt[0] - curr[0], nxt[1] - curr[1])
+                dot = v1[0] * v2[0] + v1[1] * v2[1]
+                mag1 = math.hypot(v1[0], v1[1])
+                mag2 = math.hypot(v2[0], v2[1])
+                if mag1 > 0.001 and mag2 > 0.001:
+                    cos_a = max(-1.0, min(1.0, dot / (mag1 * mag2)))
+                    angle = math.degrees(math.acos(cos_a))
+                    self._draw_angle_hint(screen, (px, py), angle)
     
     def _draw_status(self, screen: pygame.Surface) -> None:
         """Draw status text"""
@@ -949,12 +1051,13 @@ class CollisionPainter:
             one_way = self.polygon_one_way[self.selected_polygon_idx]
             one_way_str = " (ONE-WAY)" if one_way else ""
             lines.append(f"Selected polygon {self.selected_polygon_idx}{one_way_str}")
-            lines.append("Delete to remove, O to toggle one-way")
+            lines.append("Delete to remove, Ctrl+O to toggle one-way")
         else:
             lines.append("Click to add vertices, right-click to complete")
         
-        lines.append(f"Zoom: {self.zoom:.1f}x | Grid: {'ON' if self.show_grid else 'OFF'} (G) | Snap: {'ON' if self.snap_to_grid else 'OFF'} (S)")
-        lines.append(f"Polygons: {len(self.polygons)} | R: reset view")
+        snap_str = f"Snap: {'ON' if self.snap_to_grid else 'OFF'} (Ctrl+Shift+S)"
+        lines.append(f"Zoom: {self.zoom:.1f}x | Grid: {'ON' if self.show_grid else 'OFF'} (Ctrl+G) | {snap_str}")
+        lines.append(f"Polygons: {len(self.polygons)} | Ctrl+R: reset | Ctrl+A: angle hints {'ON' if self.show_angle_hints else 'OFF'}")
         
         y = self.rect.y + 5
         for line in lines: