tilemap-editor 2.0.2__tar.gz → 2.0.3__tar.gz

{tilemap_editor-2.0.2/src/tilemap_editor.egg-info → tilemap_editor-2.0.3}/PKG-INFO

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

{tilemap_editor-2.0.2 → tilemap_editor-2.0.3}/pyproject.toml

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

{tilemap_editor-2.0.2 → tilemap_editor-2.0.3}/src/editor.py

@@ -762,6 +762,7 @@ class Editor:
             if event.type == pygame.VIDEORESIZE:
                 self.handle_resize(event.w, event.h)
 
+            # Priority 1: Modal dialogs and inputs (highest priority)
             if self.save_input.active:
                 self.save_input.handle_event(event)
                 continue
@@ -782,9 +783,20 @@ class Editor:
                 if self.property_editor.handle_event(event):
                     continue
 
+            # Priority 2: Autotiler and Regex Designer (block all events when visible)
+            if self.autotiler.visible:
+                if self.autotiler.handle_event(event):
+                    continue
+
+            if self.regex_automap_designer.visible:
+                if self.regex_automap_designer.handle_event(event):
+                    continue
+
+            # Priority 3: Menu bar
             if self.menubar.handle_event(event):
                 continue
 
+            # Priority 4: Keyboard shortcuts
             if event.type == pygame.KEYDOWN:
                 mods = pygame.key.get_mods()
                 ctrl_held = mods & (pygame.KMOD_LCTRL | pygame.KMOD_RCTRL)
@@ -836,23 +848,17 @@ class Editor:
                         self.tilemap.layer_manager.set_active_layer(idx)
                     continue
 
+            # Priority 5: Toolbar
             if self.toolbar and self.toolbar.handle_event(event):
                 continue
 
-            if self.autotiler.visible:
-                if self.autotiler.handle_event(event):
-                    continue
-
-            if self.regex_automap_designer.visible:
-                if self.regex_automap_designer.handle_event(event):
-                    continue
-
-            # Route events to the dockable animation panel
+            # Priority 6: Dockable animation panel
             if self.left_panel_visible and self.animation_panel:
                 if hasattr(self.animation_panel, "handle_event"):
                     if self.animation_panel.handle_event(event):
                         continue
 
+            # Priority 7: Side panels (tileset and layer widgets)
             consumed = False
             if self.tileset_widget and self.tileset_widget.handle_event(event):
                 consumed = True
@@ -862,6 +868,8 @@ class Editor:
                 and self.layer_widget.handle_event(event)
             ):
                 consumed = True
+            
+            # Priority 8: Main tile grid (lowest priority)
             if not consumed and self.tile_grid_widget:
                 self.tile_grid_widget.handle_event(event)
 
@@ -894,9 +902,22 @@ class Editor:
                 self.tileset_widget.draw(self.screen)
             if self.layer_widget:
                 self.layer_widget.draw(self.screen)
+            
+            # Draw autotiler and regex designer with modal overlay
             if self.autotiler:
+                if self.autotiler.visible:
+                    # Dim background when autotiler is open
+                    overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
+                    overlay.fill((0, 0, 0, 100))
+                    self.screen.blit(overlay, (0, 0))
                 self.autotiler.draw(self.screen)
+            
             if self.regex_automap_designer:
+                if self.regex_automap_designer.visible:
+                    # Dim background when regex designer is open
+                    overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
+                    overlay.fill((0, 0, 0, 100))
+                    self.screen.blit(overlay, (0, 0))
                 self.regex_automap_designer.draw(self.screen)
 
             # Draw the dockable animation panel

{tilemap_editor-2.0.2 → tilemap_editor-2.0.3/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-2.0.2 → tilemap_editor-2.0.3}/src/widgets/autotile_template.py

@@ -166,6 +166,14 @@ class AutotileTemplateApplier:
         if not ts:
             return
 
+        # Check if a group is selected
+        if self.designer.selected_group_idx == -1:
+            print("Template Error: No group selected. Please select a group first.")
+            return
+
+        # Use the currently selected group
+        target_group = self.designer.groups[self.designer.selected_group_idx]
+
         rx, ry, rw, rh = tile_selector.selected_tile
         tile_w, tile_h = self.designer.editor.tilemap.tile_size
         sheet_cols = ts.surface.get_width() // tile_w
