synth-ai 0.2.13.dev1__py3-none-any.whl → 0.2.13.dev2__py3-none-any.whl

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

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+Direct pytest for house to outside transition using emulator directly
+This bypasses server issues and tests the core map reading functionality
+"""
+
+import pytest
+import time
+from pathlib import Path
+from pokemon_env.emulator import EmeraldEmulator
+from tests.test_memory_map import format_map_data
+
+class TestHouseToOutsideDirectTransition:
+    
+    @pytest.fixture
+    def emulator(self):
+        """Create and initialize emulator"""
+        project_root = Path.cwd()
+        rom_path = str(project_root / "Emerald-GBAdvance" / "rom.gba")
+        
+        emu = EmeraldEmulator(rom_path, headless=True, sound=False)
+        emu.initialize()
+        
+        yield emu
+        
+        emu.stop()
+    
+    def test_house_map_baseline(self, emulator):
+        """Test that house map reads correctly as baseline"""
+        print("\n📍 Testing house map baseline...")
+        
+        # Load house state
+        emulator.load_state("tests/states/house.state")
+        
+        # Read initial map
+        map_data = emulator.memory_reader.read_map_around_player(radius=7)
+        assert map_data, "House map data should not be empty"
+        
+        location = emulator.memory_reader.read_location()
+        position = emulator.memory_reader.read_coordinates()
+        
+        print(f"   Location: {location}")
+        print(f"   Position: {position}")
+        print(f"   Map size: {len(map_data)}x{len(map_data[0])}")
+        
+        # Validate house map
+        validation = self._validate_map_structure(map_data, location, "house")
+        assert validation['is_valid'], f"House map validation failed: {validation['message']}"
+        
+        # Show house map
+        formatted_map = format_map_data(map_data, f"House Baseline - {location}")
+        print(f"   House map:\n{formatted_map}")
+    
+    def test_walk_and_map_transition(self, emulator):
+        """Test walking outside and check if map transitions work"""
+        print("\n🚶 Testing walk outside and map transition...")
+        
+        # Load house state
+        emulator.load_state("tests/states/house.state")
+        
+        # Get initial state
+        initial_location = emulator.memory_reader.read_location()
+        initial_position = emulator.memory_reader.read_coordinates()
+        
+        print(f"   Initial: {initial_location} at {initial_position}")
+        
+        # First, look at the house map to find the door
+        house_map = emulator.memory_reader.read_map_around_player(radius=7)
+        self._analyze_map_for_exits(house_map, initial_position)
+        
+        # Try different movement patterns to find the exit
+        movements = [
+            ("DOWN", [('down', 10)]),
+        ]
+        
+        for movement_name, button_sequence in movements:
+            print(f"\n   Trying movement pattern: {movement_name}")
+            
+            # Reload state for fresh attempt
+            emulator.load_state("tests/states/house.state")
+            
+            # Execute button sequence
+            for button, count in button_sequence:
+                for i in range(count):
+                    emulator.press_buttons([button], hold_frames=15, release_frames=15)
+                    time.sleep(0.1)
+            
+            # Check result
+            new_location = emulator.memory_reader.read_location()
+            new_position = emulator.memory_reader.read_coordinates()
+            
+            print(f"      Result: {new_location} at {new_position}")
+            
+            # If we successfully exited the house, test the map
+            if 'HOUSE' not in new_location.upper():
+                print(f"   ✅ Successfully exited house with pattern: {movement_name}")
+                return self._test_outside_map(emulator, new_location, new_position)
+        
+        # If no pattern worked, show debugging info
+        print(f"   ❌ Could not exit house with any movement pattern")
+        final_map = emulator.memory_reader.read_map_around_player(radius=7)
+        formatted_map = format_map_data(final_map, "Final House Map")
+        print(f"   Final map:\n{formatted_map}")
+        
+        pytest.fail("Could not exit house to test outside map transition")
+    
+    def _test_outside_map(self, emulator, location, position):
+        """Test the outside map after successful transition"""
+        print(f"\n🗺️  Testing outside map: {location} at {position}")
+        
+        # Read outside map
+        outside_map = emulator.memory_reader.read_map_around_player(radius=7)
+        
+        if not outside_map:
+            print("   ❌ Outside map is empty - this is the bug!")
+            return False
+        
+        # Validate outside map
+        validation = self._validate_map_structure(outside_map, location, "outside")
+        
+        # Show outside map regardless of validation
+        formatted_map = format_map_data(outside_map, f"Outside Map - {location}")
+        print(f"   Outside map:\n{formatted_map}")
+        
+        if validation['is_valid']:
+            print(f"   ✅ Outside map validation passed: {validation['message']}")
+            return True
+        else:
+            print(f"   ❌ Outside map validation failed: {validation['message']}")
+            print("   This confirms the transition bug!")
+            return False
+    
+    def _analyze_map_for_exits(self, map_data, player_pos):
+        """Analyze house map to find potential exits"""
+        print(f"   Analyzing house map for exits around player at {player_pos}...")
+        
+        center_y = len(map_data) // 2
+        center_x = len(map_data[0]) // 2
+        
+        # Check tiles around player for doors or exits
+        for dy in range(-1, 2):
+            for dx in range(-1, 2):
+                y = center_y + dy
+                x = center_x + dx
+                
+                if 0 <= y < len(map_data) and 0 <= x < len(map_data[0]):
+                    tile = map_data[y][x]
+                    if len(tile) >= 4:
+                        tile_id, behavior, collision, elevation = tile
+                        behavior_name = behavior.name if hasattr(behavior, 'name') else f"Raw({behavior})"
+                        
+                        if dy == 0 and dx == 0:
+                            print(f"      Player: {behavior_name} (collision={collision})")
+                        elif "DOOR" in behavior_name:
+                            print(f"      Door found at ({dx:+2d},{dy:+2d}): {behavior_name}")
+                        elif collision == 0:
+                            print(f"      Walkable at ({dx:+2d},{dy:+2d}): {behavior_name}")
+    
+    def _validate_map_structure(self, map_data, location_name, area_type):
+        """Validate map structure"""
+        if not map_data or len(map_data) == 0:
+            return {"is_valid": False, "message": "Empty map data"}
+        
+        total_tiles = sum(len(row) for row in map_data)
+        unknown_tiles = 0
+        valid_tiles = 0
+        
+        for row in map_data:
+            for tile in row:
+                if len(tile) >= 2:
+                    behavior = tile[1]
+                    if hasattr(behavior, 'name'):
+                        behavior_name = behavior.name
+                    elif isinstance(behavior, int):
+                        try:
+                            from pokemon_env.enums import MetatileBehavior
+                            behavior_enum = MetatileBehavior(behavior)
+                            behavior_name = behavior_enum.name
+                        except ValueError:
+                            behavior_name = "UNKNOWN"
+                    else:
+                        behavior_name = "UNKNOWN"
+                    
+                    if behavior_name == "UNKNOWN":
+                        unknown_tiles += 1
+                    else:
+                        valid_tiles += 1
+        
+        unknown_ratio = unknown_tiles / total_tiles if total_tiles > 0 else 0
+        
+        if unknown_ratio > 0.5:
+            return {"is_valid": False, "message": f"Too many unknown tiles: {unknown_ratio:.1%}"}
+        
+        return {
+            "is_valid": True, 
+            "message": f"Structure valid: {valid_tiles}/{total_tiles} valid tiles ({unknown_ratio:.1%} unknown)"
+        }
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "-s"])

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

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+"""
+Pytest for the house to outside transition bug
+This test reproduces the specific issue where transitioning from house.state 
+to outside results in incorrect map data
+"""
+
+import pytest
+import requests
+import time
+import threading
+import subprocess
+import os
+from pathlib import Path
+
+from tests.test_memory_map import format_map_data, MetatileBehavior
+
+# Test configuration
+SERVER_PORT = 8002  # Use different port to avoid conflicts
+SERVER_URL = f"http://127.0.0.1:{SERVER_PORT}"
+
+class TestHouseToOutsideTransition:
+    
+    @classmethod
+    def setup_class(cls):
+        """Start server with house.state before running tests"""
+        print(f"\n🚀 Starting server on port {SERVER_PORT} with house.state...")
+        
+        # Start server in background
+        project_root = Path.cwd()
+        server_cmd = [
+            "python", "-m", "server.app", 
+            "--load-state", "tests/states/house.state",
+            "--port", str(SERVER_PORT),
+            "--manual"
+        ]
+        
+        cls.server_process = subprocess.Popen(
+            server_cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env={**os.environ, "CONDA_DEFAULT_ENV": "mgba"}
+        )
+        
+        # Wait for server to start
+        max_wait = 30
+        for i in range(max_wait):
+            try:
+                response = requests.get(f"{SERVER_URL}/status", timeout=1)
+                if response.status_code == 200:
+                    print(f"✅ Server started successfully after {i+1} seconds")
+                    break
+            except requests.exceptions.RequestException:
+                if i < max_wait - 1:
+                    time.sleep(1)
+                    continue
+                else:
+                    # Kill process if it started but isn't responding
+                    cls.server_process.terminate()
+                    cls.server_process.wait()
+                    raise Exception(f"Server failed to start within {max_wait} seconds")
+    
+    @classmethod
+    def teardown_class(cls):
+        """Stop server after all tests"""
+        print("\n🛑 Stopping server...")
+        if hasattr(cls, 'server_process'):
+            cls.server_process.terminate()
+            cls.server_process.wait()
+        print("✅ Server stopped")
+    
+    def test_initial_house_map(self):
+        """Test that the initial house map matches the expected ground truth"""
+        print("\n📍 Testing initial house map...")
+        
+        # Get state from server
+        response = requests.get(f"{SERVER_URL}/state", timeout=5)
+        assert response.status_code == 200, "Failed to get server state"
+        
+        state_data = response.json()
+        
+        # Verify location
+        location = state_data.get('player', {}).get('location', '')
+        assert 'BRENDANS HOUSE 1F' in location.upper(), f"Expected house location, got: {location}"
+        
+        # Get map tiles
+        assert 'map' in state_data, "No map data in state"
+        assert 'tiles' in state_data['map'], "No tiles in map data"
+        
+        map_tiles = state_data['map']['tiles']
+        assert len(map_tiles) > 0, "Map tiles are empty"
+        
+        # Format map data (convert from server format to test format)
+        formatted_map = self._format_server_map_data(map_tiles, f"House Map - {location}")
+        
+        # Load expected ground truth
+        truth_path = Path("tests/states/house_map_truth.txt")
+        if truth_path.exists():
+            with open(truth_path, 'r') as f:
+                expected_map = f.read().strip()
+            
+            # Compare maps (allowing for some flexibility in coordinates/format)
+            assert self._maps_are_similar(formatted_map, expected_map), \
+                f"House map doesn't match expected format:\n\nActual:\n{formatted_map}\n\nExpected:\n{expected_map}"
+        else:
+            print(f"⚠️  Ground truth file not found at {truth_path}")
+            print(f"House map format:\n{formatted_map}")
+            # Don't fail if ground truth doesn't exist, just verify basic structure
+            assert "HOUSE" in formatted_map or "BRENDAN" in formatted_map, "Map should contain house-related content"
+    
+    def test_walk_outside_transition(self):
+        """Test walking outside from house and verify map is correct"""
+        print("\n🚶 Testing transition from house to outside...")
+        
+        # First, check initial position
+        response = requests.get(f"{SERVER_URL}/state", timeout=5)
+        initial_state = response.json()
+        initial_pos = initial_state.get('player', {}).get('position', {})
+        print(f"   Initial position: ({initial_pos.get('x', '?')}, {initial_pos.get('y', '?')})")
+        
+        # Walk down until we exit the house (up to 10 steps)
+        steps_taken = 0
+        max_steps = 10
+        
+        for i in range(max_steps):
+            print(f"   Step {i+1}: Walking DOWN...")
+            response = requests.post(f"{SERVER_URL}/action", 
+                                   json={"type": "button", "button": "down"}, 
+                                   timeout=5)
+            assert response.status_code == 200, f"Failed to send DOWN action on step {i+1}"
+            time.sleep(0.5)  # Longer delay to ensure movement completes
+            
+            # Check current location after this step
+            response = requests.get(f"{SERVER_URL}/state", timeout=5)
+            state_data = response.json()
+            location = state_data.get('player', {}).get('location', '')
+            position = state_data.get('player', {}).get('position', {})
+            
+            print(f"      After step {i+1}: {location} at ({position.get('x', '?')}, {position.get('y', '?')})")
+            
+            # Check if we've exited the house
+            if 'HOUSE' not in location.upper():
+                print(f"   ✅ Exited house after {i+1} steps!")
+                steps_taken = i + 1
+                break
+        
+        if steps_taken == 0:
+            # If we never exited, show current state for debugging
+            print(f"   ❌ Never exited house after {max_steps} steps. Current location: {location}")
+            assert False, f"Failed to exit house after {max_steps} DOWN movements"
+        
+        # Get state after transition
+        response = requests.get(f"{SERVER_URL}/state", timeout=5)
+        assert response.status_code == 200, "Failed to get server state after transition"
+        
+        state_data = response.json()
+        
+        # Verify we're now outside
+        location = state_data.get('player', {}).get('location', '')
+        assert 'LITTLEROOT TOWN' in location.upper(), f"Expected to be in Littleroot Town, got: {location}"
+        assert 'HOUSE' not in location.upper(), f"Should be outside house, but got: {location}"
+        
+        # Get map tiles
+        assert 'map' in state_data, "No map data in state after transition"
+        assert 'tiles' in state_data['map'], "No tiles in map data after transition"
+        
+        map_tiles = state_data['map']['tiles']
+        assert len(map_tiles) > 0, "Map tiles are empty after transition"
+        
+        # Validate map quality
+        validation_result = self._validate_outside_map(map_tiles, location)
+        assert validation_result['is_valid'], f"Outside map validation failed: {validation_result['message']}"
+        
+        # Format and display map for debugging
+        formatted_map = self._format_server_map_data(map_tiles, f"Outside Map - {location}")
+        print(f"\n🗺️  Outside map:\n{formatted_map}")
+        
+        print(f"✅ Map validation: {validation_result['message']}")
+    
+    def _format_server_map_data(self, server_tiles, title="Map Data"):
+        """Convert server tile format to the same format as test_memory_map.py"""
+        # Convert server format [tile_id, behavior_int, collision, elevation] 
+        # to test format (tile_id, behavior_enum, collision, elevation)
+        formatted_tiles = []
+        
+        for row in server_tiles:
+            formatted_row = []
+            for tile in row:
+                if len(tile) >= 4:
+                    tile_id, behavior_int, collision, elevation = tile
+                    
+                    # Convert behavior integer to enum for compatibility
+                    try:
+                        behavior_enum = MetatileBehavior(behavior_int)
+                    except ValueError:
+                        behavior_enum = None  # Will be handled as "UNKNOWN" in format function
+                    
+                    formatted_row.append((tile_id, behavior_enum, collision, elevation))
+                else:
+                    # Fallback for incomplete tile data
+                    formatted_row.append((0, None, 0, 0))
+            
+            formatted_tiles.append(formatted_row)
+        
+        return format_map_data(formatted_tiles, title)
+    
+    def _maps_are_similar(self, actual, expected):
+        """Check if two maps are similar (allowing for minor differences)"""
+        # For now, just check that both contain reasonable map structure
+        # Could be made more sophisticated later
+        
+        # Both should have map dimensions
+        actual_has_dimensions = "Map dimensions:" in actual
+        expected_has_dimensions = "Map dimensions:" in expected
+        
+        # Both should have traversability map
+        actual_has_traversability = "TRAVERSABILITY MAP" in actual
+        expected_has_traversability = "TRAVERSABILITY MAP" in expected
+        
+        # Both should have player position
+        actual_has_player = " P " in actual
+        expected_has_player = " P " in expected
+        
+        return (actual_has_dimensions and expected_has_dimensions and 
+                actual_has_traversability and expected_has_traversability and 
+                actual_has_player and expected_has_player)
+    
+    def _validate_outside_map(self, map_tiles, location_name):
+        """Validate that outside map looks reasonable"""
+        if not map_tiles or len(map_tiles) == 0:
+            return {"is_valid": False, "message": "Empty map data"}
+        
+        total_tiles = sum(len(row) for row in map_tiles)
+        unknown_tiles = 0
+        walkable_tiles = 0
+        wall_tiles = 0
+        special_tiles = 0
+        
+        for row in map_tiles:
+            for tile in row:
+                if len(tile) >= 4:
+                    tile_id, behavior_int, collision, elevation = tile
+                    
+                    # Convert behavior
+                    try:
+                        behavior_enum = MetatileBehavior(behavior_int)
+                        behavior_name = behavior_enum.name
+                    except ValueError:
+                        behavior_name = "UNKNOWN"
+                    
+                    if behavior_name == "UNKNOWN":
+                        unknown_tiles += 1
+                    elif behavior_name == "NORMAL":
+                        if collision == 0:
+                            walkable_tiles += 1
+                        else:
+                            wall_tiles += 1
+                    else:
+                        special_tiles += 1
+        
+        unknown_ratio = unknown_tiles / total_tiles if total_tiles > 0 else 0
+        walkable_ratio = walkable_tiles / total_tiles if total_tiles > 0 else 0
+        wall_ratio = wall_tiles / total_tiles if total_tiles > 0 else 0
+        
+        # Validation rules for outside area
+        if unknown_ratio > 0.2:
+            return {"is_valid": False, "message": f"Too many unknown tiles: {unknown_ratio:.1%}"}
+        
+        if walkable_ratio < 0.15:
+            return {"is_valid": False, "message": f"Too few walkable tiles: {walkable_ratio:.1%}"}
+        
+        if wall_ratio > 0.95:
+            return {"is_valid": False, "message": f"Too many walls: {wall_ratio:.1%}"}
+        
+        return {
+            "is_valid": True, 
+            "message": f"Map valid: {walkable_ratio:.1%} walkable, {wall_ratio:.1%} walls, {unknown_ratio:.1%} unknown"
+        }
+
+if __name__ == "__main__":
+    # Run the test directly
+    import sys
+    pytest.main([__file__, "-v", "-s"] + sys.argv[1:])