trianglengin 2.0.1__cp312-cp312-musllinux_1_2_x86_64.whl

trianglengin/ui/visualization/drawing/previews.py

@@ -0,0 +1,181 @@
+import logging
+
+# Guard UI imports
+try:
+    import pygame
+
+    # Import DisplayConfig from the correct UI location
+    from trianglengin.ui.config import DisplayConfig
+
+    from ..core import colors  # Relative import
+    from .shapes import draw_shape  # Relative import
+    from .utils import get_triangle_points  # Relative import
+except ImportError as e:
+    raise ImportError(
+        "UI components require 'pygame'. Install with 'pip install trianglengin[ui]'."
+    ) from e
+
+# Use absolute imports for core components
+from trianglengin.config import EnvConfig
+from trianglengin.game_interface import Shape
+
+logger = logging.getLogger(__name__)
+
+
+def render_previews(
+    surface: pygame.Surface,
+    shapes: list[Shape | None],  # Core Shape
+    area_topleft: tuple[int, int],
+    _mode: str,
+    env_config: EnvConfig,  # Core EnvConfig
+    display_config: DisplayConfig,  # UI 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))
+        # Calculate absolute screen rect for collision detection later
+        slot_rect_screen = slot_rect_local.move(area_topleft)
+        preview_rects_screen[i] = slot_rect_screen
+
+        shape: Shape | None = shapes[i] if i < len(shapes) else None
+        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
+        )
+        # Draw border onto the local surface
+        pygame.draw.rect(surface, border_color, slot_rect_local, border_width)
+
+        if shape:
+            # Calculate drawing area inside the border and padding
+            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
+                # Effective columns considering 0.75 width factor for triangles
+                shape_cols_eff = (
+                    (max_c - min_c + 1) * 0.75 + 0.25 if shape.triangles else 1
+                )
+                # Calculate scale to fit shape within draw area
+                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))  # Use smallest scale
+
+                # Calculate centered top-left position for drawing the shape
+                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 the shape onto the local surface
+                draw_shape(
+                    surface,
+                    shape,
+                    (int(draw_topleft_x), int(draw_topleft_y)),
+                    cell_size,
+                    _is_selected=is_selected,
+                    origin_offset=(-min_r, -min_c),  # Adjust drawing origin
+                )
+        current_y += slot_h + pad
+    return preview_rects_screen
+
+
+def draw_placement_preview(
+    surface: pygame.Surface,
+    shape: Shape,  # Core 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)
+    # Create a temporary surface for alpha blending
+    temp_surface = pygame.Surface(surface.get_size(), pygame.SRCALPHA)
+    temp_surface.fill((0, 0, 0, 0))  # Transparent background
+
+    for dr, dc, is_up in shape.triangles:
+        tri_r, tri_c = r + dr, c + dc
+        # Use helper to get points relative to grid origin
+        pts = get_triangle_points(tri_r, tri_c, is_up, ox, oy, cw, ch)
+        pygame.draw.polygon(temp_surface, color, pts)
+
+    # Blit the temporary surface onto the main surface
+    surface.blit(temp_surface, (0, 0))
+
+
+def draw_floating_preview(
+    surface: pygame.Surface,
+    shape: Shape,  # Core Shape
+    screen_pos: tuple[int, int],
+) -> 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)
+    # Create a temporary surface for alpha blending
+    temp_surface = pygame.Surface(surface.get_size(), pygame.SRCALPHA)
+    temp_surface.fill((0, 0, 0, 0))  # Transparent background
+
+    # Center the shape around the screen_pos
+    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:
+        # Calculate position relative to the center of the shape bbox
+        pt_x = screen_pos[0] + (dc - center_c) * (cell_size * 0.75)
+        pt_y = screen_pos[1] + (dr - center_r) * cell_size
+        # Use helper to get points relative to (0,0) for local drawing
+        rel_pts = get_triangle_points(0, 0, is_up, 0, 0, cell_size, cell_size)
+        # Translate points to the calculated screen position
+        pts = [(px + pt_x, py + pt_y) for px, py in rel_pts]
+        pygame.draw.polygon(temp_surface, color, pts)
+
+    # Blit the temporary surface onto the main surface
+    surface.blit(temp_surface, (0, 0))

