trianglengin 1.0.6__py3-none-any.whl

trianglengin/visualization/drawing/__init__.py

@@ -0,0 +1,30 @@
+# trianglengin/visualization/drawing/__init__.py
+"""Drawing functions for specific visual elements."""
+
+from .grid import (
+    draw_debug_grid_overlay,  # Keep if used elsewhere
+    draw_grid_background,
+    # draw_grid_indices, # Removed - integrated into background
+    draw_grid_state,  # Renamed from draw_grid_triangles
+)
+from .highlight import draw_debug_highlight
+from .hud import render_hud
+from .previews import (
+    draw_floating_preview,
+    draw_placement_preview,
+    render_previews,
+)
+from .shapes import draw_shape
+
+__all__ = [
+    "draw_grid_background",
+    "draw_grid_state",  # Export renamed function
+    "draw_debug_grid_overlay",
+    # "draw_grid_indices", # Removed
+    "draw_shape",
+    "render_previews",
+    "draw_placement_preview",
+    "draw_floating_preview",
+    "render_hud",
+    "draw_debug_highlight",
+]

trianglengin/visualization/drawing/grid.py

@@ -0,0 +1,156 @@
+# File: trianglengin/visualization/drawing/grid.py
+import logging
+from typing import TYPE_CHECKING
+
+import pygame
+
+from trianglengin.core.structs.triangle import Triangle
+from trianglengin.visualization.core import colors
+
+if TYPE_CHECKING:
+    from trianglengin.config import DisplayConfig, EnvConfig
+    from trianglengin.core.environment.grid.grid_data import GridData
+
+
+log = logging.getLogger(__name__)
+
+
+def draw_grid_background(
+    surface: pygame.Surface,
+    env_config: "EnvConfig",
+    display_config: "DisplayConfig",
+    cw: float,
+    ch: float,
+    ox: float,
+    oy: float,
+    game_over: bool = False,
+    debug_mode: bool = False,
+) -> None:
+    """Draws the background grid structure using pre-calculated render parameters."""
+    bg_color = colors.GRID_BG_GAME_OVER if game_over else colors.GRID_BG_DEFAULT
+    surface.fill(bg_color)
+
+    if cw <= 0 or ch <= 0:
+        log.warning("Cannot draw grid background with zero cell dimensions.")
+        return
+
+    for r in range(env_config.ROWS):
+        # Use PLAYABLE_RANGE_PER_ROW to determine death zones
+        start_col, end_col = env_config.PLAYABLE_RANGE_PER_ROW[r]
+        for c in range(env_config.COLS):
+            is_up = (r + c) % 2 != 0
+            is_death = not (start_col <= c < end_col)  # Check if outside playable range
+            tri = Triangle(r, c, is_up, is_death)
+
+            if is_death:
+                cell_color = colors.DEATH_ZONE_COLOR
+            else:
+                cell_color = (
+                    colors.GRID_BG_LIGHT if (r % 2 == c % 2) else colors.GRID_BG_DARK
+                )
+
+            points = tri.get_points(ox, oy, cw, ch)
+            pygame.draw.polygon(surface, cell_color, points)
+            pygame.draw.polygon(surface, colors.GRID_LINE_COLOR, points, 1)
+
+            if debug_mode:
+                font = display_config.DEBUG_FONT
+                text = f"{r},{c}"
+                text_surf = font.render(text, True, colors.DEBUG_TOGGLE_COLOR)
+                center_x = sum(p[0] for p in points) / 3
+                center_y = sum(p[1] for p in points) / 3
+                text_rect = text_surf.get_rect(center=(center_x, center_y))
+                surface.blit(text_surf, text_rect)
+
+
+def draw_grid_state(
+    surface: pygame.Surface,
+    grid_data: "GridData",
+    cw: float,
+    ch: float,
+    ox: float,
+    oy: float,
+) -> None:
+    """Draws the occupied triangles with their colors using pre-calculated parameters."""
+    rows, cols = grid_data.rows, grid_data.cols
+    occupied_np = grid_data._occupied_np
+    color_id_np = grid_data._color_id_np
+    death_np = grid_data._death_np
+
+    if cw <= 0 or ch <= 0:
+        log.warning("Cannot draw grid state with zero cell dimensions.")
+        return
+
+    for r in range(rows):
+        for c in range(cols):
+            if death_np[r, c]:
+                continue
+
+            if occupied_np[r, c]:
+                color_id = int(color_id_np[r, c])
+                color = colors.ID_TO_COLOR_MAP.get(color_id)
+
+                is_up = (r + c) % 2 != 0
+                tri = Triangle(r, c, is_up, False)
+                points = tri.get_points(ox, oy, cw, ch)
+
+                if color is not None:
+                    pygame.draw.polygon(surface, color, points)
+                elif color_id == colors.DEBUG_COLOR_ID:
+                    pygame.draw.polygon(surface, colors.DEBUG_TOGGLE_COLOR, points)
+                else:
+                    log.warning(
+                        f"Occupied cell ({r},{c}) has invalid color ID: {color_id}"
+                    )
+                    pygame.draw.polygon(surface, colors.TRIANGLE_EMPTY_COLOR, points)
+
+
+def draw_debug_grid_overlay(
+    surface: pygame.Surface,
+    grid_data: "GridData",
+    display_config: "DisplayConfig",
+    cw: float,
+    ch: float,
+    ox: float,
+    oy: float,
+) -> None:
+    """Draws debug information using pre-calculated render parameters."""
+    font = display_config.DEBUG_FONT
+    rows, cols = grid_data.rows, grid_data.cols
+
+    if cw <= 0 or ch <= 0:
+        log.warning("Cannot draw debug overlay with zero cell dimensions.")
+        return
+
+    for r in range(rows):
+        for c in range(cols):
+            is_up = (r + c) % 2 != 0
+            is_death = grid_data.is_death(r, c)
+            tri = Triangle(r, c, is_up, is_death)
+            points = tri.get_points(ox, oy, cw, ch)
+
+            text = f"{r},{c}"
+            text_surf = font.render(text, True, colors.DEBUG_TOGGLE_COLOR)
+            center_x = sum(p[0] for p in points) / 3
+            center_y = sum(p[1] for p in points) / 3
+            text_rect = text_surf.get_rect(center=(center_x, center_y))
+            surface.blit(text_surf, text_rect)
+
+
+def draw_grid(
+    surface: pygame.Surface,
+    grid_data: "GridData",
+    env_config: "EnvConfig",
+    display_config: "DisplayConfig",
+    cw: float,
+    ch: float,
+    ox: float,
+    oy: float,
+    game_over: bool = False,
+    debug_mode: bool = False,
+) -> None:
+    """Main function to draw the entire grid including background and state."""
+    draw_grid_background(
+        surface, env_config, display_config, cw, ch, ox, oy, game_over, debug_mode
+    )
+    draw_grid_state(surface, grid_data, cw, ch, ox, oy)

