tilemap-editor 3.2.8__tar.gz → 3.2.10__tar.gz

{tilemap_editor-3.2.8/src/tilemap_editor.egg-info → tilemap_editor-3.2.10}/PKG-INFO

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

{tilemap_editor-3.2.8 → tilemap_editor-3.2.10}/pyproject.toml

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

{tilemap_editor-3.2.8 → tilemap_editor-3.2.10}/src/tilemap.py

@@ -298,6 +298,8 @@ class Tilemap:
                     ts_data["tile_properties"] = {
                         str(k): v for k, v in ts.tile_properties.items()
                     }
+                if ts.animation:
+                    ts_data["animation"] = ts.animation
 
                 save_data["resources"]["tilesets"].append(ts_data)
 
@@ -547,6 +549,7 @@ class Tilemap:
                         tileset_type,
                         properties=ts_entry.get("properties", {}),
                         tile_properties=ts_entry.get("tile_properties", {}),
+                        animation=ts_entry.get("animation"),
                     )
                 except Exception as e:
                     error_msg = f"Error loading tileset {path_str}: {e}"

{tilemap_editor-3.2.8 → tilemap_editor-3.2.10/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.2.8 → tilemap_editor-3.2.10}/src/ttypes/tilemap.py

@@ -64,6 +64,7 @@ class TypeTilesetSerialized(TypedDict, total=True):
     type: str
     properties: NotRequired[Dict[str, Any]]
     tile_properties: NotRequired[Dict[str, Dict[str, Any]]]  # variant_id string -> properties
+    animation: NotRequired[dict]
 
 
 TTile = Dict[Tuple[int, int], TypeTile]

{tilemap_editor-3.2.8 → tilemap_editor-3.2.10}/src/widgets/tile_grid.py

@@ -1290,6 +1290,15 @@ class TileGrid:
                         base_surf = tileset_data.surface
 
                         variant_id = tile["variant"]
+                        if tileset_data.animation:
+                            anim = tileset_data.animation
+                            frame_ms = pygame.time.get_ticks()
+                            frame_idx = int(frame_ms / anim["frame_duration_ms"]) % anim["frame_count"]
+                            if anim.get("animation_mode") == "random_start_times":
+                                phase = hash((x, y, ttype)) % anim["frame_count"]
+                                frame_idx = (frame_idx + phase) % anim["frame_count"]
+                            variant_id += frame_idx * anim["frame_stride"]
+
                         sheet_w = base_surf.get_width()
 
                         # Source rect always uses logical tile size

{tilemap_editor-3.2.8 → tilemap_editor-3.2.10}/src/widgets/tile_selector.py

@@ -28,6 +28,7 @@ class TilesetData:
         self.tile_properties: Dict[int, Dict[str, Any]] = {}
         self.object_collision_path: Optional[Path] = None
         self.object_collision_data: Optional[Dict[str, Any]] = None
+        self.animation: Optional[dict] = None
 
 
 class TileSelector:
@@ -45,6 +46,10 @@ class TileSelector:
             x, y + self.top_bar_h, w, h - self.top_bar_h - self.btm_bar_h
         )
         self.tab_scroll_x = 0
+        arrow_h = self.top_bar_h - 4
+        arrow_y = y + (self.top_bar_h - arrow_h) // 2
+        self._tab_arrow_left = Rect(x + 2, arrow_y, 18, arrow_h)
+        self._tab_arrow_right = Rect(x + w - 20, arrow_y, 18, arrow_h)
         self.is_panning = False
         self.pan_start = (0, 0)
         self.pan_start_offset = (0, 0)
@@ -85,6 +90,10 @@ class TileSelector:
         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)
+        arrow_h = self.top_bar_h - 4
+        arrow_y = y + (self.top_bar_h - arrow_h) // 2
+        self._tab_arrow_left = Rect(x + 2, arrow_y, 18, arrow_h)
+        self._tab_arrow_right = Rect(x + w - 20, arrow_y, 18, arrow_h)
 
     def set_rule_hints(self, hints: Set[int]):
         self.rule_hints = hints
@@ -178,6 +187,13 @@ class TileSelector:
                 return True
 
             if self.rect.collidepoint(mouse_pos) and mouse_pos[1] < self.view_rect.top:
+                # Check arrow buttons first
+                if self._tab_arrow_left.collidepoint(mouse_pos):
+                    self._scroll_tabs(100)
+                    return True
+                if self._tab_arrow_right.collidepoint(mouse_pos):
+                    self._scroll_tabs(-100)
+                    return True
                 self.check_tab_click(mouse_pos)
                 return True
 
@@ -335,6 +351,10 @@ class TileSelector:
             self._pending_tileset_queue.pop(0)
         )
         print(f"DEBUG: Processing tileset: {self._pending_tileset_path}")
+        tw, th = self.editor.tilemap.tile_size
+        sheet_cols = self._pending_tileset_surf.get_width() // tw
+        sheet_rows = self._pending_tileset_surf.get_height() // th
+        self.editor.tileset_type_dialog.set_sheet_dimensions(sheet_cols, sheet_rows)
         self.editor.tileset_type_dialog.show(
             on_confirm=self._on_tileset_type_selected,
             on_cancel=self._on_tileset_type_cancel,
@@ -346,6 +366,7 @@ class TileSelector:
         tileset_type: str,
         properties: dict = {},
         tile_properties: dict = {},
+        animation: Optional[dict] = None,
     ):
         """Load tileset from path without showing dialog (used when loading maps).
 
@@ -354,6 +375,7 @@ class TileSelector:
             tileset_type: Type of tileset ("tile" or "object") - already known from saved map
             properties: Custom properties for the tileset
             tile_properties: Custom properties for individual tiles in the tileset (variant_id str -> dict)
+            animation: Animation config dict (frame_count, frame_duration_ms, frame_stride, loop, animation_mode)
         """
         if path.exists():
             try:
