trianglengin 1.0.6__py3-none-any.whl

trianglengin/core/environment/shapes/templates.py

@@ -0,0 +1,587 @@
+# File: trianglengin/core/environment/shapes/templates.py
+# ==============================================================================
+# ==                    PREDEFINED SHAPE TEMPLATES                          ==
+# ==                                                                        ==
+# ==    DO NOT MODIFY THIS LIST MANUALLY unless you are absolutely sure!    ==
+# == These shapes are fundamental to the game's design and balance.         ==
+# == Modifying them can have unintended consequences on gameplay and agent  ==
+# == training.                                                              ==
+# ==============================================================================
+
+# List of predefined shape templates. Each template is a list of relative triangle coordinates (dr, dc, is_up).
+# Coordinates are relative to the shape's origin (typically the top-leftmost triangle).
+# is_up = True for upward-pointing triangle, False for downward-pointing.
+PREDEFINED_SHAPE_TEMPLATES: list[list[tuple[int, int, bool]]] = [
+    [  # Shape 1
+        (
+            0,
+            0,
+            True,
+        )
+    ],
+    [  # Shape 1
+        (
+            0,
+            0,
+            True,
+        )
+    ],
+    [  # Shape 2
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+    ],
+    [  # Shape 2
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+    ],
+    [  # Shape 3
+        (
+            0,
+            0,
+            False,
+        )
+    ],
+    [  # Shape 4
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+    ],
+    [  # Shape 4
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+    ],
+    [  # Shape 5
+        (
+            0,
+            0,
+            False,
+        ),
+        (
+            0,
+            1,
+            True,
+        ),
+    ],
+    [  # Shape 5
+        (
+            0,
+            0,
+            False,
+        ),
+        (
+            0,
+            1,
+            True,
+        ),
+    ],
+    [  # Shape 6
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            0,
+            2,
+            True,
+        ),
+    ],
+    [  # Shape 7
+        (
+            0,
+            0,
+            False,
+        ),
+        (
+            0,
+            1,
+            True,
+        ),
+        (
+            0,
+            2,
+            False,
+        ),
+    ],
+    [  # Shape 8
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            0,
+            2,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+    ],
+    [  # Shape 9
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            0,
+            2,
+            True,
+        ),
+        (
+            1,
+            2,
+            False,
+        ),
+    ],
+    [  # Shape 10
+        (
+            0,
+            0,
+            False,
+        ),
+        (
+            0,
+            1,
+            True,
+        ),
+        (
+            1,
+            0,
+            True,
+        ),
+        (
+            1,
+            1,
+            False,
+        ),
+    ],
+    [  # Shape 11
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            2,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+        (
+            1,
+            1,
+            True,
+        ),
+        (
+            1,
+            2,
+            False,
+        ),
+    ],
+    [  # Shape 12
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            1,
+            -2,
+            False,
+        ),
+        (
+            1,
+            -1,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+    ],
+    [  # Shape 13
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+        (
+            1,
+            1,
+            True,
+        ),
+    ],
+    [  # Shape 14
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+        (
+            1,
+            1,
+            True,
+        ),
+        (
+            1,
+            2,
+            False,
+        ),
+    ],
+    [  # Shape 15
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            0,
+            2,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+        (
+            1,
+            1,
+            True,
+        ),
+    ],
+    [  # Shape 16
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            0,
+            2,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+        (
+            1,
+            2,
+            False,
+        ),
+    ],
+    [  # Shape 17
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            0,
+            2,
+            True,
+        ),
+        (
+            1,
+            1,
+            True,
+        ),
+        (
+            1,
+            2,
+            False,
+        ),
+    ],
+    [  # Shape 18
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            2,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+        (
+            1,
+            1,
+            True,
+        ),
+        (
+            1,
+            2,
+            False,
+        ),
+    ],
+    [  # Shape 19
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+        (
+            1,
+            1,
+            True,
+        ),
+        (
+            1,
+            2,
+            False,
+        ),
+    ],
+    [  # Shape 20
+        (
+            0,
+            0,
+            False,
+        ),
+        (
+            0,
+            1,
+            True,
+        ),
+        (
+            1,
+            1,
+            False,
+        ),
+    ],
+    [  # Shape 21
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            1,
+            -1,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+    ],
+    [  # Shape 22
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+        (
+            1,
+            1,
+            True,
+        ),
+    ],
+    [  # Shape 23
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            1,
+            -1,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+        (
+            1,
+            1,
+            True,
+        ),
+    ],
+    [  # Shape 24
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            1,
+            -1,
+            True,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+    ],
+    [  # Shape 25
+        (
+            0,
+            0,
+            False,
+        ),
+        (
+            0,
+            1,
+            True,
+        ),
+        (
+            0,
+            2,
+            False,
+        ),
+        (
+            1,
+            1,
+            False,
+        ),
+    ],
+    [  # Shape 26
+        (
+            0,
+            0,
+            False,
+        ),
+        (
+            0,
+            1,
+            True,
+        ),
+        (
+            1,
+            1,
+            False,
+        ),
+    ],
+    [  # Shape 27
+        (
+            0,
+            0,
+            True,
+        ),
+        (
+            0,
+            1,
+            False,
+        ),
+        (
+            1,
+            0,
+            False,
+        ),
+    ],
+]

