trianglengin 1.0.6__py3-none-any.whl

tests/core/environment/test_grid_logic.py

@@ -0,0 +1,362 @@
+# File: tests/core/environment/test_grid_logic.py
+import logging
+
+import pytest
+
+from trianglengin.config import EnvConfig
+from trianglengin.core.environment.grid import GridData
+from trianglengin.core.environment.grid import logic as GridLogic
+from trianglengin.core.structs import Shape
+
+# Default color for fixture shapes
+DEFAULT_TEST_COLOR = (100, 100, 100)
+log = logging.getLogger(__name__)
+
+
+@pytest.fixture
+def default_config() -> EnvConfig:
+    """Fixture for default environment configuration."""
+    return EnvConfig()
+
+
+@pytest.fixture
+def default_grid(default_config: EnvConfig) -> GridData:
+    """Fixture for a default GridData instance."""
+    # Ensure the cache is populated for the default config before tests run
+    # This will now use the fixed _compute_lines_and_map_v4
+    GridData(default_config)
+    # Return a fresh instance for the test, which will reuse the cache
+    return GridData(default_config)
+
+
+def occupy_coords(grid_data: GridData, coords: set[tuple[int, int]]):
+    """Helper to occupy specific coordinates."""
+    for r, c in coords:
+        if grid_data.valid(r, c) and not grid_data.is_death(r, c):
+            grid_data._occupied_np[r, c] = True
+            # Assign a dummy color ID
+            grid_data._color_id_np[r, c] = 0
+
+
+# --- Basic Placement Tests ---
+# (Keep existing basic placement tests - they should still pass)
+
+
+def test_can_place_basic(default_grid: GridData):
+    """Test basic placement in empty grid."""
+    shape = Shape([(0, 0, False), (0, 1, True)], DEFAULT_TEST_COLOR)  # D, U
+    start_r, start_c = -1, -1
+    for r in range(default_grid.rows):
+        for c in range(default_grid.cols):
+            if not default_grid.is_death(r, c) and (r + c) % 2 == 0:  # Find Down cell
+                start_r, start_c = r, c
+                break
+        if start_r != -1:
+            break
+    if start_r == -1:
+        pytest.skip("Could not find a valid starting Down cell.")
+    assert GridLogic.can_place(default_grid, shape, start_r, start_c)
+
+
+def test_can_place_occupied(default_grid: GridData):
+    """Test placement fails if target is occupied."""
+    shape = Shape([(0, 0, False)], DEFAULT_TEST_COLOR)  # Single Down
+    start_r, start_c = -1, -1
+    for r in range(default_grid.rows):
+        for c in range(default_grid.cols):
+            if not default_grid.is_death(r, c) and (r + c) % 2 == 0:  # Find Down cell
+                start_r, start_c = r, c
+                break
+        if start_r != -1:
+            break
+    if start_r == -1:
+        pytest.skip("Could not find a valid starting Down cell.")
+    default_grid._occupied_np[start_r, start_c] = True
+    assert not GridLogic.can_place(default_grid, shape, start_r, start_c)
+
+
+def test_can_place_death_zone(default_grid: GridData):
+    """Test placement fails if target is in death zone."""
+    Shape([(0, 0, False)], DEFAULT_TEST_COLOR)  # Single Down
+    death_r, death_c = -1, -1
+    for r in range(default_grid.rows):
+        for c in range(default_grid.cols):
+            if default_grid.is_death(r, c):
+                death_r, death_c = r, c
+                break
+        if death_r != -1:
+            break
+    if death_r == -1:
+        pytest.skip("Could not find a death zone cell.")
+    shape_to_use = Shape([(0, 0, (death_r + death_c) % 2 != 0)], DEFAULT_TEST_COLOR)
+    assert not GridLogic.can_place(default_grid, shape_to_use, death_r, death_c)
+
+
+def test_can_place_orientation_mismatch(default_grid: GridData):
+    """Test placement fails if shape orientation doesn't match grid."""
+    shape = Shape([(0, 0, True)], DEFAULT_TEST_COLOR)  # Needs Up
+    start_r, start_c = -1, -1
+    for r in range(default_grid.rows):
+        for c in range(default_grid.cols):
+            if not default_grid.is_death(r, c) and (r + c) % 2 == 0:  # Find Down cell
+                start_r, start_c = r, c
+                break
+        if start_r != -1:
+            break
+    if start_r == -1:
+        pytest.skip("Could not find a valid starting Down cell.")
+    assert not GridLogic.can_place(default_grid, shape, start_r, start_c)
+
+    shape_down = Shape([(0, 0, False)], DEFAULT_TEST_COLOR)  # Needs Down
+    up_r, up_c = -1, -1
+    for r in range(default_grid.rows):
+        for c in range(default_grid.cols):
+            if not default_grid.is_death(r, c) and (r + c) % 2 != 0:  # Find Up cell
+                up_r, up_c = r, c
+                break
+        if up_r != -1:
+            break
+    if up_r == -1:
+        pytest.skip("Could not find a valid starting Up cell.")
+    assert not GridLogic.can_place(default_grid, shape_down, up_r, up_c)
+
+
+def test_can_place_out_of_bounds(default_grid: GridData):
+    """Test placement fails if shape goes out of bounds."""
+    shape = Shape([(0, 0, False), (0, 1, True)], DEFAULT_TEST_COLOR)
+    assert not GridLogic.can_place(default_grid, shape, 0, default_grid.cols - 1)
+    shape_tall = Shape([(0, 0, False), (1, 0, False)], DEFAULT_TEST_COLOR)
+    assert not GridLogic.can_place(default_grid, shape_tall, default_grid.rows - 1, 0)
+
+
+# --- Line Clearing Tests ---
+
+
+def test_check_and_clear_lines_simple(default_grid: GridData):
+    """Test clearing a single horizontal line."""
+    target_line = None
+    for line in default_grid._lines:
+        # Find a reasonably long horizontal line for a good test
+        if len(line) > 4 and all(c[0] == line[0][0] for c in line):
+            target_line = line
+            break
+    if not target_line:
+        pytest.skip("Could not find a suitable horizontal line.")
+    target_line_set = set(target_line)
+    occupy_coords(default_grid, target_line_set)
+    last_coord = target_line[-1]
+    lines_cleared, coords_cleared, cleared_line_sets = GridLogic.check_and_clear_lines(
+        default_grid, {last_coord}
+    )
+    assert lines_cleared == 1, f"Expected 1 line clear, got {lines_cleared}"
+    assert coords_cleared == target_line_set, "Cleared coordinates mismatch"
+    assert cleared_line_sets == {frozenset(target_line)}, "Cleared line set mismatch"
+    for r, c in target_line_set:
+        assert not default_grid._occupied_np[r, c], f"Cell ({r},{c}) was not cleared"
+        assert default_grid._color_id_np[r, c] == -1, (
+            f"Color ID for ({r},{c}) not reset"
+        )
+
+
+def test_check_and_clear_lines_no_clear(default_grid: GridData):
+    """Test that no lines are cleared if none are complete."""
+    target_line = None
+    for line in default_grid._lines:
+        # Find a reasonably long line
+        if len(line) > 4:
+            target_line = line
+            break
+    if not target_line:
+        pytest.skip("Could not find a suitable line.")
+    # Occupy all but the last coordinate
+    coords_to_occupy = set(target_line[:-1])
+    occupy_coords(default_grid, coords_to_occupy)
+    # Check clear using the last occupied coordinate
+    last_occupied_coord = target_line[-2]  # The one before the empty one
+    lines_cleared, coords_cleared, cleared_line_sets = GridLogic.check_and_clear_lines(
+        default_grid, {last_occupied_coord}
+    )
+    assert lines_cleared == 0, f"Expected 0 lines cleared, got {lines_cleared}"
+    assert not coords_cleared, "Coords should not be cleared"
+    assert not cleared_line_sets, "Cleared line sets should be empty"
+    # Verify grid cells remain occupied
+    for r, c in coords_to_occupy:
+        assert default_grid._occupied_np[r, c], (
+            f"Cell ({r},{c}) should still be occupied"
+        )
+
+
+# --- Specific Boundary Line Clearing Scenarios ---
+
+# Define the boundary lines explicitly based on default EnvConfig
+# IMPORTANT: Use the natural traversal order expected from line_cache v4
+BOUNDARY_LINES = {
+    "top_left_diag": (
+        (4, 0),
+        (3, 0),
+        (3, 1),
+        (2, 1),
+        (2, 2),
+        (1, 2),
+        (1, 3),
+        (0, 3),
+        (0, 4),
+    ),
+    "top_horiz": tuple((0, c) for c in range(3, 12)),
+    "top_right_diag": (
+        (0, 10),
+        (0, 11),
+        (1, 11),
+        (1, 12),
+        (2, 12),
+        (2, 13),
+        (3, 13),
+        (3, 14),
+        (4, 14),
+    ),
+    "bottom_right_diag": (
+        (3, 14),
+        (4, 14),
+        (4, 13),
+        (5, 13),
+        (5, 12),
+        (6, 12),
+        (6, 11),
+        (7, 11),
+        (7, 10),
+    ),
+    "bottom_horiz": tuple((7, c) for c in range(3, 12)),
+    "bottom_left_diag": (
+        (3, 0),
+        (4, 0),
+        (4, 1),
+        (5, 1),
+        (5, 2),
+        (6, 2),
+        (6, 3),
+        (7, 3),
+        (7, 4),
+    ),
+}
+
+
+@pytest.mark.parametrize("line_name, line_coords", BOUNDARY_LINES.items())
+def test_boundary_line_clears_only_when_full(
+    line_name: str, line_coords: tuple[tuple[int, int], ...], default_grid: GridData
+):
+    """
+    Tests that boundary lines clear only when the final middle piece(s) are placed,
+    simulating placing pieces from the outside inwards.
+    """
+    grid_data = default_grid
+    grid_data.reset()  # Start with a clean grid for each line test
+    n = len(line_coords)
+    line_set = set(line_coords)
+    line_fs = frozenset(line_coords)
+    log.info(f"Testing line '{line_name}' (len={n}): {line_coords}")
+
+    # Verify line exists in cache first (essential prerequisite)
+    first_coord = line_coords[0]
+    assert first_coord in grid_data._coord_to_lines_map, (
+        f"Coord {first_coord} not in map for line '{line_name}'"
+    )
+    found_mapping = False
+    if first_coord in grid_data._coord_to_lines_map:
+        for mapped_fs in grid_data._coord_to_lines_map[first_coord]:
+            if mapped_fs == line_fs:
+                found_mapping = True
+                break
+    assert found_mapping, (
+        f"Line {line_fs} not mapped to {first_coord} for line '{line_name}'"
+    )
+
+    # --- Simulate Inward Placement ---
+    placed_coords = set()
+    final_clear_occurred = False
+    for i in range(n // 2 + (n % 2)):  # Iterate inwards (e.g., 0, 1, 2, 3, 4 for n=9)
+        coord1 = line_coords[i]
+        coord2 = line_coords[n - 1 - i]
+        is_last_pair_or_middle = i == (n // 2 + (n % 2) - 1)
+        log.debug(
+            f"  Step {i}: Considering pair {coord1} / {coord2}. Is last: {is_last_pair_or_middle}"
+        )
+
+        # --- Place first cell of the pair ---
+        if coord1 not in placed_coords:
+            log.debug(f"    Placing {coord1}...")
+            grid_data._occupied_np[coord1[0], coord1[1]] = True
+            grid_data._color_id_np[coord1[0], coord1[1]] = 0
+            placed_coords.add(coord1)
+            lines_cleared_1, coords_cleared_1, cleared_sets_1 = (
+                GridLogic.check_and_clear_lines(grid_data, {coord1})
+            )
+
+            should_clear_now = len(placed_coords) == n
+            if should_clear_now:
+                log.debug(f"    Checking FINAL clear after placing {coord1}")
+                assert lines_cleared_1 == 1, (
+                    f"Line '{line_name}' should clear after placing final piece {coord1}, but did not."
+                )
+                assert coords_cleared_1 == line_set, (
+                    f"Cleared coords mismatch for '{line_name}' after final piece {coord1}."
+                )
+                assert cleared_sets_1 == {line_fs}, (
+                    f"Cleared line set mismatch for '{line_name}' after final piece {coord1}."
+                )
+                final_clear_occurred = True
+            else:
+                log.debug(f"    Checking NO clear after placing {coord1}")
+                assert lines_cleared_1 == 0, (
+                    f"Line '{line_name}' cleared prematurely after placing {coord1} (step {i}, total placed: {len(placed_coords)}/{n})"
+                )
+                assert not coords_cleared_1, (
+                    f"Coords cleared prematurely for '{line_name}' after {coord1}"
+                )
+                assert grid_data._occupied_np[coord1[0], coord1[1]], (
+                    f"{coord1} should still be occupied after non-clearing step"
+                )
+
+        # --- Place second cell of the pair (if different from first) ---
+        if coord1 != coord2 and coord2 not in placed_coords:
+            log.debug(f"    Placing {coord2}...")
+            grid_data._occupied_np[coord2[0], coord2[1]] = True
+            grid_data._color_id_np[coord2[0], coord2[1]] = 0
+            placed_coords.add(coord2)
+            lines_cleared_2, coords_cleared_2, cleared_sets_2 = (
+                GridLogic.check_and_clear_lines(grid_data, {coord2})
+            )
+
+            should_clear_now = len(placed_coords) == n
+            if should_clear_now:
+                log.debug(f"    Checking FINAL clear after placing {coord2}")
+                assert lines_cleared_2 == 1, (
+                    f"Line '{line_name}' should clear after placing final piece {coord2}, but did not."
+                )
+                assert coords_cleared_2 == line_set, (
+                    f"Cleared coords mismatch for '{line_name}' after final piece {coord2}."
+                )
+                assert cleared_sets_2 == {line_fs}, (
+                    f"Cleared line set mismatch for '{line_name}' after final piece {coord2}."
+                )
+                final_clear_occurred = True
+            else:
+                log.debug(f"    Checking NO clear after placing {coord2}")
+                assert lines_cleared_2 == 0, (
+                    f"Line '{line_name}' cleared prematurely after placing {coord2} (step {i}, total placed: {len(placed_coords)}/{n})"
+                )
+                assert not coords_cleared_2, (
+                    f"Coords cleared prematurely for '{line_name}' after {coord2}"
+                )
+                assert grid_data._occupied_np[coord2[0], coord2[1]], (
+                    f"{coord2} should still be occupied after non-clearing step"
+                )
+
+    # --- Final Verification ---
+    assert final_clear_occurred, (
+        f"The final clear event did not happen for line '{line_name}' after placing all {n} pieces."
+    )
+    # Check that all cells in the line are indeed clear *after* the loop finishes
+    for r_clr, c_clr in line_set:
+        assert not grid_data._occupied_np[r_clr, c_clr], (
+            f"Cell ({r_clr},{c_clr}) was not cleared for line '{line_name}' after test completion"
+        )

tests/core/environment/test_shape_logic.py

@@ -0,0 +1,171 @@
+# File: trianglengin/tests/core/environment/test_shape_logic.py
+import random
+
+import pytest
+
+# Import directly from the library being tested
+from trianglengin.core.environment import GameState
+from trianglengin.core.environment.shapes import logic as ShapeLogic
+from trianglengin.core.structs import Shape
+
+# Use fixtures from the local conftest.py
+# Fixtures are implicitly injected by pytest
+
+
+def test_generate_random_shape(fixed_rng: random.Random):
+    """Test generating a single random shape."""
+    shape = ShapeLogic.generate_random_shape(fixed_rng)
+    assert isinstance(shape, Shape)
+    assert shape.triangles is not None
+    assert shape.color is not None
+    assert len(shape.triangles) > 0
+    # Check connectivity (optional but good)
+    assert ShapeLogic.is_shape_connected(shape)
+
+
+def test_generate_multiple_shapes(fixed_rng: random.Random):
+    """Test generating multiple shapes to ensure variety (or lack thereof with fixed seed)."""
+    shape1 = ShapeLogic.generate_random_shape(fixed_rng)
+    # Re-seed or use different rng instance if true randomness is needed per call
+    # For this test, using the same fixed_rng will likely produce the same shape again
+    shape2 = ShapeLogic.generate_random_shape(fixed_rng)
+    # --- REMOVED INCORRECT ASSERTION ---
+    # assert shape1 == shape2  # Expect same shape due to fixed seed - THIS IS INCORRECT
+    # --- END REMOVED ---
+    # Check that subsequent calls produce different results with the same RNG instance
+    assert shape1 != shape2, (
+        "Two consecutive calls with the same RNG produced the exact same shape (template and color), which is highly unlikely."
+    )
+
+    # Use a different seed for variation
+    rng2 = random.Random(54321)
+    shape3 = ShapeLogic.generate_random_shape(rng2)
+    # Check that different RNGs produce different results (highly likely)
+    assert shape1 != shape3 or shape1.color != shape3.color
+
+
+def test_refill_shape_slots_empty(game_state: GameState, fixed_rng: random.Random):
+    """Test refilling when all slots are initially empty."""
+    game_state.shapes = [None] * game_state.env_config.NUM_SHAPE_SLOTS
+    ShapeLogic.refill_shape_slots(game_state, fixed_rng)
+    assert all(s is not None for s in game_state.shapes)
+    assert len(game_state.shapes) == game_state.env_config.NUM_SHAPE_SLOTS
+
+
+def test_refill_shape_slots_partial(game_state: GameState, fixed_rng: random.Random):
+    """Test refilling when some slots are empty - SHOULD NOT REFILL."""
+    num_slots = game_state.env_config.NUM_SHAPE_SLOTS
+    if num_slots < 2:
+        pytest.skip("Test requires at least 2 shape slots")
+
+    # Start with full slots
+    ShapeLogic.refill_shape_slots(game_state, fixed_rng)
+    assert all(s is not None for s in game_state.shapes)
+
+    # Empty one slot
+    game_state.shapes[0] = None
+    # Store original state (important: copy shapes if they are mutable)
+    original_shapes = [s.copy() if s else None for s in game_state.shapes]
+
+    # Attempt refill - it should do nothing
+    ShapeLogic.refill_shape_slots(game_state, fixed_rng)
+
+    # Check that shapes remain unchanged
+    assert game_state.shapes == original_shapes, "Refill happened unexpectedly"
+
+
+def test_refill_shape_slots_full(game_state: GameState, fixed_rng: random.Random):
+    """Test refilling when all slots are already full - SHOULD NOT REFILL."""
+    # Start with full slots
+    ShapeLogic.refill_shape_slots(game_state, fixed_rng)
+    assert all(s is not None for s in game_state.shapes)
+    original_shapes = [s.copy() if s else None for s in game_state.shapes]
+
+    # Attempt refill - should do nothing
+    ShapeLogic.refill_shape_slots(game_state, fixed_rng)
+
+    # Check shapes are unchanged
+    assert game_state.shapes == original_shapes, "Refill happened when slots were full"
+
+
+def test_refill_shape_slots_batch_trigger(game_state: GameState) -> None:
+    """Test that refill only happens when ALL slots are empty."""
+    num_slots = game_state.env_config.NUM_SHAPE_SLOTS
+    if num_slots < 2:
+        pytest.skip("Test requires at least 2 shape slots")
+
+    # Fill all slots initially
+    ShapeLogic.refill_shape_slots(game_state, game_state._rng)
+    initial_shapes = [s.copy() if s else None for s in game_state.shapes]
+    assert all(s is not None for s in initial_shapes)
+
+    # Empty one slot - refill should NOT happen
+    game_state.shapes[0] = None
+    shapes_after_one_empty = [s.copy() if s else None for s in game_state.shapes]
+    ShapeLogic.refill_shape_slots(game_state, game_state._rng)
+    assert game_state.shapes == shapes_after_one_empty, (
+        "Refill happened when only one slot was empty"
+    )
+
+    # Empty all slots - refill SHOULD happen
+    game_state.shapes = [None] * num_slots
+    ShapeLogic.refill_shape_slots(game_state, game_state._rng)
+    assert all(s is not None for s in game_state.shapes), (
+        "Refill did not happen when all slots were empty"
+    )
+    # Check that the shapes are different from the initial ones (probabilistically)
+    assert game_state.shapes != initial_shapes, (
+        "Shapes after refill are identical to initial shapes (unlikely)"
+    )
+
+
+# --- ADDED TESTS ---
+def test_get_neighbors():
+    """Test neighbor calculation for up and down triangles."""
+    # Up triangle at (1, 1)
+    up_neighbors = ShapeLogic.get_neighbors(r=1, c=1, is_up=True)
+    # Expected: Left (1,0), Right (1,2), Vertical (Down) (2,1)
+    assert set(up_neighbors) == {(1, 0), (1, 2), (2, 1)}
+
+    # Down triangle at (1, 2)
+    down_neighbors = ShapeLogic.get_neighbors(r=1, c=2, is_up=False)
+    # Expected: Left (1,1), Right (1,3), Vertical (Up) (0,2)
+    assert set(down_neighbors) == {(1, 1), (1, 3), (0, 2)}
+
+
+def test_is_shape_connected_true(simple_shape: Shape):  # Use fixture
+    """Test connectivity for various connected shapes."""
+    # Single triangle
+    shape1 = Shape([(0, 0, True)], (1, 1, 1))
+    assert ShapeLogic.is_shape_connected(shape1)
+
+    # Domino (horizontal) - Down(0,0) connects to Up(0,1)
+    shape2 = Shape([(0, 0, False), (0, 1, True)], (1, 1, 1))
+    assert ShapeLogic.is_shape_connected(shape2)
+
+    # L-shape (from simple_shape fixture) - Down(0,0) connects Up(1,0), Up(1,0) connects Down(1,1)
+    assert ShapeLogic.is_shape_connected(simple_shape)  # Test the fixture directly
+
+    # Empty shape
+    shape4 = Shape([], (1, 1, 1))
+    assert ShapeLogic.is_shape_connected(shape4)
+
+    # More complex connected shape
+    shape5 = Shape(
+        [(0, 0, False), (0, 1, True), (1, 1, False), (1, 0, True)], (1, 1, 1)
+    )
+    assert ShapeLogic.is_shape_connected(shape5)
+
+
+def test_is_shape_connected_false():
+    """Test connectivity for disconnected shapes."""
+    # Two separate triangles
+    shape1 = Shape([(0, 0, True), (2, 2, False)], (1, 1, 1))
+    assert not ShapeLogic.is_shape_connected(shape1)
+
+    # Three triangles, two connected, one separate
+    shape2 = Shape([(0, 0, False), (0, 1, True), (3, 3, True)], (1, 1, 1))
+    assert not ShapeLogic.is_shape_connected(shape2)
+
+
+# --- END ADDED TESTS ---