Test suite modernization

tests/wiki_phase_d3_verify.py

@@ -0,0 +1,470 @@
+"""Verify code snippets from Phase D batch 3 wiki updates."""
+import mcrfpy
+import sys
+
+passes = 0
+fails = 0
+
+def check(name, fn):
+    global passes, fails
+    try:
+        fn()
+        passes += 1
+        print(f"  [OK] {name}")
+    except Exception as e:
+        fails += 1
+        print(f"  [FAIL] {name}: {e}")
+
+# ===================================================================
+print("=== PROCEDURAL GENERATION ===")
+# ===================================================================
+
+def test_pg_bsp_basic():
+    """BSP dungeon generation pattern"""
+    grid = mcrfpy.Grid(grid_size=(50, 50), pos=(0, 0), size=(400, 400))
+
+    # Set cells walkable (carve a room)
+    for x in range(10, 20):
+        for y in range(10, 20):
+            cell = grid.at(x, y)
+            cell.walkable = True
+            cell.transparent = True
+
+    # Verify
+    assert grid.at(15, 15).walkable == True
+    assert grid.at(0, 0).walkable == False
+
+check("PG: BSP basic grid setup", test_pg_bsp_basic)
+
+def test_pg_cell_properties():
+    """Cell property access patterns"""
+    grid = mcrfpy.Grid(grid_size=(20, 20), pos=(0, 0), size=(320, 320))
+    cell = grid.at(5, 5)
+
+    # Test walkable
+    cell.walkable = True
+    assert cell.walkable == True
+    cell.walkable = False
+    assert cell.walkable == False
+
+    # Test transparent
+    cell.transparent = True
+    assert cell.transparent == True
+    cell.transparent = False
+    assert cell.transparent == False
+
+check("PG: cell properties", test_pg_cell_properties)
+
+def test_pg_entity_placement():
+    """Entity placement in generated rooms"""
+    import random
+    grid = mcrfpy.Grid(grid_size=(30, 30), pos=(0, 0), size=(400, 400))
+
+    # Place entities
+    for i in range(5):
+        e = mcrfpy.Entity(grid_pos=(10 + i, 10), sprite_index=i)
+        grid.entities.append(e)
+
+    assert len(grid.entities) == 5
+
+check("PG: entity placement", test_pg_entity_placement)
+
+def test_pg_scene_setup():
+    """Scene setup for procgen"""
+    scene = mcrfpy.Scene("pg_test")
+    grid = mcrfpy.Grid(grid_size=(50, 50), pos=(0, 0), size=(400, 400))
+    scene.children.append(grid)
+
+    player = mcrfpy.Entity(grid_pos=(25, 25), sprite_index=1)
+    grid.entities.append(player)
+
+check("PG: scene setup", test_pg_scene_setup)
+
+def test_pg_timer_generation():
+    """Timer-based incremental generation"""
+    step_count = [0]
+
+    def generate_step(timer, runtime):
+        step_count[0] += 1
+        if step_count[0] >= 3:
+            timer.stop()
+
+    t = mcrfpy.Timer("pg_gen", generate_step, 100)
+    # Each step() call can fire at most one timer event
+    for _ in range(5):
+        mcrfpy.step(0.11)
+    assert step_count[0] >= 3, f"Expected >= 3 fires, got {step_count[0]}"
+    t.stop()
+
+check("PG: timer generation", test_pg_timer_generation)
+
+def test_pg_grid_size():
+    """Grid size access"""
+    grid = mcrfpy.Grid(grid_size=(40, 30), pos=(0, 0), size=(400, 300))
+    gs = grid.grid_size
+    assert gs[0] == 40
+    assert gs[1] == 30
+
+check("PG: grid_size property", test_pg_grid_size)
+
+# ===================================================================
+print("\n=== GRID RENDERING PIPELINE ===")
+# ===================================================================
+
+def test_grp_layer_creation():
+    """Layer creation with standalone objects"""
+    grid = mcrfpy.Grid(grid_size=(20, 20), pos=(0, 0), size=(320, 320), layers=[])
+
+    # Create layers as standalone objects
+    bg = mcrfpy.ColorLayer(name="background", z_index=-2)
+    grid.add_layer(bg)
+
+    # Overlay above entities
+    overlay = mcrfpy.ColorLayer(name="overlay", z_index=1)
+    grid.add_layer(overlay)
+
+    # Verify layers exist
+    assert grid.layer("background") is not None
+    assert grid.layer("overlay") is not None
+
+check("GRP: layer creation", test_grp_layer_creation)
+
+def test_grp_layer_operations():
+    """Layer set/at/fill operations"""
+    grid = mcrfpy.Grid(grid_size=(10, 10), pos=(0, 0), size=(160, 160), layers=[])
+
+    cl = mcrfpy.ColorLayer(name="colors", z_index=-1)
+    grid.add_layer(cl)
+
+    # Fill
+    cl.fill(mcrfpy.Color(0, 0, 0, 255))
+
+    # Set individual cell
+    cl.set((5, 5), mcrfpy.Color(255, 0, 0, 255))
+
+    # Read back
+    c = cl.at((5, 5))
+    assert c.r == 255
+
+check("GRP: layer operations", test_grp_layer_operations)
+
+def test_grp_tile_layer():
+    """TileLayer creation"""
+    grid = mcrfpy.Grid(grid_size=(10, 10), pos=(0, 0), size=(160, 160), layers=[])
+
+    tl = mcrfpy.TileLayer(name="tiles", z_index=-1)
+    grid.add_layer(tl)
+
+    assert grid.layer("tiles") is not None
+
+check("GRP: TileLayer creation", test_grp_tile_layer)
+
+def test_grp_z_index():
+    """Z-index layer ordering"""
+    grid = mcrfpy.Grid(grid_size=(10, 10), pos=(0, 0), size=(160, 160), layers=[])
+
+    l1 = mcrfpy.ColorLayer(name="below", z_index=-2)
+    l2 = mcrfpy.ColorLayer(name="above", z_index=1)
+    grid.add_layer(l1)
+    grid.add_layer(l2)
+
+    below = grid.layer("below")
+    above = grid.layer("above")
+    assert below.z_index == -2
+    assert above.z_index == 1
+
+check("GRP: z-index ordering", test_grp_z_index)
+
+def test_grp_fog_overlay():
+    """Fog overlay pattern with layer"""
+    grid = mcrfpy.Grid(grid_size=(20, 20), pos=(0, 0), size=(320, 320), layers=[])
+    fog = mcrfpy.ColorLayer(name="fog", z_index=1)
+    grid.add_layer(fog)
+    fog.fill(mcrfpy.Color(0, 0, 0, 192))
+
+    # Make all cells transparent for FOV
+    for x in range(20):
+        for y in range(20):
+            grid.at(x, y).transparent = True
+            grid.at(x, y).walkable = True
+
+    # Compute FOV and reveal
+    grid.compute_fov((10, 10), radius=8)
+    for x in range(20):
+        for y in range(20):
+            if grid.is_in_fov((x, y)):
+                fog.set((x, y), mcrfpy.Color(0, 0, 0, 0))
+
+    # Origin should be revealed
+    c = fog.at((10, 10))
+    assert c.a == 0
+
+check("GRP: fog overlay", test_grp_fog_overlay)
+
+def test_grp_grid_properties():
+    """Grid rendering properties"""
+    grid = mcrfpy.Grid(grid_size=(20, 20), pos=(0, 0), size=(320, 320))
+
+    # Check zoom property exists
+    assert hasattr(grid, 'zoom')
+
+    # Check center properties
+    assert hasattr(grid, 'center')
+
+check("GRP: grid properties", test_grp_grid_properties)
+
+# ===================================================================
+print("\n=== GRID TCOD INTEGRATION ===")
+# ===================================================================
+
+def test_tcod_fov():
+    """FOV computation with tuple args"""
+    grid = mcrfpy.Grid(grid_size=(30, 30), pos=(0, 0), size=(400, 400))
+    for x in range(30):
+        for y in range(30):
+            grid.at(x, y).transparent = True
+            grid.at(x, y).walkable = True
+
+    # Add wall
+    grid.at(15, 10).transparent = False
+    grid.at(15, 10).walkable = False
+
+    # Compute FOV
+    grid.compute_fov((10, 10), radius=10)
+
+    # Origin should be visible
+    assert grid.is_in_fov((10, 10))
+
+    # Behind wall might not be visible
+    # (depends on exact algorithm, just check API works)
+    grid.is_in_fov((20, 10))  # Just verify no crash
+
+check("TCOD: FOV computation", test_tcod_fov)
+
+def test_tcod_pathfinding():
+    """A* pathfinding with AStarPath object"""
+    grid = mcrfpy.Grid(grid_size=(30, 30), pos=(0, 0), size=(400, 400))
+    for x in range(30):
+        for y in range(30):
+            grid.at(x, y).walkable = True
+
+    # Find path
+    path = grid.find_path((5, 5), (25, 25))
+    assert path is not None
+    assert len(path) > 0
+
+    # Walk the path
+    step = path.walk()
+    assert step is not None
+
+    # Check properties
+    assert path.origin is not None
+    assert path.destination is not None
+    assert path.remaining >= 0
+
+check("TCOD: A* pathfinding", test_tcod_pathfinding)
+
+def test_tcod_dijkstra():
+    """Dijkstra map with DijkstraMap object"""
+    grid = mcrfpy.Grid(grid_size=(30, 30), pos=(0, 0), size=(400, 400))
+    for x in range(30):
+        for y in range(30):
+            grid.at(x, y).walkable = True
+
+    dm = grid.get_dijkstra_map((15, 15))
+
+    # Get distance
+    d = dm.distance((0, 0))
+    assert d > 0
+
+    # Get path
+    p = dm.path_from((0, 0))
+    assert len(p) > 0
+
+    # Get next step
+    s = dm.step_from((0, 0))
+    assert s is not None
+
+check("TCOD: Dijkstra map", test_tcod_dijkstra)
+
+def test_tcod_perspective():
+    """Grid perspective assignment"""
+    grid = mcrfpy.Grid(grid_size=(20, 20), pos=(0, 0), size=(320, 320))
+    player = mcrfpy.Entity(grid_pos=(10, 10), sprite_index=0)
+    grid.entities.append(player)
+
+    # Set perspective
+    grid.perspective = player
+    assert grid.perspective is not None
+
+check("TCOD: perspective", test_tcod_perspective)
+
+def test_tcod_dynamic_obstacle():
+    """Dynamic obstacle pattern"""
+    grid = mcrfpy.Grid(grid_size=(20, 20), pos=(0, 0), size=(320, 320))
+    for x in range(20):
+        for y in range(20):
+            grid.at(x, y).walkable = True
+
+    # Open door pattern
+    door = grid.at(10, 10)
+    door.walkable = False
+    door.transparent = False
+
+    # Verify path around door
+    path = grid.find_path((5, 10), (15, 10))
+    assert path is not None  # Should find path around
+
+    # Open door
+    door.walkable = True
+    door.transparent = True
+
+    # Path should now go through
+    path2 = grid.find_path((5, 10), (15, 10))
+    assert path2 is not None
+    # Direct path should be shorter
+    assert len(path2) <= len(path)
+
+check("TCOD: dynamic obstacle", test_tcod_dynamic_obstacle)
+
+# ===================================================================
+print("\n=== PERFORMANCE PATTERNS ===")
+# ===================================================================
+
+def test_perf_benchmark_api():
+    """Check benchmark API exists"""
+    assert hasattr(mcrfpy, 'start_benchmark') or True  # May not exist
+    # Just check step works for headless benchmarking
+    dt = mcrfpy.step(0.016)
+    assert dt is not None
+
+check("PERF: step-based benchmarking", test_perf_benchmark_api)
+
+def test_perf_timer_benchmark():
+    """Timer-based benchmarking pattern"""
+    frame_times = []
+
+    def measure(timer, runtime):
+        frame_times.append(runtime)
+        if len(frame_times) >= 5:
+            timer.stop()
+
+    t = mcrfpy.Timer("perf_bench", measure, 50)
+    mcrfpy.step(0.3)  # Run several frames
+    t.stop()
+
+    assert len(frame_times) > 0
+
+check("PERF: timer benchmark", test_perf_timer_benchmark)
+
+# ===================================================================
+print("\n=== PYTHON BINDING LAYER PATTERNS ===")
+# ===================================================================
+
+def test_pbl_grid_constructor():
+    """Modern grid constructor"""
+    grid = mcrfpy.Grid(grid_size=(10, 10), pos=(0, 0), size=(160, 160))
+    gs = grid.grid_size
+    assert gs[0] == 10
+    assert gs[1] == 10
+
+check("PBL: Grid constructor", test_pbl_grid_constructor)
+
+def test_pbl_entity_constructor():
+    """Modern entity constructor"""
+    e = mcrfpy.Entity(grid_pos=(5, 5), sprite_index=42)
+    assert e.grid_x == 5
+    assert e.grid_y == 5
+    # sprite_index is set
+    assert e.sprite_index == 42
+
+check("PBL: Entity constructor", test_pbl_entity_constructor)
+
+def test_pbl_frame_constructor():
+    """Frame constructor with keywords"""
+    f = mcrfpy.Frame(pos=(100, 200), size=(300, 150))
+    assert f.x == 100
+    assert f.y == 200
+    assert f.w == 300
+    assert f.h == 150
+
+check("PBL: Frame constructor", test_pbl_frame_constructor)
+
+def test_pbl_sprite_constructor():
+    """Sprite constructor"""
+    s = mcrfpy.Sprite(x=10, y=20, sprite_index=5)
+    assert s.x == 10
+    assert s.y == 20
+
+check("PBL: Sprite constructor", test_pbl_sprite_constructor)
+
+def test_pbl_caption_constructor():
+    """Caption constructor"""
+    c = mcrfpy.Caption(text="Hello", pos=(50, 60))
+    assert c.text == "Hello"
+    assert c.x == 50
+
+check("PBL: Caption constructor", test_pbl_caption_constructor)
+
+def test_pbl_color():
+    """Color creation"""
+    c = mcrfpy.Color(255, 128, 0, 200)
+    assert c.r == 255
+    assert c.g == 128
+    assert c.b == 0
+    assert c.a == 200
+
+check("PBL: Color object", test_pbl_color)
+
+def test_pbl_scene_api():
+    """Scene API pattern"""
+    scene = mcrfpy.Scene("pbl_test")
+    f = mcrfpy.Frame(pos=(0, 0), size=(100, 100))
+    scene.children.append(f)
+    assert len(scene.children) >= 1
+
+check("PBL: Scene API", test_pbl_scene_api)
+
+# Check what benchmark API exists
+def test_check_benchmark_api():
+    """Check which benchmark methods exist"""
+    has_start = hasattr(mcrfpy, 'start_benchmark')
+    has_end = hasattr(mcrfpy, 'end_benchmark')
+    has_log = hasattr(mcrfpy, 'log_benchmark')
+    print(f"    start_benchmark: {has_start}, end_benchmark: {has_end}, log_benchmark: {has_log}")
+    # Also check for sync methods on grid
+    grid = mcrfpy.Grid(grid_size=(10, 10), pos=(0, 0), size=(160, 160))
+    has_sync = hasattr(grid, 'sync_tcod_map')
+    has_sync_cell = hasattr(grid, 'sync_tcod_cell')
+    print(f"    sync_tcod_map: {has_sync}, sync_tcod_cell: {has_sync_cell}")
+    # Check for FOV algorithm constants
+    has_fov_basic = hasattr(mcrfpy, 'FOV_BASIC')
+    print(f"    FOV_BASIC constant: {has_fov_basic}")
+    # Check cell.tilesprite
+    cell = grid.at(0, 0)
+    has_tilesprite = hasattr(cell, 'tilesprite')
+    has_sprite_index = hasattr(cell, 'sprite_index')
+    has_tile_index = hasattr(cell, 'tile_index')
+    print(f"    cell.tilesprite: {has_tilesprite}, cell.sprite_index: {has_sprite_index}, cell.tile_index: {has_tile_index}")
+    # Check cell color property
+    has_color = hasattr(cell, 'color')
+    has_fill_color = hasattr(cell, 'fill_color')
+    print(f"    cell.color: {has_color}, cell.fill_color: {has_fill_color}")
+    # Check entities_in_radius
+    has_eir = hasattr(grid, 'entities_in_radius')
+    print(f"    entities_in_radius: {has_eir}")
+    # List all grid cell (GridPoint) attributes
+    cell_attrs = [a for a in dir(cell) if not a.startswith('_')]
+    print(f"    GridPoint attrs: {cell_attrs}")
+
+check("API: check available methods", test_check_benchmark_api)
+
+# ===================================================================
+print("\n" + "=" * 60)
+print(f"PHASE D3 VERIFICATION: {passes} passed, {fails} failed")
+print("=" * 60)
+
+if fails:
+    sys.exit(1)
+else:
+    sys.exit(0)