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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 3.2.8
+Version: 3.2.9
 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.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.2.8"
+version = "3.2.9"
 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.9}/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.9/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.9
 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.9}/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.9}/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.9}/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:
@@ -335,6 +336,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 +351,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 +360,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 +372,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 +411,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

tilemap_editor-3.2.9/src/widgets/ui/tileset_type_dialog.py

@@ -0,0 +1,451 @@
+"""
+Simple dialog for selecting tileset type (tile vs object) and configuring animation.
+"""
+
+import pygame
+from pygame import Rect, Surface
+from typing import Callable, Optional
+
+
+class TilesetTypeDialog:
+    """Dialog to select whether a tileset is tile-based or object-based."""
+
+    def __init__(self, editor_rect: Rect):
+        self.editor_rect = editor_rect
+        self.rect = Rect(0, 0, 400, 420)
+        self.rect.center = editor_rect.center
+
+        self.active = False
+        self.selected_type: Optional[str] = None
+        self.on_confirm: Optional[Callable[[str], 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.field_color = (55, 55, 55)
+        self.field_border = (80, 80, 80)
+        self.radio_color = (100, 150, 255)
+        self.button_color = (60, 100, 180)
+        self.button_hover_color = (80, 120, 200)
+
+        self.radio_tile_rect = Rect(0, 0, 20, 20)
+        self.radio_object_rect = Rect(0, 0, 20, 20)
+        self.radio_tile_label_rect = Rect(0, 0, 0, 0)
+        self.radio_object_label_rect = Rect(0, 0, 0, 0)
+        self.radio_tile_row_rect = Rect(0, 0, 0, 0)
+        self.radio_object_row_rect = Rect(0, 0, 0, 0)
+
+        self.btn_ok = Rect(0, 0, 80, 30)
+        self.btn_cancel = Rect(0, 0, 80, 30)
+
+        self.font_title = pygame.font.SysFont("Arial", 18, bold=True)
+        self.font_text = pygame.font.SysFont("Arial", 14)
+        self.font_field = pygame.font.SysFont("Arial", 13)
+
+        self.btn_ok_hover = False
+        self.btn_cancel_hover = False
+
+        # Animation state
+        self.animated = False
+        self.anim_frame_count = 4
+        self.anim_frame_duration_ms = 200
+        self.anim_loop = True
+        self.anim_mode_index = 0  # 0=default, 1=random_start_times
+        self.anim_modes = ["default", "random_start_times"]
+        self.anim_mode_labels = ["Sync", "Random"]
+
+        # Inline editing state
+        self._editing_field: Optional[str] = None
+        self._edit_buffer = ""
+
+        # Animation field rects (set by _layout)
+        self.anim_check_rect = Rect(0, 0, 16, 16)
+        self.anim_fields_rects: dict = {}
+        self.anim_loop_check_rect = Rect(0, 0, 16, 16)
+        self.anim_mode_rect = Rect(0, 0, 0, 0)
+
+        self._layout()
+
+    def _layout(self):
+        """Position child controls from the current dialog rect."""
+        self.rect.center = self.editor_rect.center
+
+        h = 220
+        if self.animated or self._editing_field is not None:
+            h = 420
+        self.rect.h = h
+
+        radio_x = self.rect.x + 42
+        row_w = self.rect.w - 84
+        row_h = 38
+        first_y = self.rect.y + 58
+        gap = 12
+
+        self.radio_tile_row_rect = Rect(radio_x - 10, first_y - 9, row_w, row_h)
+        self.radio_object_row_rect = Rect(
+            radio_x - 10, first_y + row_h + gap - 9, row_w, row_h
+        )
+
+        self.radio_tile_rect = Rect(radio_x, first_y, 20, 20)
+        self.radio_object_rect = Rect(radio_x, first_y + row_h + gap, 20, 20)
+
+        label_x = radio_x + 34
+        self.radio_tile_label_rect = Rect(label_x, first_y - 4, row_w - 44, 28)
+        self.radio_object_label_rect = Rect(
+            label_x, first_y + row_h + gap - 4, row_w - 44, 28
+        )
+
+        # Animated checkbox
+        anim_y = first_y + (row_h + gap) * 2 + 6
+        self.anim_check_rect = Rect(radio_x, anim_y, 16, 16)
+
+        # Animation fields (collapsible)
+        field_y = anim_y + 30
+        field_h = 22
+        field_gap = 4
+        field_label_w = 100
+        field_value_w = 80
+        field_x = self.rect.x + 42
+
+        self.anim_fields_rects = {}
+        anim_fields = [
+            ("frame_count", "Frame Count", str(self.anim_frame_count)),
+            ("frame_duration_ms", "Duration (ms)", str(self.anim_frame_duration_ms)),
+        ]
+        for key, label, _ in anim_fields:
+            label_rect = Rect(field_x, field_y, field_label_w, field_h)
+            value_rect = Rect(field_x + field_label_w + 8, field_y, field_value_w, field_h)
+            self.anim_fields_rects[key] = {
+                "label": label_rect,
+                "value": value_rect,
+                "label_text": label,
+            }
+            field_y += field_h + field_gap
+
+        # Loop checkbox
+        self.anim_loop_check_rect = Rect(field_x, field_y, 16, 16)
+        field_y += 26
+
+        # Animation mode
+        mode_label_rect = Rect(field_x, field_y, field_label_w, field_h)
+        mode_value_rect = Rect(field_x + field_label_w + 8, field_y, field_value_w, field_h)
+        self.anim_fields_rects["mode"] = {
+            "label": mode_label_rect,
+            "value": mode_value_rect,
+            "label_text": "Animation Mode",
+        }
+
+        # Stride hint (read-only, auto-computed)
+        self._stride_hint_rect = Rect(field_x, field_y + 36, field_label_w + field_value_w + 8, field_h)
+
+        btn_y = self.rect.y + h - 44
+        self.btn_ok = Rect(self.rect.centerx - 94, btn_y, 80, 30)
+        self.btn_cancel = Rect(self.rect.centerx + 14, btn_y, 80, 30)
+
+    def get_animation_config(self) -> Optional[dict]:
+        if not self.animated:
+            return None
+        return {
+            "frame_count": self.anim_frame_count,
+            "frame_duration_ms": self.anim_frame_duration_ms,
+            "loop": self.anim_loop,
+            "animation_mode": self.anim_modes[self.anim_mode_index],
+        }
+
+    def _get_display_value(self, key: str) -> str:
+        if self._editing_field == key:
+            return self._edit_buffer
+        map = {
+            "frame_count": str(self.anim_frame_count),
+            "frame_duration_ms": str(self.anim_frame_duration_ms),
+            "mode": self.anim_mode_labels[self.anim_mode_index],
+        }
+        return map.get(key, "")
+
+    def _commit_edit(self):
+        if self._editing_field is None:
+            return
+        try:
+            if self._editing_field == "frame_count":
+                self.anim_frame_count = max(1, int(self._edit_buffer))
+                self._update_computed_stride()
+            elif self._editing_field == "frame_duration_ms":
+                self.anim_frame_duration_ms = max(1, int(self._edit_buffer))
+        except ValueError:
+            pass
+        self._editing_field = None
+        self._edit_buffer = ""
+
+    def set_sheet_dimensions(self, sheet_cols: int, sheet_rows: int):
+        self._sheet_cols = sheet_cols
+        self._sheet_rows = sheet_rows
+        if self.anim_frame_count > 0:
+            self._update_computed_stride()
+
+    def _update_computed_stride(self):
+        fc = self.anim_frame_count
+        if fc < 1:
+            return
+        if hasattr(self, '_sheet_cols') and self._sheet_cols % fc == 0:
+            self._computed_stride = self._sheet_cols // fc
+        elif hasattr(self, '_sheet_rows') and self._sheet_rows % fc == 0:
+            self._computed_stride = (self._sheet_rows // fc) * getattr(self, '_sheet_cols', 1)
+        else:
+            self._computed_stride = 1
+
+    def show(self, on_confirm: Callable[[str], None], on_cancel: Callable[[], None]):
+        """Show the dialog."""
+        if self.active:
+            self.hide()
+        self.active = True
+        self.selected_type = "tile"
+        self.on_confirm = on_confirm
+        self.on_cancel = on_cancel
+        self.btn_ok_hover = False
+        self.btn_cancel_hover = False
+        self.animated = False
+        self.anim_frame_count = 4
+        self.anim_frame_duration_ms = 200
+        self.anim_loop = True
+        self.anim_mode_index = 0
+        self._computed_stride = 1
+        self._editing_field = None
+        self._edit_buffer = ""
+
+    def hide(self):
+        """Hide the dialog."""
+        self.active = False
+        self._editing_field = None
+        self._edit_buffer = ""
+
+    def handle_event(self, event: pygame.event.Event) -> bool:
+        """Handle events. Returns True if event was consumed."""
+        if not self.active:
+            return False
+
+        self._layout()
+        mouse_pos = pygame.mouse.get_pos()
+
+        if event.type == pygame.KEYDOWN:
+            if self._editing_field is not None:
+                if event.key == pygame.K_RETURN:
+                    self._commit_edit()
+                    return True
+                elif event.key == pygame.K_ESCAPE:
+                    self._editing_field = None
+                    self._edit_buffer = ""
+                    return True
+                elif event.key == pygame.K_BACKSPACE:
+                    self._edit_buffer = self._edit_buffer[:-1]
+                    return True
+                else:
+                    ch = event.unicode
+                    if ch.isdigit() or ch == "-":
+                        self._edit_buffer += ch
+                    return True
+            else:
+                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 and self.selected_type:
+                        self.on_confirm(self.selected_type)
+                    self.hide()
+                    return True
+
+        elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+            if self.radio_tile_row_rect.collidepoint(mouse_pos):
+                self.selected_type = "tile"
+                return True
+            if self.radio_object_row_rect.collidepoint(mouse_pos):
+                self.selected_type = "object"
+                return True
+
+            # Animated checkbox toggle
+            if self.anim_check_rect.collidepoint(mouse_pos):
+                self.animated = not self.animated
+                self._editing_field = None
+                self._edit_buffer = ""
+                return True
+
+            if self.animated:
+                # Animation field clicks
+                if self.anim_loop_check_rect.collidepoint(mouse_pos):
+                    self.anim_loop = not self.anim_loop
+                    return True
+
+                for key, rects in self.anim_fields_rects.items():
+                    if key == "mode":
+                        if rects["value"].collidepoint(mouse_pos):
+                            self.anim_mode_index = (self.anim_mode_index + 1) % len(self.anim_modes)
+                            return True
+                    else:
+                        if rects["value"].collidepoint(mouse_pos):
+                            self._commit_edit()
+                            self._editing_field = key
+                            self._edit_buffer = self._get_display_value(key)
+                            return True
+
+            if self.btn_ok.collidepoint(mouse_pos):
+                self._commit_edit()
+                if self.on_confirm and self.selected_type:
+                    self.on_confirm(self.selected_type)
+                self.hide()
+                return True
+            if self.btn_cancel.collidepoint(mouse_pos):
+                self._editing_field = None
+                self._edit_buffer = ""
+                if self.on_cancel:
+                    self.on_cancel()
+                self.hide()
+                return True
+
+        elif event.type == pygame.MOUSEMOTION:
+            self.btn_ok_hover = self.btn_ok.collidepoint(mouse_pos)
+            self.btn_cancel_hover = self.btn_cancel.collidepoint(mouse_pos)
+
+        return False
+
+    def draw(self, surface: Surface):
+        """Draw the dialog on the given 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 = self.font_title.render("Tileset Type", True, self.text_color)
+        title_rect = title.get_rect(topleft=(self.rect.x + 20, self.rect.y + 15))
+        surface.blit(title, title_rect)
+
+        self._draw_radio(
+            surface,
+            self.radio_tile_rect,
+            self.radio_tile_row_rect,
+            self.selected_type == "tile",
+            "Tile Tileset (grid-based)",
+            self.radio_tile_label_rect,
+        )
+
+        self._draw_radio(
+            surface,
+            self.radio_object_rect,
+            self.radio_object_row_rect,
+            self.selected_type == "object",
+            "Object Tileset (free-positioned)",
+            self.radio_object_label_rect,
+        )
+
+        self._draw_checkbox(
+            surface,
+            self.anim_check_rect,
+            self.animated,
+            "Animated Tileset",
+            self.rect.x + 62,
+        )
+
+        if self.animated:
+            self._draw_animation_fields(surface)
+
+        ok_color = self.button_hover_color if self.btn_ok_hover else self.button_color
+        cancel_color = (
+            self.button_hover_color if self.btn_cancel_hover else self.button_color
+        )
+
+        pygame.draw.rect(surface, ok_color, self.btn_ok)
+        pygame.draw.rect(surface, cancel_color, self.btn_cancel)
+
+        ok_text = self.font_text.render("OK", True, self.text_color)
+        cancel_text = self.font_text.render("Cancel", True, self.text_color)
+
+        ok_text_rect = ok_text.get_rect(center=self.btn_ok.center)
+        cancel_text_rect = cancel_text.get_rect(center=self.btn_cancel.center)
+
+        surface.blit(ok_text, ok_text_rect)
+        surface.blit(cancel_text, cancel_text_rect)
+
+    def _draw_animation_fields(self, surface: Surface):
+        """Draw the animation configuration fields."""
+        numeric_keys = ["frame_count", "frame_duration_ms"]
+        for key in numeric_keys:
+            rects = self.anim_fields_rects.get(key)
+            if rects is None:
+                continue
+            label_surf = self.font_text.render(rects["label_text"], True, self.text_color)
+            surface.blit(label_surf, rects["label"])
+
+            value_str = self._get_display_value(key)
+            value_color = self.radio_color if self._editing_field == key else self.text_color
+            border = self.field_border if self._editing_field != key else self.radio_color
+            pygame.draw.rect(surface, self.field_color, rects["value"])
+            pygame.draw.rect(surface, border, rects["value"], 1)
+            val_surf = self.font_field.render(value_str, True, value_color)
+            val_rect = val_surf.get_rect(midleft=(rects["value"].x + 4, rects["value"].centery))
+            surface.blit(val_surf, val_rect)
+
+        # Loop checkbox — label to the right of the box, not at field_x
+        loop_label_x = self.anim_loop_check_rect.right + 6
+        self._draw_checkbox(
+            surface,
+            self.anim_loop_check_rect,
+            self.anim_loop,
+            "Loop",
+            loop_label_x,
+        )
+
+        # Animation mode (below loop)
+        mode_rects = self.anim_fields_rects.get("mode")
+        if mode_rects:
+            label_surf = self.font_text.render(mode_rects["label_text"], True, self.text_color)
+            surface.blit(label_surf, mode_rects["label"])
+            mode_border = self.field_border
+            pygame.draw.rect(surface, self.field_color, mode_rects["value"])
+            pygame.draw.rect(surface, mode_border, mode_rects["value"], 1)
+            mode_text = self.anim_mode_labels[self.anim_mode_index]
+            val_surf = self.font_field.render(mode_text, True, self.text_color)
+            val_rect = val_surf.get_rect(midleft=(mode_rects["value"].x + 4, mode_rects["value"].centery))
+            surface.blit(val_surf, val_rect)
+
+        # Stride hint (auto-computed, below mode)
+        hint_color = (160, 160, 160)
+        hint_surf = self.font_field.render(f"Stride: {self._computed_stride}  (auto)", True, hint_color)
+        surface.blit(hint_surf, self._stride_hint_rect)
+
+    def _draw_checkbox(self, surface: Surface, rect: Rect, checked: bool, label: str, label_x: int):
+        pygame.draw.rect(surface, self.field_color, rect)
+        pygame.draw.rect(surface, self.field_border, rect, 1)
+        if checked:
+            pygame.draw.line(surface, self.radio_color, (rect.x + 3, rect.centery), (rect.centerx - 2, rect.bottom - 3), 2)
+            pygame.draw.line(surface, self.radio_color, (rect.centerx - 2, rect.bottom - 3), (rect.right - 3, rect.y + 3), 2)
+        label_surf = self.font_text.render(label, True, self.text_color)
+        label_pos = label_surf.get_rect(midleft=(label_x, rect.centery))
+        surface.blit(label_surf, label_pos)
+
+    def _draw_radio(
+        self,
+        surface: Surface,
+        radio_rect: Rect,
+        row_rect: Rect,
+        is_selected: bool,
+        label: str,
+        label_rect: Rect,
+    ):
+        """Draw a radio button with label."""
+        pygame.draw.rect(surface, (48, 48, 48), row_rect, border_radius=6)
+        pygame.draw.rect(surface, self.border_color, row_rect, 1, border_radius=6)
+
+        center = (radio_rect.centerx, radio_rect.centery)
+        radius = radio_rect.width // 2
+
+        pygame.draw.circle(surface, self.border_color, center, radius, 2)
+
+        if is_selected:
+            pygame.draw.circle(surface, self.radio_color, center, radius - 4)
+
+        label_surf = self.font_text.render(label, True, self.text_color)
+        label_pos = label_surf.get_rect(midleft=(label_rect.x, radio_rect.centery))
+        surface.blit(label_surf, label_pos)