@@ -173,24 +181,6 @@ class AutotileTemplateApplier:
         start_col = rx // tile_w
         start_row = ry // tile_h
 
-        # Define a unique group ID for THIS specific 3x3 selection area
-        # (e.g. "GrassSet_12_4")
-        set_id = f"{ts.name}_{start_col}_{start_row}"
-
-        from .autotiler import AutotileGroup
-
-        # Create a real group object in the designer
-        target_group = None
-        for g in self.designer.groups:
-            if g.name == set_id:
-                target_group = g
-                break
-
-        if not target_group:
-            target_group = AutotileGroup(set_id)
-            self.designer.groups.append(target_group)
-            self.designer.selected_group_idx = len(self.designer.groups) - 1
-
         added_count = 0
         updated_count = 0
 
@@ -204,32 +194,43 @@ class AutotileTemplateApplier:
 
             ts_index = tile_selector.active_idx
 
-            # Check for existing rule in THIS group
+            # Check for existing rule in THIS group with EXACT same neighbors and tileset
             matched_rule = None
             for r in target_group.rules:
+                # Must match both neighbors AND tileset to be considered the same rule
                 if r.neighbors == neighbors and r.tileset_index == ts_index:
                     matched_rule = r
                     break
 
             if matched_rule:
+                # Only add variant if it's not already there
                 if vid not in matched_rule.variant_ids:
                     matched_rule.variant_ids.append(vid)
                     updated_count += 1
             else:
-                rule_name = f"{ts.name}_{start_col}_{start_row}_{rel_col}_{rel_row}"
+                # Create a new rule with a unique name
+                rule_num = len(target_group.rules) + 1
+                rule_name = f"Rule {rule_num}"
+                
+                # Ensure unique name
+                existing_names = {r.name for r in target_group.rules}
+                while rule_name in existing_names:
+                    rule_num += 1
+                    rule_name = f"Rule {rule_num}"
+                
                 new_rule = AutotileRule(
                     name=rule_name,
-                    neighbors=neighbors,
+                    neighbors=set(neighbors),  # Create a new set to avoid reference issues
                     tileset_path=str(ts.path),
                     variant_ids=[vid],
                     tileset_index=ts_index,
-                    group_id=set_id,
+                    group_id=target_group.name,
                 )
                 target_group.rules.append(new_rule)
                 added_count += 1
 
         print(
-            f"Template Applied: {template.name}. Group: {set_id}. {added_count} rules added, {updated_count} rules updated."
+            f"Template Applied: {template.name} to Group '{target_group.name}'. {added_count} rules added, {updated_count} rules updated."
         )
 
     def draw(self, screen: Surface):

{tilemap_editor-2.0.2 → tilemap_editor-2.0.3}/src/widgets/autotiler.py

@@ -87,7 +87,7 @@ class AutotileGroup:
 class AutotileRuleDesigner:
     def __init__(self, editor: "Editor", x: int, y: int):
         self.editor = editor
-        self.rect = Rect(x, y, 600, 450)
+        self.rect = Rect(x, y, 600, 500)  # Increased height to accommodate buttons outside list areas
         self.header_height = 30
 
         self.visible = False
@@ -102,7 +102,7 @@ class AutotileRuleDesigner:
         self.rename_text: str = ""
 
         self.scroll_offset: int = 0
-        self.max_visible_rules: int = 10
+        self.max_visible_rules: int = 6  # Reduced to make scrolling more visible
         self.scroll_bar_rect: Optional[Rect] = None
         self.is_scrollbar_dragging: bool = False
 
@@ -139,9 +139,16 @@ class AutotileRuleDesigner:
         body_h = self.rect.height - self.header_height
         sidebar_w = 200
         self.list_area = Rect(self.rect.x, body_y, sidebar_w, body_h)
