synth-ai 0.2.13.dev1__py3-none-any.whl → 0.2.14__py3-none-any.whl

examples/task_apps/dev/pokemon_emerald/external/pokeagent-speedrun/tests/test_memory_map.py

@@ -0,0 +1,575 @@
+import os
+import pytest
+from pathlib import Path
+import numpy as np
+from pprint import pprint
+
+from pokemon_env.emulator import EmeraldEmulator
+from pokemon_env.enums import MetatileBehavior
+
+def format_map_data(map_data, title="Map Data"):
+    """Format the map data into a string using the agent's format"""
+    print(f"Map data: {map_data}")
+    lines = []
+    lines.append(f"=== {title} ===")
+    lines.append("Format: (MetatileID, Behavior, X, Y)")
+    lines.append(f"Map dimensions: {len(map_data)}x{len(map_data[0])}")
+    lines.append("")
+    lines.append("--- TRAVERSABILITY MAP ---")
+    
+    # Column headers
+    header = "     "
+    for i in range(len(map_data[0])):
+        header += f"{i:2} "
+    lines.append(header)
+    lines.append("    " + "--" * len(map_data[0]))
+    
+    # Find player position (center of the grid)
+    center_y = len(map_data) // 2
+    center_x = len(map_data[0]) // 2
+    
+    # Format each row
+    for y in range(len(map_data)):
+        row = f"{y:2}: "
+        for x in range(len(map_data[y])):
+            if y == center_y and x == center_x:
+                row += "P"  # Player position
+            else:
+                tile = map_data[y][x]
+                behavior = tile[1]
+                # Convert behavior to map symbol using same logic as get_comprehensive_state
+                tile_id, behavior, collision, elevation = tile
+                
+                # Handle both enum objects and raw integers from server API
+                if hasattr(behavior, 'name'):
+                    behavior_name = behavior.name
+                elif isinstance(behavior, int):
+                    try:
+                        behavior_enum = MetatileBehavior(behavior)
+                        behavior_name = behavior_enum.name
+                    except ValueError:
+                        behavior_name = "UNKNOWN"
+                else:
+                    behavior_name = "UNKNOWN"
+                
+                if behavior_name == "NORMAL":
+                    # For normal tiles, use collision data to determine if passable
+                    row += "." if collision == 0 else "#"
+                elif "TALL_GRASS" in behavior_name:
+                    row += "~"  # Tall grass
+                elif "WATER" in behavior_name:
+                    row += "W"  # Water
+                elif "JUMP" in behavior_name:
+                    # Show jump direction
+                    if "JUMP_EAST" in behavior_name:
+                        row += "→"
+                    elif "JUMP_WEST" in behavior_name:
+                        row += "←"
+                    elif "JUMP_NORTH" in behavior_name:
+                        row += "↑"
+                    elif "JUMP_SOUTH" in behavior_name:
+                        row += "↓"
+                    elif "JUMP_NORTHEAST" in behavior_name:
+                        row += "↗"
+                    elif "JUMP_NORTHWEST" in behavior_name:
+                        row += "↖"
+                    elif "JUMP_SOUTHEAST" in behavior_name:
+                        row += "↘"
+                    elif "JUMP_SOUTHWEST" in behavior_name:
+                        row += "↙"
+                    else:
+                        row += "J"
+                elif "DOOR" in behavior_name:
+                    row += "D"  # Door
+                else:
+                    # For other behaviors, show abbreviated name
+                    short_name = behavior_name.replace("_", "")[:4]
+                    row += f"{short_name[:2]}"
+            row += " "  # Add space between tiles
+        lines.append(row.rstrip())
+    
+    return "\n".join(lines)
+
+def print_map_data(map_data, title="Map Data"):
+    """Pretty print the map data and return the formatted string"""
+    formatted_map = format_map_data(map_data, title)
+    print("\n" + formatted_map)
+    print("\nLegend:")
+    print("  P  = Player position")
+    print("  .  = Normal walkable path")
+    print("  #  = Blocked/wall")
+    print("  D  = Door (can be entered)")
+    print("  ~  = Tall grass (wild Pokemon encounters)")
+    print("  W  = Water (requires Surf)")
+    print("  IM = Impassable terrain")
+    print("  SE = Sealed area (cannot enter)")
+    print("  EA = East arrow (direction indicator)")
+    print("  SO = Sound mat (makes sound when stepped on)")
+    print("  TE = Television")
+    print("  →←↑↓↗↖↘↙ = Jump ledge directions (can jump in that direction)")
+    return formatted_map
+
+# Get the absolute path to the test states directory
+TEST_STATES_DIR = os.path.join(os.path.dirname(__file__), "states")
+
+@pytest.fixture
+def emulator():
+    """Create and initialize an emulator instance"""
+    # Get path to ROM file
+    project_root = Path(__file__).parent.parent
+    rom_path = str(project_root / "Emerald-GBAdvance" / "rom.gba")
+    
+    # Initialize emulator
+    emu = EmeraldEmulator(rom_path, headless=True, sound=False)
+    emu.initialize()
+    
+    yield emu
+    
+    # Cleanup
+    emu.stop()
+
+def test_house_state_map_reading(emulator):
+    """Test map reading functionality in the house state"""
+    # Load the house state
+    state_path = os.path.join(TEST_STATES_DIR, "house.state")
+    emulator.load_state(state_path)
+    
+    # Get map data around player using the same function as the agent
+    map_data = emulator.memory_reader.read_map_around_player(radius=7)
+    
+    # Format the map data
+    formatted_map = print_map_data(map_data, "House State Map")
+    
+    # Load ground truth
+    truth_path = os.path.join(TEST_STATES_DIR, "house_map_truth.txt")
+    with open(truth_path, 'r') as f:
+        expected_map = f.read().strip()
+    
+    # Compare with ground truth
+    assert formatted_map == expected_map, "Map output does not match ground truth"
+    
+    # Basic structure tests
+    assert map_data is not None, "Map data should not be None"
+    assert isinstance(map_data, list), "Map data should be a list"
+    assert len(map_data) > 0, "Map data should not be empty"
+    assert isinstance(map_data[0], list), "Map data should be a 2D list"
+    
+    # Test map dimensions
+    height = len(map_data)
+    width = len(map_data[0])
+    assert height == 15, f"Map height should be 15 (2*radius + 1), got {height}"
+    assert width == 15, f"Map width should be 15 (2*radius + 1), got {width}"
+    
+    # Test tile data structure
+    center_tile = map_data[7][7]  # Center tile where player is
+    assert isinstance(center_tile, tuple), "Tile data should be a tuple"
+    assert len(center_tile) == 4, "Tile data should contain metatile ID, behavior, x, and y coordinates"
+    
+    # Test that we're indoors (should have indoor tiles)
+    center_behavior = center_tile[1]
+    assert isinstance(center_behavior, MetatileBehavior), "Tile behavior should be MetatileBehavior enum"
+    assert center_behavior in [MetatileBehavior.INDOOR_ENCOUNTER, MetatileBehavior.NORMAL], \
+        "Center tile should be an indoor tile"
+
+def test_truck_state_map_reading(emulator):
+    """Test map reading functionality in the truck state (game start)"""
+    # Load the truck state
+    state_path = os.path.join(TEST_STATES_DIR, "truck.state")
+    emulator.load_state(state_path)
+    
+    # Get map data around player using the same function as the agent
+    map_data = emulator.memory_reader.read_map_around_player(radius=7)
+    
+    # Format the map data
+    formatted_map = print_map_data(map_data, "Truck State Map")
+    
+    # Load ground truth
+    truth_path = os.path.join(TEST_STATES_DIR, "truck_map_truth.txt")
+    with open(truth_path, 'r') as f:
+        expected_map = f.read().strip()
+    
+    # Compare with ground truth
+    assert formatted_map == expected_map, "Map output does not match ground truth"
+    
+    # Basic structure tests
+    assert map_data is not None, "Map data should not be None"
+    assert isinstance(map_data, list), "Map data should be a list"
+    assert len(map_data) > 0, "Map data should not be empty"
+    assert isinstance(map_data[0], list), "Map data should be a 2D list"
+    
+    # Test map dimensions
+    height = len(map_data)
+    width = len(map_data[0])
+    assert height == 15, f"Map height should be 15 (2*radius + 1), got {height}"
+    assert width == 15, f"Map width should be 15 (2*radius + 1), got {width}"
+    
+    # Test tile data structure
+    center_tile = map_data[7][7]  # Center tile where player is
+    assert isinstance(center_tile, tuple), "Tile data should be a tuple"
+    assert len(center_tile) == 4, "Tile data should contain metatile ID, behavior, x, and y coordinates"
+    
+    # Test that we're in the truck (should have indoor/special tiles)
+    center_behavior = center_tile[1]
+    assert isinstance(center_behavior, MetatileBehavior), "Tile behavior should be MetatileBehavior enum"
+    assert center_behavior in [MetatileBehavior.INDOOR_ENCOUNTER, MetatileBehavior.NORMAL], \
+        "Center tile should be an indoor tile"
+
+def test_door_behavior(emulator):
+    """Test that doors are properly identified and not marked as blocked"""
+    # Load the house state
+    state_path = os.path.join(TEST_STATES_DIR, "house.state")
+    emulator.load_state(state_path)
+    
+    # Get map data around player using the same function as the agent
+    map_data = emulator.memory_reader.read_map_around_player(radius=7)
+    
+    # Print the map data for visual inspection
+    print_map_data(map_data, "House State Map (Door Test)")
+    
+    # Find any door tiles
+    door_found = False
+    door_behaviors = [MetatileBehavior.NON_ANIMATED_DOOR, 
+                     MetatileBehavior.ANIMATED_DOOR,
+                     MetatileBehavior.WATER_DOOR]
+    
+    for row in map_data:
+        for tile in row:
+            behavior = tile[1]
+            if behavior in door_behaviors:
+                door_found = True
+                # Verify door tile is not marked as blocked
+                assert behavior != MetatileBehavior.NORMAL, "Door should not be marked as normal path"
+                assert behavior in door_behaviors, "Door should have proper door behavior"
+    
+    # We should find at least one door in the house state
+    assert door_found, "No doors found in house state"
+
+def test_map_data_validation(emulator):
+    """Test validation of map data structure and content"""
+    # Load any state (using truck state)
+    state_path = os.path.join(TEST_STATES_DIR, "truck.state")
+    emulator.load_state(state_path)
+    
+    # Test different radius values
+    for radius in [3, 5, 7]:
+        map_data = emulator.memory_reader.read_map_around_player(radius=radius)
+        
+        # Check dimensions
+        expected_size = 2 * radius + 1
+        assert len(map_data) == expected_size, f"Map height should be {expected_size} for radius {radius}"
+        assert all(len(row) == expected_size for row in map_data), \
+            f"All rows should have width {expected_size} for radius {radius}"
+        
+        # Check tile data consistency
+        for row in map_data:
+            for tile in row:
+                    # Check tile structure
+                    assert isinstance(tile, tuple), "Tile data should be a tuple"
+                    assert len(tile) == 4, "Tile data should contain metatile ID, behavior, x, and y coordinates"
+                    
+                    # Check metatile ID
+                    metatile_id = tile[0]
+                    assert isinstance(metatile_id, int), "Metatile ID should be an integer"
+                    assert metatile_id >= 0, "Metatile ID should be non-negative"
+                
+                    # Check behavior
+                    behavior = tile[1]
+                    assert isinstance(behavior, MetatileBehavior), "Behavior should be MetatileBehavior enum"
+                    assert behavior.value >= 0, "Behavior value should be non-negative"
+
+def test_upstairs_state_map_reading(emulator):
+    """Test map reading functionality in the upstairs state"""
+    # Load the upstairs state
+    state_path = os.path.join(TEST_STATES_DIR, "upstairs.state")
+    emulator.load_state(state_path)
+    
+    # Get map data around player using the same function as the agent
+    map_data = emulator.memory_reader.read_map_around_player(radius=7)
+    
+    # Format the map data
+    formatted_map = print_map_data(map_data, "Upstairs State Map")
+    
+    # Basic structure tests
+    assert map_data is not None, "Map data should not be None"
+    assert isinstance(map_data, list), "Map data should be a list"
+    assert len(map_data) > 0, "Map data should not be empty"
+    assert isinstance(map_data[0], list), "Map data should be a 2D list"
+    
+    # Test map dimensions
+    height = len(map_data)
+    width = len(map_data[0])
+    assert height == 15, f"Map height should be 15 (2*radius + 1), got {height}"
+    assert width == 15, f"Map width should be 15 (2*radius + 1), got {width}"
+    
+    # Test tile data structure
+    center_tile = map_data[7][7]  # Center tile where player is
+    assert isinstance(center_tile, tuple), "Tile data should be a tuple"
+    assert len(center_tile) == 4, "Tile data should contain metatile ID, behavior, x, and y coordinates"
+    
+    # Test that we're indoors (should have indoor tiles)
+    center_behavior = center_tile[1]
+    assert isinstance(center_behavior, MetatileBehavior), "Tile behavior should be MetatileBehavior enum"
+    
+    # Print detailed information for debugging
+    # print(f"\n=== UPSTAIRS STATE DEBUG INFO ===")
+    print(f"Map dimensions: {width}x{height}")
+    print(f"Center tile: {center_tile}")
+    print(f"Center behavior: {center_behavior}")
+    
+    # Check for specific upstairs characteristics
+    # Upstairs should have indoor tiles, possibly doors, and specific layout
+    indoor_tiles = 0
+    door_tiles = 0
+    wall_tiles = 0
+    impassable_tiles = 0
+    normal_tiles = 0
+    
+    # Analyze the map data more thoroughly
+    for y, row in enumerate(map_data):
+        for x, tile in enumerate(row):
+            if len(tile) >= 2:
+                metatile_id, behavior, collision, elevation = tile
+                
+                # Count different tile types
+                if behavior == MetatileBehavior.INDOOR_ENCOUNTER:
+                    indoor_tiles += 1
+                elif behavior in [MetatileBehavior.NON_ANIMATED_DOOR, MetatileBehavior.ANIMATED_DOOR]:
+                    door_tiles += 1
+                elif behavior == MetatileBehavior.NORMAL:
+                    if collision > 0:
+                        wall_tiles += 1
+                    else:
+                        normal_tiles += 1
+                else:
+                    # Check if this is an impassable tile
+                    if metatile_id == 0 or behavior.value == 0:
+                        impassable_tiles += 1
+    
+    print(f"Indoor tiles found: {indoor_tiles}")
+    print(f"Door tiles found: {door_tiles}")
+    print(f"Wall tiles found: {wall_tiles}")
+    print(f"Normal walkable tiles found: {normal_tiles}")
+    print(f"Impassable tiles found: {impassable_tiles}")
+    
+    # Check map buffer addresses
+    print(f"\nMap buffer info:")
+    print(f"Map buffer address: 0x{emulator.memory_reader._map_buffer_addr:08X}")
+    print(f"Map width: {emulator.memory_reader._map_width}")
+    print(f"Map height: {emulator.memory_reader._map_height}")
+    
+    # Check player coordinates
+    player_coords = emulator.memory_reader.read_coordinates()
+    print(f"Player coordinates: {player_coords}")
+    
+    # Check if behaviors are being loaded correctly
+    all_behaviors = emulator.memory_reader.get_all_metatile_behaviors()
+    print(f"Total behaviors loaded: {len(all_behaviors) if all_behaviors else 0}")
+    
+    # Check specific tiles around the player
+    print(f"\nTile analysis around player (center):")
+    for dy in range(-2, 3):
+        for dx in range(-2, 3):
+            y = 7 + dy
+            x = 7 + dx
+            if 0 <= y < len(map_data) and 0 <= x < len(map_data[0]):
+                tile = map_data[y][x]
+                if len(tile) >= 4:
+                    metatile_id, behavior, collision, elevation = tile
+                    symbol = "P" if dy == 0 and dx == 0 else f"{metatile_id:03X}"
+                    print(f"  ({dx:+2d},{dy:+2d}): {symbol} {behavior.name} c{collision} e{elevation}")
+    
+    # Upstairs should have some indoor characteristics
+    assert indoor_tiles > 0 or door_tiles > 0, "Upstairs state should have indoor or door tiles"
+    
+    # Check if we have too many impassable tiles (might indicate map reading issues)
+    total_tiles = width * height
+    impassable_ratio = impassable_tiles / total_tiles
+    print(f"Impassable tile ratio: {impassable_ratio:.2%}")
+    
+    # If more than 50% of tiles are impassable, there might be an issue
+    if impassable_ratio > 0.5:
+        print("WARNING: High ratio of impassable tiles detected. This might indicate map reading issues.")
+    
+    # Save the formatted map for future reference
+    truth_path = os.path.join(TEST_STATES_DIR, "upstairs_map_truth.txt")
+    with open(truth_path, 'w') as f:
+        f.write(formatted_map)
+    
+    print(f"\nMap data saved to {truth_path}")
+    # print("=== END UPSTAIRS STATE DEBUG INFO ===\n")
+
+def test_map_reading_area_transitions(emulator):
+    """Test that map reading handles area transitions and new saves correctly"""
+    # Test 1: Load upstairs state and verify map reading
+    state_path = os.path.join(TEST_STATES_DIR, "upstairs.state")
+    emulator.load_state(state_path)
+    
+    # Force invalidate map cache to simulate area transition
+    emulator.memory_reader.invalidate_map_cache()
+    
+    # Try to read map - should work correctly
+    map_data = emulator.memory_reader.read_map_around_player(radius=7)
+    
+    # Verify map data is valid
+    assert map_data is not None, "Map data should not be None after cache invalidation"
+    assert len(map_data) > 0, "Map data should not be empty after cache invalidation"
+    assert len(map_data) == 15, "Map height should be 15 after cache invalidation"
+    assert len(map_data[0]) == 15, "Map width should be 15 after cache invalidation"
+    
+    # Test 2: Load house state and verify map reading
+    state_path = os.path.join(TEST_STATES_DIR, "house.state")
+    emulator.load_state(state_path)
+    
+    # Map cache should be automatically invalidated by load_state
+    map_data = emulator.memory_reader.read_map_around_player(radius=7)
+    
+    # Verify map data is valid
+    assert map_data is not None, "Map data should not be None after loading house state"
+    assert len(map_data) > 0, "Map data should not be empty after loading house state"
+    assert len(map_data) == 15, "Map height should be 15 after loading house state"
+    assert len(map_data[0]) == 15, "Map width should be 15 after loading house state"
+    
+    # Test 3: Load truck state and verify map reading
+    state_path = os.path.join(TEST_STATES_DIR, "truck.state")
+    emulator.load_state(state_path)
+    
+    map_data = emulator.memory_reader.read_map_around_player(radius=7)
+    
+    # Verify map data is valid
+    assert map_data is not None, "Map data should not be None after loading truck state"
+    assert len(map_data) > 0, "Map data should not be empty after loading truck state"
+    assert len(map_data) == 15, "Map height should be 15 after loading truck state"
+    assert len(map_data[0]) == 15, "Map width should be 15 after loading truck state"
+    
+    print("✅ All area transition tests passed - map reading handles transitions correctly")
+
+def test_simple_test_state_map_reading(emulator):
+    """Test map reading functionality in the simple_test state (rival's bedroom)"""
+    # Load the simple_test state
+    state_path = os.path.join(TEST_STATES_DIR, "simple_test.state")
+    emulator.load_state(state_path)
+    
+    # Get map data around player using the same function as the agent
+    map_data = emulator.memory_reader.read_map_around_player(radius=7)
+    
+    # Format the map data
+    formatted_map = print_map_data(map_data, "Simple Test State Map")
+    
+    # Basic structure tests
+    assert map_data is not None, "Map data should not be None"
+    assert isinstance(map_data, list), "Map data should be a list"
+    assert len(map_data) > 0, "Map data should not be empty"
+    assert isinstance(map_data[0], list), "Map data should be a 2D list"
+    
+    # Test map dimensions
+    height = len(map_data)
+    width = len(map_data[0])
+    assert height == 15, f"Map height should be 15 (2*radius + 1), got {height}"
+    assert width == 15, f"Map width should be 15 (2*radius + 1), got {width}"
+    
+    # Test tile data structure
+    center_tile = map_data[7][7]  # Center tile where player is
+    assert isinstance(center_tile, tuple), "Tile data should be a tuple"
+    assert len(center_tile) == 4, "Tile data should contain metatile ID, behavior, x, and y coordinates"
+    
+    # Print detailed information for debugging
+    # print(f"\n=== SIMPLE TEST STATE DEBUG INFO ===")
+    print(f"Map dimensions: {width}x{height}")
+    print(f"Center tile: {center_tile}")
+    print(f"Center behavior: {center_tile[1]}")
+    
+    # Check map buffer addresses
+    print(f"\nMap buffer info:")
+    print(f"Map buffer address: 0x{emulator.memory_reader._map_buffer_addr:08X}")
+    print(f"Map width: {emulator.memory_reader._map_width}")
+    print(f"Map height: {emulator.memory_reader._map_height}")
+    
+    # Check player coordinates
+    player_coords = emulator.memory_reader.read_coordinates()
+    print(f"Player coordinates: {player_coords}")
+    
+    # Check if behaviors are being loaded correctly
+    all_behaviors = emulator.memory_reader.get_all_metatile_behaviors()
+    print(f"Total behaviors loaded: {len(all_behaviors) if all_behaviors else 0}")
+    
+    # Check specific tiles around the player
+    print(f"\nTile analysis around player (center):")
+    for dy in range(-2, 3):
+        for dx in range(-2, 3):
+            y = 7 + dy
+            x = 7 + dx
+            if 0 <= y < len(map_data) and 0 <= x < len(map_data[0]):
+                tile = map_data[y][x]
+                if len(tile) >= 4:
+                    metatile_id, behavior, collision, elevation = tile
+                    symbol = "P" if dy == 0 and dx == 0 else f"{metatile_id:03X}"
+                    print(f"  ({dx:+2d},{dy:+2d}): {symbol} {behavior.name} c{collision} e{elevation}")
+    
+    # Count different tile types
+    indoor_tiles = 0
+    door_tiles = 0
+    wall_tiles = 0
+    impassable_tiles = 0
+    normal_tiles = 0
+    decoration_tiles = 0
+    
+    for y, row in enumerate(map_data):
+        for x, tile in enumerate(row):
+            if len(tile) >= 2:
+                metatile_id, behavior, collision, elevation = tile
+                
+                # Count different tile types
+                if behavior == MetatileBehavior.INDOOR_ENCOUNTER:
+                    indoor_tiles += 1
+                elif behavior in [MetatileBehavior.NON_ANIMATED_DOOR, MetatileBehavior.ANIMATED_DOOR]:
+                    door_tiles += 1
+                elif behavior == MetatileBehavior.NORMAL:
+                    if collision > 0:
+                        wall_tiles += 1
+                    else:
+                        normal_tiles += 1
+                elif "DECORATION" in behavior.name or "HOLDS" in behavior.name:
+                    decoration_tiles += 1
+                else:
+                    # Check if this is an impassable tile
+                    if metatile_id == 0 or behavior.value == 0:
+                        impassable_tiles += 1
+    
+    print(f"\nTile counts:")
+    print(f"Indoor tiles found: {indoor_tiles}")
+    print(f"Door tiles found: {door_tiles}")
+    print(f"Wall tiles found: {wall_tiles}")
+    print(f"Normal walkable tiles found: {normal_tiles}")
+    print(f"Decoration tiles found: {decoration_tiles}")
+    print(f"Impassable tiles found: {impassable_tiles}")
+    
+    # Check if we have too many impassable tiles (might indicate map reading issues)
+    total_tiles = width * height
+    impassable_ratio = impassable_tiles / total_tiles
+    print(f"Impassable tile ratio: {impassable_ratio:.2%}")
+    
+    # If more than 50% of tiles are impassable, there might be an issue
+    if impassable_ratio > 0.5:
+        print("WARNING: High ratio of impassable tiles detected. This might indicate map reading issues.")
+        
+        # Try to force re-find map buffer addresses
+        print("Attempting to force re-find map buffer addresses...")
+        emulator.memory_reader.invalidate_map_cache()
+        if emulator.memory_reader._find_map_buffer_addresses():
+            print("Successfully re-found map buffer addresses")
+            # Try reading map again
+            new_map_data = emulator.memory_reader.read_map_around_player(radius=7)
+            if new_map_data and len(new_map_data) > 0:
+                print("Map reading improved after cache invalidation")
+                formatted_map = print_map_data(new_map_data, "Simple Test State Map (After Cache Invalidation)")
+    
+    # Save the formatted map for future reference
+    truth_path = os.path.join(TEST_STATES_DIR, "simple_test_map_truth.txt")
+    with open(truth_path, 'w') as f:
+        f.write(formatted_map)
+    
+    print(f"\nMap data saved to {truth_path}")
+    # print("=== END SIMPLE TEST STATE DEBUG INFO ===\n")
+    
+    # Simple test state is actually outdoors in tall grass, so it should have outdoor characteristics
+    assert normal_tiles > 0 or wall_tiles > 0, "Simple test state should have normal walkable tiles or walls"