@@ -365,6 +387,7 @@ class TileSelector:
                 tileset_data.tile_properties = {
                     int(k): v for k, v in tile_properties.items()
                 }
+                tileset_data.animation = animation
                 self._load_collision_data_for_tileset(tileset_data)
 
                 self.tilesets.append(tileset_data)
@@ -403,6 +426,19 @@ class TileSelector:
         surf = self._pending_tileset_surf
 
         tileset_data = TilesetData(path.name, path, surf, tileset_type=tileset_type)
+        animation = self.editor.tileset_type_dialog.get_animation_config()
+        if animation:
+            tw, th = self.editor.tilemap.tile_size
+            sheet_cols = surf.get_width() // tw
+            sheet_rows = surf.get_height() // th
+            frame_count = animation["frame_count"]
+            if sheet_cols % frame_count == 0:
+                animation["frame_stride"] = sheet_cols // frame_count
+            elif sheet_rows % frame_count == 0:
+                animation["frame_stride"] = (sheet_rows // frame_count) * sheet_cols
+            else:
+                animation["frame_stride"] = (sheet_cols * sheet_rows) // frame_count
+        tileset_data.animation = animation
         self._load_collision_data_for_tileset(tileset_data)
         self.tilesets.append(tileset_data)
         self.active_idx = len(self.tilesets) - 1
@@ -540,8 +576,8 @@ class TileSelector:
     def _get_tab_at_pos(self, pos) -> Optional[int]:
         if not self.tilesets:
             return None
-        tab_w = min(100, self.rect.width // len(self.tilesets))
-        idx = (pos[0] - self.rect.x) // tab_w
+        tab_w = 100
+        idx = (pos[0] - self.rect.x + self.tab_scroll_x) // tab_w
         if 0 <= idx < len(self.tilesets):
             return int(idx)
         return None
@@ -854,14 +890,19 @@ class TileSelector:
         clip = screen.get_clip()
         tab_area = Rect(self.rect.x, self.rect.y, self.rect.width, self.top_bar_h)
         screen.set_clip(tab_area)
+
+        pygame.draw.rect(screen, COLORS.header, tab_area)
+
         tab_w = 100
         total_w = tab_w * len(self.tilesets)
-        if total_w > self.rect.width:
+        has_overflow = total_w > self.rect.width
+        if has_overflow:
             self.tab_scroll_x = max(
                 0, min(self.tab_scroll_x, total_w - self.rect.width)
             )
         else:
             self.tab_scroll_x = 0
+
         for i, ts in enumerate(self.tilesets):
             r = Rect(
                 self.rect.x + i * tab_w - self.tab_scroll_x,
@@ -874,13 +915,25 @@ class TileSelector:
             is_active = i == self.active_idx
             col = COLORS.selected if is_active else COLORS.header
             pygame.draw.rect(screen, col, r)
-            pygame.draw.rect(screen, COLORS.border, r, 1)
+            if not is_active:
+                pygame.draw.line(screen, COLORS.border, r.bottomleft, r.bottomright, 1)
             t = ts.name[:8] + ".." if len(ts.name) > 10 else ts.name
             screen.blit(self.font.render(t, True, COLORS.text), (r.x + 5, r.y + 5))
-            mx, my = pygame.mouse.get_pos()
-            if r.collidepoint(mx, my):
-                self.editor.tooltip.show(ts.name, (mx + 10, my + 10))
-        if total_w > self.rect.width:
+
+        mx, my = pygame.mouse.get_pos()
+        show_arrows = has_overflow and tab_area.collidepoint(mx, my)
+
+        if show_arrows:
+            for arrow_rect, label in [
+                (self._tab_arrow_left, "<"),
+                (self._tab_arrow_right, ">"),
+            ]:
+                pygame.draw.rect(screen, COLORS.selected, arrow_rect)
+                pygame.draw.rect(screen, COLORS.border, arrow_rect, 1)
+                arrow_surf = self.font.render(label, True, COLORS.text)
+                arrow_rect_text = arrow_surf.get_rect(center=arrow_rect.center)
+                screen.blit(arrow_surf, arrow_rect_text)
+
             bar_w = max(30, int(self.rect.width * (self.rect.width / total_w)))
             bar_x = self.rect.x + int(
                 (self.tab_scroll_x / (total_w - self.rect.width))
@@ -888,6 +941,20 @@ class TileSelector:
             )
             bar_rect = Rect(bar_x, self.rect.y + self.top_bar_h - 4, bar_w, 3)
             pygame.draw.rect(screen, COLORS.border_soft, bar_rect, border_radius=2)
+
+        # Tooltip for tab name
+        if tab_area.collidepoint(mx, my) and not (
+            show_arrows and (
+                self._tab_arrow_left.collidepoint(mx, my) or
+                self._tab_arrow_right.collidepoint(mx, my)
+            )
+        ):
+            idx = self._get_tab_at_pos((mx, my))
+            if idx is not None and 0 <= idx < len(self.tilesets):
+                self.editor.tooltip.show(
+                    self.tilesets[idx].name, (mx + 10, my + 10)
+                )
+
         screen.set_clip(clip)
 
     def _scroll_tabs(self, delta: float):