trianglengin/core/structs/__init__.py

@@ -0,0 +1,27 @@
+# File: trianglengin/core/structs/__init__.py
+"""
+Module for core data structures used across different parts of the application,
+like environment, visualization, and features. Helps avoid circular dependencies.
+"""
+
+# Correctly export constants from the constants submodule
+from .constants import (
+    COLOR_ID_MAP,
+    COLOR_TO_ID_MAP,
+    DEBUG_COLOR_ID,
+    NO_COLOR_ID,
+    SHAPE_COLORS,
+)
+from .shape import Shape
+from .triangle import Triangle
+
+__all__ = [
+    "Triangle",
+    "Shape",
+    # Exported Constants
+    "SHAPE_COLORS",
+    "NO_COLOR_ID",
+    "DEBUG_COLOR_ID",
+    "COLOR_ID_MAP",
+    "COLOR_TO_ID_MAP",
+]

trianglengin/core/structs/constants.py

@@ -0,0 +1,28 @@
+SHAPE_COLORS: list[tuple[int, int, int]] = [
+    (220, 40, 40),  # 0: Red
+    (60, 60, 220),  # 1: Blue
+    (40, 200, 40),  # 2: Green
+    (230, 230, 40),  # 3: Yellow
+    (240, 150, 20),  # 4: Orange
+    (140, 40, 140),  # 5: Purple
+    (40, 200, 200),  # 6: Cyan
+    (200, 100, 180),  # 7: Pink (Example addition)
+    (100, 180, 200),  # 8: Light Blue (Example addition)
+]
+
+# --- NumPy GridData Color Representation ---
+# ID for empty cells in the _color_id_np array
+NO_COLOR_ID: int = -1
+# ID for debug-toggled cells
+DEBUG_COLOR_ID: int = -2
+
+# Mapping from Color ID (int >= 0) to RGB tuple.
+# Index 0 corresponds to SHAPE_COLORS[0], etc.
+# This list is used by visualization to get the RGB from the ID.
+COLOR_ID_MAP: list[tuple[int, int, int]] = SHAPE_COLORS
+
+# Reverse mapping for efficient lookup during placement (Color Tuple -> ID)
+# Note: Ensure SHAPE_COLORS have unique tuples.
+COLOR_TO_ID_MAP: dict[tuple[int, int, int], int] = {
+    color: i for i, color in enumerate(COLOR_ID_MAP)
+}

trianglengin/core/structs/shape.py

@@ -0,0 +1,61 @@
+# File: trianglengin/core/structs/shape.py
+from __future__ import annotations
+
+import logging
+from typing import cast
+
+logger = logging.getLogger(__name__)
+
+
+class Shape:
+    """Represents a polyomino-like shape made of triangles."""
+
+    def __init__(
+        self, triangles: list[tuple[int, int, bool]], color: tuple[int, int, int]
+    ):
+        # Ensure triangles are tuples and sort them for consistent representation
+        # Sorting is based on (row, col) primarily
+        try:
+            # Explicitly cast inner tuples to the correct type for mypy
+            processed_triangles = [
+                cast("tuple[int, int, bool]", tuple(t)) for t in triangles
+            ]
+            self.triangles: list[tuple[int, int, bool]] = sorted(processed_triangles)
+        except Exception as e:
+            logger.error(f"Failed to sort triangles: {triangles}. Error: {e}")
+            # Fallback or re-raise depending on desired behavior
+            self.triangles = [
+                cast("tuple[int, int, bool]", tuple(t)) for t in triangles
+            ]  # Store as is if sort fails
+
+        self.color: tuple[int, int, int] = color
+
+    def bbox(self) -> tuple[int, int, int, int]:
+        """Calculates bounding box (min_r, min_c, max_r, max_c) in relative coords."""
+        if not self.triangles:
+            return (0, 0, 0, 0)
+        rows = [t[0] for t in self.triangles]
+        cols = [t[1] for t in self.triangles]
+        return (min(rows), min(cols), max(rows), max(cols))
+
+    def copy(self) -> Shape:
+        """Creates a shallow copy (triangle list is copied, color is shared)."""
+        new_shape = Shape.__new__(Shape)
+        new_shape.triangles = list(self.triangles)
+        new_shape.color = self.color
+        return new_shape
+
+    def __str__(self) -> str:
+        return f"Shape(Color:{self.color}, Tris:{len(self.triangles)})"
+
+    def __eq__(self, other: object) -> bool:
+        """Checks for equality based on triangles and color."""
+        if not isinstance(other, Shape):
+            return NotImplemented
+        # Compare sorted lists of tuples
+        return self.triangles == other.triangles and self.color == other.color
+
+    def __hash__(self) -> int:
+        """Allows shapes to be used in sets/dicts if needed."""
+        # Hash the tuple representation of the sorted list
+        return hash((tuple(self.triangles), self.color))