trianglengin/visualization/drawing/highlight.py

@@ -0,0 +1,30 @@
+# File: trianglengin/visualization/drawing/highlight.py
+import pygame
+
+# Use internal imports
+from ...core.structs import Triangle
+from ..core import colors
+
+
+def draw_debug_highlight(
+    surface: pygame.Surface,
+    r: int,
+    c: int,
+    # config: EnvConfig, # Removed - use cw, ch, ox, oy
+    cw: float,
+    ch: float,
+    ox: float,
+    oy: float,
+) -> None:
+    """Highlights a specific triangle border for debugging using pre-calculated parameters."""
+    if surface.get_width() <= 0 or surface.get_height() <= 0:
+        return
+
+    if cw <= 0 or ch <= 0:
+        return
+
+    is_up = (r + c) % 2 != 0
+    temp_tri = Triangle(r, c, is_up)
+    pts = temp_tri.get_points(ox, oy, cw, ch)
+
+    pygame.draw.polygon(surface, colors.DEBUG_TOGGLE_COLOR, pts, 3)

trianglengin/visualization/drawing/hud.py

@@ -0,0 +1,39 @@
+# File: trianglengin/trianglengin/visualization/drawing/hud.py
+from typing import Any
+
+import pygame
+
+# Use internal imports
+from ..core import colors
+
+
+def render_hud(
+    surface: pygame.Surface,
+    mode: str,
+    fonts: dict[str, pygame.font.Font | None],
+    _display_stats: dict[str, Any] | None = None,  # Prefix with underscore
+) -> None:
+    """
+    Renders HUD elements for interactive modes (play/debug).
+    Displays only help text relevant to the mode.
+    Ignores _display_stats.
+    """
+    screen_w, screen_h = surface.get_size()
+    help_font = fonts.get("help")
+
+    if not help_font:
+        return
+
+    bottom_y = screen_h - 10  # Position from bottom
+
+    # --- Render Help Text Only ---
+    help_text = "[ESC] Quit"
+    if mode == "play":
+        help_text += " | [Click] Select/Place Shape"
+    elif mode == "debug":
+        help_text += " | [Click] Toggle Cell"
+
+    help_surf = help_font.render(help_text, True, colors.LIGHT_GRAY)
+    # Position help text at the bottom right
+    help_rect = help_surf.get_rect(bottomright=(screen_w - 15, bottom_y))
+    surface.blit(help_surf, help_rect)

