Positions are always mcrfpy.Vector, Vector/tuple/iterables expected as inputs, and for position-only inputs we permit x,y args to prevent requiring double-parens

tests/unit/test_grid_pathfinding_positions.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Test Grid pathfinding methods with new position parsing.
+
+Tests that Grid.find_path, Grid.compute_fov, etc. accept positions
+in multiple formats: tuples, lists, Vectors.
+"""
+import mcrfpy
+import sys
+
+def run_tests():
+    """Run all grid pathfinding position parsing tests."""
+    print("Testing Grid pathfinding position parsing...")
+
+    # Create a test grid
+    texture = mcrfpy.Texture("assets/kenney_ice.png", 16, 16)
+    grid = mcrfpy.Grid(grid_size=(10, 10), texture=texture, pos=(0, 0), size=(320, 320))
+
+    # Set up walkability: all cells walkable initially
+    for y in range(10):
+        for x in range(10):
+            cell = grid.at((x, y))
+            cell.walkable = True
+
+    # Add a wall in the middle
+    grid.at((5, 5)).walkable = False
+
+    print("  Grid created with walkable cells and one wall at (5,5)")
+
+    # ============ Test find_path ============
+    print("\n  Testing find_path...")
+
+    # Test with tuple positions
+    path1 = grid.find_path((0, 0), (3, 3))
+    assert path1 is not None, "find_path with tuples returned None"
+    assert len(path1) > 0, "find_path with tuples returned empty path"
+    print(f"    find_path((0,0), (3,3)) -> {len(path1)} steps: PASS")
+
+    # Test with list positions
+    path2 = grid.find_path([0, 0], [3, 3])
+    assert path2 is not None, "find_path with lists returned None"
+    assert len(path2) > 0, "find_path with lists returned empty path"
+    print(f"    find_path([0,0], [3,3]) -> {len(path2)} steps: PASS")
+
+    # Test with Vector positions
+    start_vec = mcrfpy.Vector(0, 0)
+    end_vec = mcrfpy.Vector(3, 3)
+    path3 = grid.find_path(start_vec, end_vec)
+    assert path3 is not None, "find_path with Vectors returned None"
+    assert len(path3) > 0, "find_path with Vectors returned empty path"
+    print(f"    find_path(Vector(0,0), Vector(3,3)) -> {len(path3)} steps: PASS")
+
+    # Test path with diagonal_cost parameter
+    path4 = grid.find_path((0, 0), (3, 3), diagonal_cost=1.41)
+    assert path4 is not None, "find_path with diagonal_cost returned None"
+    print(f"    find_path with diagonal_cost=1.41: PASS")
+
+    # ============ Test compute_fov / is_in_fov ============
+    print("\n  Testing compute_fov / is_in_fov...")
+
+    # All cells transparent for FOV testing
+    for y in range(10):
+        for x in range(10):
+            cell = grid.at((x, y))
+            cell.transparent = True
+
+    # Test compute_fov with tuple
+    grid.compute_fov((5, 5), radius=5)
+    print("    compute_fov((5,5), radius=5): PASS")
+
+    # Test is_in_fov with tuple
+    in_fov1 = grid.is_in_fov((5, 5))
+    assert in_fov1 == True, "Center should be in FOV"
+    print(f"    is_in_fov((5,5)) = {in_fov1}: PASS")
+
+    # Test is_in_fov with list
+    in_fov2 = grid.is_in_fov([4, 5])
+    assert in_fov2 == True, "Adjacent cell should be in FOV"
+    print(f"    is_in_fov([4,5]) = {in_fov2}: PASS")
+
+    # Test is_in_fov with Vector
+    pos_vec = mcrfpy.Vector(6, 5)
+    in_fov3 = grid.is_in_fov(pos_vec)
+    assert in_fov3 == True, "Adjacent cell should be in FOV"
+    print(f"    is_in_fov(Vector(6,5)) = {in_fov3}: PASS")
+
+    # Test compute_fov with Vector
+    center_vec = mcrfpy.Vector(3, 3)
+    grid.compute_fov(center_vec, radius=3)
+    print("    compute_fov(Vector(3,3), radius=3): PASS")
+
+    # ============ Test compute_dijkstra / get_dijkstra_* ============
+    print("\n  Testing Dijkstra methods...")
+
+    # Test compute_dijkstra with tuple
+    grid.compute_dijkstra((0, 0))
+    print("    compute_dijkstra((0,0)): PASS")
+
+    # Test get_dijkstra_distance with tuple
+    dist1 = grid.get_dijkstra_distance((3, 3))
+    assert dist1 is not None, "Distance should not be None for reachable cell"
+    print(f"    get_dijkstra_distance((3,3)) = {dist1:.2f}: PASS")
+
+    # Test get_dijkstra_distance with list
+    dist2 = grid.get_dijkstra_distance([2, 2])
+    assert dist2 is not None, "Distance should not be None for reachable cell"
+    print(f"    get_dijkstra_distance([2,2]) = {dist2:.2f}: PASS")
+
+    # Test get_dijkstra_distance with Vector
+    dist3 = grid.get_dijkstra_distance(mcrfpy.Vector(1, 1))
+    assert dist3 is not None, "Distance should not be None for reachable cell"
+    print(f"    get_dijkstra_distance(Vector(1,1)) = {dist3:.2f}: PASS")
+
+    # Test get_dijkstra_path with tuple
+    dpath1 = grid.get_dijkstra_path((3, 3))
+    assert dpath1 is not None, "Dijkstra path should not be None"
+    print(f"    get_dijkstra_path((3,3)) -> {len(dpath1)} steps: PASS")
+
+    # Test get_dijkstra_path with Vector
+    dpath2 = grid.get_dijkstra_path(mcrfpy.Vector(4, 4))
+    assert dpath2 is not None, "Dijkstra path should not be None"
+    print(f"    get_dijkstra_path(Vector(4,4)) -> {len(dpath2)} steps: PASS")
+
+    # ============ Test compute_astar_path ============
+    print("\n  Testing compute_astar_path...")
+
+    # Test with tuples
+    apath1 = grid.compute_astar_path((0, 0), (3, 3))
+    assert apath1 is not None, "A* path should not be None"
+    print(f"    compute_astar_path((0,0), (3,3)) -> {len(apath1)} steps: PASS")
+
+    # Test with lists
+    apath2 = grid.compute_astar_path([1, 1], [4, 4])
+    assert apath2 is not None, "A* path should not be None"
+    print(f"    compute_astar_path([1,1], [4,4]) -> {len(apath2)} steps: PASS")
+
+    # Test with Vectors
+    apath3 = grid.compute_astar_path(mcrfpy.Vector(2, 2), mcrfpy.Vector(7, 7))
+    assert apath3 is not None, "A* path should not be None"
+    print(f"    compute_astar_path(Vector(2,2), Vector(7,7)) -> {len(apath3)} steps: PASS")
+
+    print("\n" + "="*50)
+    print("All grid pathfinding position tests PASSED!")
+    print("="*50)
+    return True
+
+# Run tests
+try:
+    success = run_tests()
+    if success:
+        print("\nPASS")
+        sys.exit(0)
+except Exception as e:
+    print(f"\nFAIL: {e}")
+    import traceback
+    traceback.print_exc()
+    sys.exit(1)