trianglengin/ui/visualization/drawing/shapes.py

@@ -0,0 +1,46 @@
+# Guard UI imports
+try:
+    import pygame
+
+    from ..core import colors  # Relative import
+    from .utils import get_triangle_points  # Relative import
+except ImportError as e:
+    raise ImportError(
+        "UI components require 'pygame'. Install with 'pip install trianglengin[ui]'."
+    ) from e
+
+# Use absolute imports for core components
+from trianglengin.game_interface import Shape
+
+
+def draw_shape(
+    surface: pygame.Surface,
+    shape: Shape,  # Core Shape
+    topleft: tuple[int, int],
+    cell_size: float,
+    _is_selected: bool = False,  # Keep underscore if not used visually
+    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  # Use a defined border color
+    cw = cell_size
+    ch = cell_size  # Assuming square aspect ratio for cells in preview
+
+    for dr, dc, is_up in shape.triangles:
+        # Adjust relative coords by origin offset (used for centering in previews)
+        adj_r, adj_c = dr + origin_offset[0], dc + origin_offset[1]
+        # Calculate top-left corner of the bounding box for this triangle
+        tri_x = topleft[0] + adj_c * (cw * 0.75)
+        tri_y = topleft[1] + adj_r * ch
+        # Use helper to get points relative to (0,0) for local drawing
+        # then translate them to the calculated tri_x, tri_y
+        pts = [
+            (px + tri_x, py + tri_y)
+            for px, py in get_triangle_points(0, 0, is_up, 0, 0, cw, ch)
+        ]
+        pygame.draw.polygon(surface, shape_color, pts)
+        pygame.draw.polygon(surface, border_color, pts, 1)  # Draw border

trianglengin/ui/visualization/drawing/utils.py

@@ -0,0 +1,23 @@
+"""Utility functions for the drawing module."""
+
+
+def get_triangle_points(
+    r: int, c: int, is_up: bool, ox: float, oy: float, cw: float, ch: float
+) -> list[tuple[float, float]]:
+    """
+    Calculates vertex points for drawing a triangle, relative to origin (ox, oy).
+    """
+    # Top-left corner of the bounding rectangle for the cell (r, c)
+    # Note the horizontal offset depends only on column (c * 0.75 * cw)
+    # Note the vertical offset depends only on row (r * ch)
+    x = ox + c * (cw * 0.75)
+    y = oy + r * ch
+
+    if is_up:
+        # Points for an upward-pointing triangle (base at bottom)
+        # Vertices: Bottom-left, Bottom-right, Top-middle
+        return [(x, y + ch), (x + cw, y + ch), (x + cw / 2, y)]
+    else:
+        # Points for a downward-pointing triangle (base at top)
+        # Vertices: Top-left, Top-right, Bottom-middle
+        return [(x, y), (x + cw, y), (x + cw / 2, y + ch)]

trianglengin/utils/__init__.py

@@ -0,0 +1,9 @@
+"""
+General utilities for the Triangle Engine.
+"""
+
+# --- ADDED: Export geometry ---
+from . import geometry
+from .types import ActionType
+
+__all__ = ["ActionType", "geometry"]

trianglengin/utils/geometry.py

@@ -0,0 +1,62 @@
+# File: src/trianglengin/utils/geometry.py
+from collections.abc import Sequence  # Import Tuple
+
+
+def is_point_in_polygon(
+    point: tuple[float, float], polygon: Sequence[tuple[float, float]]
+) -> bool:
+    """
+    Checks if a point is inside a polygon using the Winding Number algorithm.
+    Handles points on the boundary correctly.
+
+    Args:
+        point: Tuple (x, y) representing the point coordinates.
+        polygon: Sequence of tuples [(x1, y1), (x2, y2), ...] representing polygon vertices in order.
+
+    Returns:
+        True if the point is inside or on the boundary of the polygon, False otherwise.
+    """
+    x, y = point
+    n = len(polygon)
+    if n < 3:
+        return False
+
+    wn = 0
+    epsilon = 1e-9
+
+    for i in range(n):
+        p1 = polygon[i]
+        p2 = polygon[(i + 1) % n]
+
+        if abs(p1[0] - x) < epsilon and abs(p1[1] - y) < epsilon:
+            return True
+        if (
+            abs(p1[1] - p2[1]) < epsilon
+            and abs(p1[1] - y) < epsilon
+            and min(p1[0], p2[0]) - epsilon <= x <= max(p1[0], p2[0]) + epsilon
+        ):
+            return True
+        if (
+            abs(p1[0] - p2[0]) < epsilon
+            and abs(p1[0] - x) < epsilon
+            and min(p1[1], p2[1]) - epsilon <= y <= max(p1[1], p2[1]) + epsilon
+        ):
+            return True
+
+        y_in_upward_range = p1[1] <= y + epsilon < p2[1] + epsilon
+        y_in_downward_range = p2[1] <= y + epsilon < p1[1] + epsilon
+
+        if y_in_upward_range or y_in_downward_range:
+            orientation = (p2[0] - p1[0]) * (y - p1[1]) - (x - p1[0]) * (p2[1] - p1[1])
+            if y_in_upward_range and orientation > epsilon:
+                wn += 1
+            elif y_in_downward_range and orientation < -epsilon:
+                wn -= 1
+            elif (
+                abs(orientation) < epsilon
+                and min(p1[0], p2[0]) - epsilon <= x <= max(p1[0], p2[0]) + epsilon
+                and min(p1[1], p2[1]) - epsilon <= y <= max(p1[1], p2[1]) + epsilon
+            ):
+                return True
+
+    return wn != 0

trianglengin/utils/types.py

@@ -0,0 +1,10 @@
+# File: trianglengin/trianglengin/utils/types.py
+# Placeholder for Phase 1
+"""
+Shared type definitions for the Triangle Engine.
+"""
+
+from typing import TypeAlias
+
+# Action representation (integer index)
+ActionType: TypeAlias = int

trianglengin-2.0.1.dist-info/METADATA

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: trianglengin
+Version: 2.0.1
+Summary: High-performance C++/Python engine for a triangle puzzle game.
+Author-email: "Luis Guilherme P. M." <lgpelin92@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/lguibr/trianglengin
+Project-URL: Bug Tracker, https://github.com/lguibr/trianglengin/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: C++
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Games/Entertainment :: Puzzle Games
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing_extensions>=4.0.0
+Requires-Dist: pygame>=2.1.0
+Requires-Dist: typer[all]>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=3.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.0.0; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: codecov; extra == "dev"
+Dynamic: license-file
+
+
+[![CI Status](https://github.com/lguibr/trianglengin/actions/workflows/ci_cd.yml/badge.svg)](https://github.com/lguibr/trianglengin/actions/workflows/ci_cd.yml)
+[![codecov](https://codecov.io/gh/lguibr/trianglengin/graph/badge.svg?token=YOUR_CODECOV_TOKEN_HERE&flag=trianglengin)](https://codecov.io/gh/lguibr/trianglengin)
+[![PyPI version](https://badge.fury.io/py/trianglengin.svg)](https://badge.fury.io/py/trianglengin)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+
+# Triangle Engine (`trianglengin`) v2
+<img src="bitmap.png" alt="trianglengin logo" width="300"/>
+
+**Version 2 introduces a high-performance C++ core for the game logic.**
+
+This library provides the core components for a triangle puzzle game, suitable for reinforcement learning agents or other applications requiring a fast game engine. Interactive play/debug modes are included.
+
+It encapsulates:
+
+1.  **Core Game Logic (C++):** High-performance implementation of environment rules, state representation, actions, placement validation, and line clearing. ([`src/trianglengin/cpp/README.md`](src/trianglengin/cpp/README.md))
+2.  **Python Interface:** A Python `GameState` wrapper providing a user-friendly API to interact with the C++ core. ([`src/trianglengin/game_interface.py`](src/trianglengin/game_interface.py))
+3.  **Configuration (Python/Pydantic):** Models for environment settings (`EnvConfig`). ([`src/trianglengin/config/README.md`](src/trianglengin/config/README.md))
+4.  **Utilities (Python):** General helpers, geometry functions, shared types. ([`src/trianglengin/utils/README.md`](src/trianglengin/utils/README.md))
+5.  **UI Components (Python/Pygame/Typer):** Basic visualization, interaction handling, and CLI for interactive modes. ([`src/trianglengin/ui/README.md`](src/trianglengin/ui/README.md))
+
+---
+
+## 🎮 The Ultimate Triangle Puzzle Guide 🧩
+
+*(Game rules remain the same)*
+
+*(... Game rules section remains unchanged ...)*
+
+---
+
+## Purpose
+
+The primary goal is to provide a self-contained, installable library with a high-performance C++ core and a Python interface for the triangle puzzle game. This allows different RL agent implementations or other applications to build upon a consistent and fast game backend. The interactive UI is included but only initialized when running the specific UI commands.
+
+## Installation
+
+**Prerequisites:**
+*   A C++ compiler supporting C++17 (e.g., GCC, Clang, MSVC).
+*   CMake (version 3.14 or higher).
+*   Python (>= 3.10) and Pip.
+
+```bash
+# For standard use (once published or built):
+pip install trianglengin
+
+# Building from source (requires compiler and CMake):
+git clone https://github.com/lguibr/trianglengin.git
+cd trianglengin
+pip install .
+```
+*(Note: `pygame` and `typer` will be installed as core dependencies).*
+
+## Running Interactive Modes
+
+After installing, you can run the interactive modes directly:
+
+- **Play Mode:**
+  ```bash
+  trianglengin play [--seed 42] [--log-level INFO]
+  ```
+- **Debug Mode:**
+  ```bash
+  trianglengin debug [--seed 42] [--log-level DEBUG]
+  ```
+
+---
+
+## Local Development & Testing
+
+These instructions are for developers contributing to `trianglengin`.
+
+1.  **Clone the Repository:**
+    ```bash
+    git clone https://github.com/lguibr/trianglengin.git
+    cd trianglengin
+    ```
+
+2.  **Prerequisites:** Ensure you have a C++17 compiler and CMake installed.
+
+3.  **Create and Activate Virtual Environment:** (venv or conda)
+    ```bash
+    # Example using venv
+    python -m venv venv
+    source venv/bin/activate # or .\venv\Scripts\activate on Windows
+    ```
+    **IMPORTANT:** Ensure your virtual environment is activated.
+
+4.  **Install Build Dependencies:** (Needed even for core dev)
+    ```bash
+    pip install pybind11>=2.10 cmake wheel
+    ```
+
+5.  **Clean Previous Builds (Optional but Recommended):**
+    ```bash
+    rm -rf build/ src/trianglengin.egg-info/ dist/ src/trianglengin/trianglengin_cpp.*.so src/trianglengin/trianglengin_cpp*.cpp
+    ```
+
+6.  **Install in Editable Mode with Dev Dependencies:**
+    *   **Make sure your virtual environment is active!**
+    *   Run from the project root directory:
+        ```bash
+        # Installs core, UI, and dev tools
+        pip install -e '.[dev]'
+        ```
+        This command compiles the C++ extension and installs the Python package so changes are reflected immediately. It also installs development tools.
+
+7.  **Running Checks:**
+    *   **Make sure your virtual environment is active!**
+    *   **Tests & Coverage:**
+        ```bash
+        pytest tests/ --cov=src/trianglengin --cov-report=xml
+        ```
+        (Coverage measures core Python code, excluding UI).
+        To just run tests: `pytest`
+    *   **Linting:** `ruff check .`
+    *   **Formatting:** `ruff format .`
+    *   **Type Checking:** `mypy src/trianglengin/ tests/`
+
+8.  **Troubleshooting Build/Import Errors:**
+    *   Ensure compiler and CMake are installed and in PATH.
+    *   Make sure the virtual environment is active *before* running `pip install -e`.
+    *   Clean previous builds (Step 5).
+    *   Check `pyproject.toml` and `setup.py` for correct configuration.
+    *   Verify Pybind11 version compatibility.
+
+---
+
+## Project Structure (v2 - UI Included)
+
+```
+trianglengin/
+├── .github/workflows/      # GitHub Actions CI/CD
+│   └── ci_cd.yml
+├── src/                    # Source root
+│   └── trianglengin/       # Python package source
+│       ├── __init__.py     # Exposes core public API (GameState, EnvConfig, Shape)
+│       ├── game_interface.py # Python GameState wrapper class
+│       ├── py.typed        # PEP 561 marker
+│       ├── cpp/            # C++ Core Implementation ([src/trianglengin/cpp/README.md])
+│       │   ├── CMakeLists.txt
+│       │   ├── bindings.cpp
+│       │   ├── config.h
+│       │   ├── structs.h
+│       │   ├── grid_data.h / .cpp
+│       │   ├── grid_logic.h / .cpp
+│       │   ├── shape_logic.h / .cpp
+│       │   └── game_state.h / .cpp
+│       ├── core/           # Core Python components (now minimal/empty)
+│       │   └── __init__.py
+│       ├── utils/          # General Python utilities ([src/trianglengin/utils/README.md])
+│       │   └── ... (geometry.py, types.py)
+│       ├── config/         # Core configuration models ([src/trianglengin/config/README.md])
+│       │   ├── __init__.py
+│       │   └── env_config.py   # EnvConfig (Pydantic)
+│       └── ui/             # UI Components ([src/trianglengin/ui/README.md])
+│           ├── __init__.py # Exposes UI API (Application, cli_app, DisplayConfig)
+│           ├── app.py      # Interactive mode application runner
+│           ├── cli.py      # CLI definition (play/debug)
+│           ├── config.py   # DisplayConfig (Pydantic)
+│           ├── interaction/    # User input handling ([src/trianglengin/ui/interaction/README.md])
+│           │   ├── __init__.py
+│           │   ├── event_processor.py
+│           │   ├── input_handler.py
+│           │   ├── play_mode_handler.py
+│           │   └── debug_mode_handler.py
+│           └── visualization/  # Pygame rendering ([src/trianglengin/ui/visualization/README.md])
+│               ├── __init__.py
+│               ├── core/       # Core vis components ([src/trianglengin/ui/visualization/core/README.md])
+│               │   ├── __init__.py
+│               │   ├── colors.py
+│               │   ├── coord_mapper.py
+│               │   ├── fonts.py
+│               │   ├── layout.py # NEW
+│               │   └── visualizer.py
+│               └── drawing/    # Drawing functions ([src/trianglengin/ui/visualization/drawing/README.md])
+│                   ├── __init__.py
+│                   ├── grid.py
+│                   ├── highlight.py
+│                   ├── hud.py
+│                   ├── previews.py
+│                   ├── shapes.py
+│                   └── utils.py
+├── tests/                  # Unit/Integration tests (Python) ([tests/README.md])
+│   ├── __init__.py
+│   ├── conftest.py
+│   └── core/environment/
+│       └── test_game_state.py # Tests the Python GameState wrapper
+├── .gitignore
+├── pyproject.toml          # Build config, dependencies
+├── setup.py                # C++ Extension build script
+├── README.md               # This file
+├── LICENSE
+└── MANIFEST.in
+```
+
+## Core Components (v2)
+
+- **`trianglengin.cpp` (C++ Core)**: Implements the high-performance game logic (state, grid, shapes, rules). Not directly imported in Python.
+- **`trianglengin.game_interface.GameState` (Python Wrapper)**: The primary Python class for interacting with the game engine. It holds a reference to the C++ game state object and provides methods like `step`, `reset`, `is_over`, `valid_actions`, `get_shapes`, `get_grid_data_np`.
+- **`trianglengin.config.EnvConfig`**: Python Pydantic model for core environment configuration. Passed to C++ core during initialization.
+- **`trianglengin.utils`**: General Python utility functions and types. ([`src/trianglengin/utils/README.md`](src/trianglengin/utils/README.md))
+
+## UI Components (`trianglengin.ui`)
+
+- **`trianglengin.ui.config.DisplayConfig`**: Pydantic model for UI display settings.
+- **`trianglengin.ui.visualization`**: Python/Pygame rendering components. Uses data obtained from the `GameState` wrapper. ([`src/trianglengin/ui/visualization/README.md`](src/trianglengin/ui/visualization/README.md))
+- **`trianglengin.ui.interaction`**: Python/Pygame input handling for interactive modes. Interacts with the `GameState` wrapper. ([`src/trianglengin/ui/interaction/README.md`](src/trianglengin/ui/interaction/README.md))
+- **`trianglengin.ui.app.Application`**: Integrates UI components for interactive modes.
+- **`trianglengin.ui.cli`**: Command-line interface (`trianglengin play`/`debug`).
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request on the [GitHub repository](https://github.com/lguibr/trianglengin). Ensure that changes maintain code quality (pass tests, linting, type checking) and keep READMEs updated. Building requires a C++17 compiler and CMake.

trianglengin-2.0.1.dist-info/RECORD

@@ -0,0 +1,61 @@
+trianglengin.libs/libstdc++-496613c0.so.6.0.32,sha256=AwZhL5WFT99I2Q6vIxXOhW7qddfuOZ1xecxiP9QTVY4,3494361
+trianglengin.libs/libgcc_s-a3a07607.so.1,sha256=5ptIUeAzZweNZrFehN0_Bb5B0FcJgux7NbAFoU8vwwo,148041
+trianglengin/game_interface.py,sha256=0aCePxmhLJOdlPGHU_JOuu-lsBZVfOs0vK5eke-bxv0,8730
+trianglengin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+trianglengin/trianglengin_cpp.cpython-312-x86_64-linux-musl.so,sha256=UWH4yF8fOnL9Iu6550q8d_OmrGXUbsxtVSDud3p1JRE,297897
+trianglengin/__init__.py,sha256=4INnGvOYIjzOyCew7lhX6Irc8_H7QVxWc5jopt9TCZ4,919
+trianglengin/trianglengin_cpp.cpython-37m-x86_64-linux-gnu.so,sha256=UWH4yF8fOnL9Iu6550q8d_OmrGXUbsxtVSDud3p1JRE,297897
+trianglengin/config/README.md,sha256=PKm6HMVMZkA1KB22s2lP-jh5jwB7XIDiFgoShz_xj0s,1506
+trianglengin/config/env_config.py,sha256=IMjbOrAZxgVzLjod9tmFhv964E30paG4zI1eUS8Nvy8,2359
+trianglengin/config/display_config.py,sha256=FHY9iKuuk7L5h-xWtDTthHUlvyme4AJeA5kOk-zZJFg,1815
+trianglengin/config/__init__.py,sha256=wKb-lRhguEAJCxcPHG1qyW-AmUherzMbUfi3SZ6IEao,160
+trianglengin/cpp/game_state.cpp,sha256=ec_tLqySZTcEx7I01tLchLi5T90ep8l_oyRSZbUsu-U,10260
+trianglengin/cpp/structs.h,sha256=v_aL5O5gwXH_qRPGUIkNplr167rgf7gCVlWIJKOLV1U,993
+trianglengin/cpp/grid_data.cpp,sha256=KH9BbLuhi-_fmKgnT2oPuzHRDo87xFDHiBfpXCwgYsw,6904
+trianglengin/cpp/grid_logic.h,sha256=O6roOE_U7nbKgAkaMkC8LrEjGDvnL3QiVzOnXunXy9s,781
+trianglengin/cpp/grid_logic.cpp,sha256=8ag6wwdmZuHg8_I-skTI9LOdB84a82IrZAoREq0dkQo,3333
+trianglengin/cpp/bindings.cpp,sha256=B3hfxIF_pBAyVG1QpbBvJT1awy8uJWRJSBNxaNY5_pY,8689
+trianglengin/cpp/shape_logic.h,sha256=QvjLAPG5y42FetpXXuCcYrWlcwvKGo7csU8Ch-RmdFs,626
+trianglengin/cpp/config.h,sha256=9Xd-9wTYmFwEuf-ZjrQa5zlXF58MrLhRKU1ygyG2Nmc,715
+trianglengin/cpp/grid_data.h,sha256=KGOtUQQb7HJnU_LyWIWW5g6S2gJ2u3ewY32qXtoPfcs,2453
+trianglengin/cpp/game_state.h,sha256=MBoAiG617XPtZNGqGPE2PC1pX1dBHuWBGHLJr3iBg6c,2547
+trianglengin/cpp/shape_logic.cpp,sha256=gF1mgolaNvxpNphwDScNUvOkoq4FuxFASB3n50WI3Bo,4133
+trianglengin/cpp/CMakeLists.txt,sha256=FCUnDHVQhe7PFj9FTQcQiWFgr61b8iJg0m0UH3hGYE4,1328
+trianglengin/utils/geometry.py,sha256=0SY1woDY5u_e2_TrNpG5y6w7a8n417Ndtiq0Z4QuuW8,2066
+trianglengin/utils/__init__.py,sha256=907xXfoKmxOc86noqwOtnomajkrkbInWvAhR-h5coow,176
+trianglengin/utils/types.py,sha256=u5VALmDiCCWpYdtxS4rMgW5uxNtIEfpjH3tRg12yjYM,231
+trianglengin/ui/README.md,sha256=M-5UU-NKG6qYu1riCUkftRZIwE2Jvf-5qOZ1QGWjPSg,1718
+trianglengin/ui/app.py,sha256=9A7iBrGVJLG-OKDuYTPiayVn8bwO2Yx1-s1h4qJKX9c,4042
+trianglengin/ui/config.py,sha256=E68Qvbr3dwyhC_Rh_PK-QHWlHOrXFQhAsARZZMoQHNs,1579
+trianglengin/ui/__init__.py,sha256=AVIFYOWoZTt69NnkX0Ht3dEAPMpxQ6WZ8G9tDvxNXvA,558
+trianglengin/ui/cli.py,sha256=8LXgyW45_qFuh6rCwwSqMkH8fxmnZ2uTEbEOEpsgdr0,3326
+trianglengin/ui/interaction/debug_mode_handler.py,sha256=FbG8UZDVZsbnrSw3j7T7oIfUCLtAlNxfVl1qKjeApSY,2527
+trianglengin/ui/interaction/play_mode_handler.py,sha256=olBy9tR09NrBWnivEyPdATar2zuboom5kXxPzu2kiBY,5544
+trianglengin/ui/interaction/README.md,sha256=SN90_u45CBqbJjympMFvhq09Jem2eGH-RvELf5vp3WI,3515
+trianglengin/ui/interaction/event_processor.py,sha256=j573lStOcX2x86urx4HIRoAfBXl7CbtK4HkzQByGbJ0,1650
+trianglengin/ui/interaction/__init__.py,sha256=NZiN6T2Dzb1ZJOBVu19YTkLW4_gVI12irlLEliF3-1w,573
+trianglengin/ui/interaction/input_handler.py,sha256=-IOfmds5lkguOgXkhBqMWC7TwQ0-F069AtQil1Fz3gw,3249
+trianglengin/ui/visualization/README.md,sha256=4oFu_I2I8WUFDotsCRhEHZvjq4Fc2sVlB_tOvFy99CU,2111
+trianglengin/ui/visualization/__init__.py,sha256=dCN6_TOLiw2uuNts_VuzAa-WhqxqR7yxF2NoU8pP1IU,1718
+trianglengin/ui/visualization/drawing/README.md,sha256=RfIhgwRSwF-uybo5uT0Md8Lm6pgM7aafFK6oDEB3qhY,2886
+trianglengin/ui/visualization/drawing/highlight.py,sha256=x-lyIbvT-lfwyqbRgdk0eTiWLTSRoSnvoR1dQ_6Z9ME,857
+trianglengin/ui/visualization/drawing/shapes.py,sha256=4L9iFo4XHAdsAEqdyLFfyoSBgMtGWNTiD11HgzkyuQc,1709
+trianglengin/ui/visualization/drawing/hud.py,sha256=3dhhJI9pm8nkgjTOG7ONd6X1jylpyw9s3zg2Tfhab3w,1227
+trianglengin/ui/visualization/drawing/grid.py,sha256=21q5wB_SYSZilTDntdj5o4q6ZrxqpL-_VGO0cfR7ZL4,7160
+trianglengin/ui/visualization/drawing/utils.py,sha256=3--x8Qsd9bLVGtveJbZDIQgZNK5naGMO7nMf7XWchMI,921
+trianglengin/ui/visualization/drawing/__init__.py,sha256=KVdPQUjB-yZI1PzK2AoHKUOVaFhbjSJnvFJtcIPS4DA,1120
+trianglengin/ui/visualization/drawing/previews.py,sha256=Kf4DDGLxxeK_Wgmcd2jg0b9_IMxrI35wKEVgkQn6W_k,7003
+trianglengin/ui/visualization/core/colors.py,sha256=L5vg1dFRSO3kEyfaMEJxX1YwkmH44qBsMiHdRtMs5ZM,3038
+trianglengin/ui/visualization/core/layout.py,sha256=uHUd0bIWnPA8gYPaenLfJKj0ry_4K_scrl-KWZmy4a4,2602
+trianglengin/ui/visualization/core/README.md,sha256=fiyYIOBmS9-6-CktXCVrOD-KBp-Eo6xSZik_BWp2f2w,3203
+trianglengin/ui/visualization/core/coord_mapper.py,sha256=FGD01ghlyfUbEvcvSKMi9FS_FmG8zCflROR775r3IxI,3260
+trianglengin/ui/visualization/core/__init__.py,sha256=26XCOn_jywwQ0YszGP6rEgFJIqdP3meQNBPRu1SYLOc,557
+trianglengin/ui/visualization/core/fonts.py,sha256=d9kQqdilPK0pTvXhv2oVJAbVT4pmWfjKxXfEir7Avdg,2016
+trianglengin/ui/visualization/core/visualizer.py,sha256=gWY4_vZGEzTokl6Z7xMeGvdrpJMl4YdZnfoT4bgBYW4,8860
+trianglengin/core/__init__.py,sha256=zMo_rn4wzVGzrevzZM4u4rkLwicZQeDqmXbnk9fI008,460
+trianglengin-2.0.1.dist-info/WHEEL,sha256=UyLNHXRBDnd27Yk45xc47r0-UQKuY5fM2-iebdLKea8,112
+trianglengin-2.0.1.dist-info/RECORD,,
+trianglengin-2.0.1.dist-info/top_level.txt,sha256=YsSWmp_2zM23wRc5TRERHpVCgQuVYieYHDTpnwVQC7Y,13
+trianglengin-2.0.1.dist-info/entry_points.txt,sha256=kQEqO_U-MEpMEC0xwOPSucBzQIq2Ny7XwCtFSruZhvY,57
+trianglengin-2.0.1.dist-info/METADATA,sha256=g8tEo09YNK3qFb45tFv8A_176S_oUHS-jHRl5UIq3Ws,12036
+trianglengin-2.0.1.dist-info/licenses/LICENSE,sha256=So3rgoJp-HgoxkclxZLIBC3pmmTwshN4tUO8KiQ6akc,1077

trianglengin-2.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-musllinux_1_2_x86_64
+

trianglengin-2.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+trianglengin = trianglengin.ui.cli:app