trianglengin/visualization/drawing/previews.py

@@ -0,0 +1,172 @@
+# File: trianglengin/visualization/drawing/previews.py
+import logging
+
+import pygame
+
+# Use internal imports
+from trianglengin.config import DisplayConfig, EnvConfig
+from trianglengin.core.environment import GameState
+from trianglengin.core.structs import Shape, Triangle
+from trianglengin.visualization.core import colors
+
+from .shapes import draw_shape
+
+logger = logging.getLogger(__name__)
+
+
+def render_previews(
+    surface: pygame.Surface,
+    game_state: GameState,
+    area_topleft: tuple[int, int],
+    _mode: str,
+    env_config: EnvConfig,
+    display_config: DisplayConfig,
+    selected_shape_idx: int = -1,
+) -> dict[int, pygame.Rect]:
+    """Renders shape previews in their area. Returns dict {index: screen_rect}."""
+    surface.fill(colors.PREVIEW_BG_COLOR)
+    preview_rects_screen: dict[int, pygame.Rect] = {}
+    num_slots = env_config.NUM_SHAPE_SLOTS
+    pad = display_config.PREVIEW_PADDING
+    inner_pad = display_config.PREVIEW_INNER_PADDING
+    border = display_config.PREVIEW_BORDER_WIDTH
+    selected_border = display_config.PREVIEW_SELECTED_BORDER_WIDTH
+
+    if num_slots <= 0:
+        return {}
+
+    total_pad_h = (num_slots + 1) * pad
+    available_h = surface.get_height() - total_pad_h
+    slot_h = available_h / num_slots if num_slots > 0 else 0
+    slot_w = surface.get_width() - 2 * pad
+
+    current_y = float(pad)
+
+    for i in range(num_slots):
+        slot_rect_local = pygame.Rect(pad, int(current_y), int(slot_w), int(slot_h))
+        slot_rect_screen = slot_rect_local.move(area_topleft)
+        preview_rects_screen[i] = slot_rect_screen
+
+        shape: Shape | None = game_state.shapes[i]
+        is_selected = selected_shape_idx == i
+
+        border_width = selected_border if is_selected else border
+        border_color = (
+            colors.PREVIEW_SELECTED_BORDER if is_selected else colors.PREVIEW_BORDER
+        )
+        pygame.draw.rect(surface, border_color, slot_rect_local, border_width)
+
+        if shape:
+            draw_area_w = slot_w - 2 * (border_width + inner_pad)
+            draw_area_h = slot_h - 2 * (border_width + inner_pad)
+
+            if draw_area_w > 0 and draw_area_h > 0:
+                min_r, min_c, max_r, max_c = shape.bbox()
+                shape_rows = max_r - min_r + 1
+                shape_cols_eff = (
+                    (max_c - min_c + 1) * 0.75 + 0.25 if shape.triangles else 1
+                )
+
+                scale_w = (
+                    draw_area_w / shape_cols_eff if shape_cols_eff > 0 else draw_area_w
+                )
+                scale_h = draw_area_h / shape_rows if shape_rows > 0 else draw_area_h
+                cell_size = max(1.0, min(scale_w, scale_h))
+
+                shape_render_w = shape_cols_eff * cell_size
+                shape_render_h = shape_rows * cell_size
+                draw_topleft_x = (
+                    slot_rect_local.left
+                    + border_width
+                    + inner_pad
+                    + (draw_area_w - shape_render_w) / 2
+                )
+                draw_topleft_y = (
+                    slot_rect_local.top
+                    + border_width
+                    + inner_pad
+                    + (draw_area_h - shape_render_h) / 2
+                )
+
+                draw_shape(
+                    surface,
+                    shape,
+                    (int(draw_topleft_x), int(draw_topleft_y)),
+                    cell_size,
+                    _is_selected=is_selected,
+                    origin_offset=(-min_r, -min_c),
+                )
+
+        current_y += slot_h + pad
+
+    return preview_rects_screen
+
+
+def draw_placement_preview(
+    surface: pygame.Surface,
+    shape: Shape,
+    r: int,
+    c: int,
+    is_valid: bool,
+    cw: float,
+    ch: float,
+    ox: float,
+    oy: float,
+) -> None:
+    """Draws a semi-transparent shape snapped to the grid using pre-calculated parameters."""
+    if not shape or not shape.triangles:
+        return
+
+    if cw <= 0 or ch <= 0:
+        return
+
+    alpha = 100
+    base_color = (
+        colors.PLACEMENT_VALID_COLOR if is_valid else colors.PLACEMENT_INVALID_COLOR
+    )
+    color: colors.ColorRGBA = (base_color[0], base_color[1], base_color[2], alpha)
+
+    temp_surface = pygame.Surface(surface.get_size(), pygame.SRCALPHA)
+    temp_surface.fill((0, 0, 0, 0))
+
+    for dr, dc, is_up in shape.triangles:
+        tri_r, tri_c = r + dr, c + dc
+        temp_tri = Triangle(tri_r, tri_c, is_up)
+        pts = temp_tri.get_points(ox, oy, cw, ch)
+        pygame.draw.polygon(temp_surface, color, pts)
+
+    surface.blit(temp_surface, (0, 0))
+
+
+def draw_floating_preview(
+    surface: pygame.Surface,
+    shape: Shape,
+    screen_pos: tuple[int, int],
+    # _config: EnvConfig, # Removed - not needed with fixed cell_size
+    # _mapper_module: "coord_mapper_module", # Removed
+) -> None:
+    """Draws a semi-transparent shape floating at the screen position."""
+    if not shape or not shape.triangles:
+        return
+
+    cell_size = 20.0  # Fixed size for floating preview
+    alpha = 100
+    color: colors.ColorRGBA = (shape.color[0], shape.color[1], shape.color[2], alpha)
+
+    temp_surface = pygame.Surface(surface.get_size(), pygame.SRCALPHA)
+    temp_surface.fill((0, 0, 0, 0))
+
+    min_r, min_c, max_r, max_c = shape.bbox()
+    center_r = (min_r + max_r) / 2.0
+    center_c = (min_c + max_c) / 2.0
+
+    for dr, dc, is_up in shape.triangles:
+        pt_x = screen_pos[0] + (dc - center_c) * (cell_size * 0.75)
+        pt_y = screen_pos[1] + (dr - center_r) * cell_size
+
+        temp_tri = Triangle(0, 0, is_up)
+        rel_pts = temp_tri.get_points(0, 0, cell_size, cell_size)
+        pts = [(px + pt_x, py + pt_y) for px, py in rel_pts]
+        pygame.draw.polygon(temp_surface, color, pts)
+
+    surface.blit(temp_surface, (0, 0))