-        self.group_list_area = Rect(self.rect.x, body_y, sidebar_w, body_h // 2)
+        
+        # Reserve space for buttons at the bottom of each list area
+        button_h = 30
+        group_content_h = (body_h // 2) - button_h
+        rule_content_h = (body_h // 2) - button_h
+        
+        # Group list area excludes the button
+        self.group_list_area = Rect(self.rect.x, body_y, sidebar_w, group_content_h)
         self.rule_list_area = Rect(
-            self.rect.x, body_y + body_h // 2, sidebar_w, body_h // 2
+            self.rect.x, body_y + body_h // 2, sidebar_w, rule_content_h
         )
 
         self.edit_area = Rect(
@@ -154,15 +161,16 @@ class AutotileRuleDesigner:
         self.save_btn_rect = Rect(cx - btn_w - 5, btn_y, btn_w, 30)
         self.delete_btn_rect = Rect(cx + 5, btn_y, btn_w, 30)
 
+        # Position buttons OUTSIDE their respective list areas to prevent click conflicts
         self.new_group_btn_rect = Rect(
             self.group_list_area.x + 10,
-            self.group_list_area.bottom - 35,
+            self.group_list_area.bottom + 5,  # Below the group list area
             self.group_list_area.width - 20,
             25,
         )
         self.new_rule_btn_rect = Rect(
             self.rule_list_area.x + 10,
-            self.rule_list_area.bottom - 30,
+            self.rule_list_area.bottom + 5,  # Below the rule list area
             self.rule_list_area.width - 20,
             25,
         )
@@ -277,10 +285,16 @@ class AutotileRuleDesigner:
                     )
                     return True
 
+                # Check buttons FIRST before checking list areas (since buttons are outside)
                 if self.new_group_btn_rect.collidepoint(mouse_pos):
                     self._create_new_group_with_focus()
                     return True
+                
+                if self.new_rule_btn_rect.collidepoint(mouse_pos):
+                    self._reset_selection()
+                    return True
 
+                # Then check list areas
                 if self.group_list_area.collidepoint(mouse_pos):
                     self._handle_group_list_click(mouse_pos)
                     return True
@@ -289,28 +303,18 @@ class AutotileRuleDesigner:
                     self._handle_rule_list_click(mouse_pos)
                     return True
 
-                if self.save_btn_rect.collidepoint(mouse_pos):
-                    self._save_current_rule()
-                    return True
-                if self.save_btn_rect.inflate(0, 40).collidepoint(mouse_pos):
-                    pass
-
-                if self.new_rule_btn_rect.collidepoint(mouse_pos):
-                    self._reset_selection()
-                    return True
-
+                # Edit area interactions
                 if self.edit_area.collidepoint(mouse_pos):
-                    if self._handle_grid_click(mouse_pos):
-                        return True
-
-                if self.delete_btn_rect.collidepoint(mouse_pos):
-                    self._delete_current_rule()
-                    return True
-                if self.external_btn_rect.collidepoint(mouse_pos):
-                    self._launch_external_viewer()
-                    return True
-                if self.template_btn_rect.collidepoint(mouse_pos):
-                    self.template_manager.show_at(mouse_pos)
+                    if self.save_btn_rect.collidepoint(mouse_pos):
+                        self._save_current_rule()
+                    elif self.delete_btn_rect.collidepoint(mouse_pos):
+                        self._delete_current_rule()
+                    elif self.external_btn_rect.collidepoint(mouse_pos):
+                        self._launch_external_viewer()
+                    elif self.template_btn_rect.collidepoint(mouse_pos):
+                        self.template_manager.show_at(mouse_pos)
+                    else:
+                        self._handle_grid_click(mouse_pos)
                     return True
 
         elif event.type == pygame.MOUSEBUTTONUP:
@@ -323,10 +327,8 @@ class AutotileRuleDesigner:
                 self._update_layout()
                 return True
 
-        if not self.rect.collidepoint(mouse_pos) and not self.is_dragging:
-            return False
-
-        return True
+        # Always consume events when visible to prevent clicks bleeding through
+        return self.rect.collidepoint(mouse_pos) or self.is_dragging
 
     def _sync_last_editor_state(self):
         tile_selector = getattr(self.editor, "tileset_widget", None)
@@ -430,10 +432,6 @@ class AutotileRuleDesigner:
                 return
 
     def _handle_rule_list_click(self, mouse_pos):
-        if self.new_rule_btn_rect.collidepoint(mouse_pos):
-            self._reset_selection()
-            return
-
         if self.selected_group_idx == -1:
             return
 
@@ -441,6 +439,17 @@ class AutotileRuleDesigner:
         start_y = self.rule_list_area.y + 25
         item_h = 25
         
+        # Only process clicks within the visible list area
+        list_content_area = Rect(
+            self.rule_list_area.x,
+            self.rule_list_area.y + 25,
+            self.rule_list_area.width,
+            self.rule_list_area.height - 25  # Adjusted since button is outside
+        )
+        
+        if not list_content_area.collidepoint(mouse_pos):
+            return
+        
         visible_start = self.scroll_offset
         visible_end = min(visible_start + self.max_visible_rules, len(group.rules))
         
@@ -684,6 +693,7 @@ class AutotileRuleDesigner:
             d_name = name if len(name) < 22 else name[:19] + ".."
             screen.blit(self.font.render(d_name, True, TEXT_COLOR), (r.x + 5, r.y + 5))
 
+        # Draw button OUTSIDE the group list area
         pygame.draw.rect(
             screen, (80, 120, 80), self.new_group_btn_rect, border_radius=4
         )
@@ -700,6 +710,7 @@ class AutotileRuleDesigner:
 
         self._draw_scrollable_rule_list(screen)
 
+        # Draw button OUTSIDE the rule list area
         pygame.draw.rect(
             screen, (70, 130, 180), self.new_rule_btn_rect, border_radius=4
         )
@@ -709,7 +720,7 @@ class AutotileRuleDesigner:
         )
 
     def _draw_scrollable_rule_list(self, screen: Surface) -> None:
-        """Draw rules with scroll indicators and scrollbar"""
+        """Draw rules with scroll indicators and scrollbar - with clipping to prevent overflow"""
         if self.selected_group_idx == -1:
             return
 
@@ -720,6 +731,17 @@ class AutotileRuleDesigner:
 
         self.scroll_offset = max(0, min(self.scroll_offset, max_scroll))
 
+        # Set clip rect to prevent rules from rendering outside the list area
+        # Since button is now outside, we can use more of the area
+        list_clip = Rect(
+            self.rule_list_area.x,
+            self.rule_list_area.y + 25,
+            self.rule_list_area.width,
+            self.rule_list_area.height - 25  # Just leave space for header
+        )
+        old_clip = screen.get_clip()
+        screen.set_clip(list_clip)
+
         visible_start = self.scroll_offset
         visible_end = min(visible_start + self.max_visible_rules, total_rules)
 
@@ -741,6 +763,9 @@ class AutotileRuleDesigner:
             d_name = rule.name if len(rule.name) < 20 else rule.name[:17] + ".."
             screen.blit(self.font.render(d_name, True, TEXT_COLOR), (r.x + 5, r.y + 5))
 
+        # Restore clip
+        screen.set_clip(old_clip)
+
         if total_rules > self.max_visible_rules:
             if self.scroll_offset > 0:
                 arrow_up = "▲"
@@ -755,11 +780,11 @@ class AutotileRuleDesigner:
                 arrow_surf = self.font.render(arrow_down, True, (150, 200, 255))
                 screen.blit(
                     arrow_surf,
-                    (self.rule_list_area.right - 20, self.rule_list_area.bottom - 35),
+                    (self.rule_list_area.right - 20, self.rule_list_area.bottom - 20),
                 )
 
             scrollbar_height = 60
-            track_height = self.rule_list_area.height - 70
+            track_height = self.rule_list_area.height - 50
             scroll_ratio = self.scroll_offset / max_scroll if max_scroll > 0 else 0
 
             scrollbar_y = (
@@ -812,7 +837,7 @@ class AutotileRuleDesigner:
         elif event.type == pygame.MOUSEMOTION:
             if self.is_scrollbar_dragging:
                 relative_y = event.pos[1] - self.rule_list_area.y - 25
-                track_height = self.rule_list_area.height - 70
+                track_height = self.rule_list_area.height - 50  # Updated to match drawing
 
                 if track_height > 0:
                     scroll_ratio = max(0, min(1, relative_y / track_height))