trianglengin/visualization/drawing/shapes.py

@@ -0,0 +1,36 @@
+import pygame
+
+# Use internal imports
+from ...core.structs import Shape, Triangle
+from ..core import colors
+
+
+def draw_shape(
+    surface: pygame.Surface,
+    shape: Shape,
+    topleft: tuple[int, int],
+    cell_size: float,
+    _is_selected: bool = False,
+    origin_offset: tuple[int, int] = (0, 0),
+) -> None:
+    """Draws a single shape onto a surface."""
+    if not shape or not shape.triangles or cell_size <= 0:
+        return
+
+    shape_color = shape.color
+    border_color = colors.GRAY
+
+    cw = cell_size
+    ch = cell_size
+
+    for dr, dc, is_up in shape.triangles:
+        adj_r, adj_c = dr + origin_offset[0], dc + origin_offset[1]
+
+        tri_x = topleft[0] + adj_c * (cw * 0.75)
+        tri_y = topleft[1] + adj_r * ch
+
+        temp_tri = Triangle(0, 0, is_up)
+        pts = [(px + tri_x, py + tri_y) for px, py in temp_tri.get_points(0, 0, cw, ch)]
+
+        pygame.draw.polygon(surface, shape_color, pts)
+        pygame.draw.polygon(surface, border_color, pts, 1)