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_direct_agent_emulator.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""
+Test agent and emulator running directly without separate server process
+"""
+
+import pytest
+import os
+import time
+from pathlib import Path
+from pokemon_env.emulator import EmeraldEmulator
+
+
+class TestDirectAgentEmulator:
+    """Test agent functionality by running emulator directly"""
+    
+    @pytest.fixture(scope="class")
+    def output_dir(self):
+        """Create output directory for test results"""
+        output_path = Path("test_outputs/direct_agent_maps")
+        output_path.mkdir(parents=True, exist_ok=True)
+        return output_path
+    
+    def format_map_for_comparison(self, tiles, title, location, position):
+        """Format map tiles for comparison"""
+        if not tiles:
+            return f"=== {title} ===\nNo tiles available\n"
+        
+        output = []
+        output.append(f"=== {title} ===")
+        output.append(f"Format: (MetatileID, Behavior, X, Y)")
+        output.append(f"Map dimensions: {len(tiles)}x{len(tiles[0]) if tiles else 0}")
+        output.append("")
+        output.append("--- TRAVERSABILITY MAP ---")
+        
+        # Header with column numbers
+        header = "      " + "  ".join(f"{i:2}" for i in range(len(tiles[0]) if tiles else 0))
+        output.append(header)
+        output.append("    " + "-" * (len(header) - 4))
+        
+        # Map rows
+        for row_idx, row in enumerate(tiles):
+            traversability_row = []
+            for col_idx, tile in enumerate(row):
+                if len(tile) >= 4:
+                    tile_id, behavior, collision, elevation = tile
+                    behavior_val = behavior if not hasattr(behavior, 'value') else behavior.value
+                    
+                    # Convert to traversability symbol
+                    if behavior_val == 0:  # NORMAL
+                        symbol = "." if collision == 0 else "#"
+                    elif behavior_val == 1:  # SECRET_BASE_WALL
+                        symbol = "#"
+                    elif behavior_val == 51:  # IMPASSABLE_SOUTH
+                        symbol = "IM"
+                    elif behavior_val == 96:  # NON_ANIMATED_DOOR
+                        symbol = "D"
+                    elif behavior_val == 101:  # SOUTH_ARROW_WARP
+                        symbol = "SO"
+                    elif behavior_val == 105:  # ANIMATED_DOOR
+                        symbol = "D"
+                    elif behavior_val == 134:  # TELEVISION
+                        symbol = "TE"
+                    else:
+                        symbol = "."  # Default to walkable for other behaviors
+                    
+                    # Mark player position
+                    if position and len(position) >= 2:
+                        # Player is at center of 15x15 map (position 7,7)
+                        if row_idx == 7 and col_idx == 7:
+                            symbol = "P"
+                    
+                    traversability_row.append(symbol)
+                else:
+                    traversability_row.append("?")
+            
+            # Format row with row number
+            row_str = f"{row_idx:2}: " + " ".join(f"{symbol:1}" for symbol in traversability_row)
+            output.append(row_str)
+        
+        return "\n".join(output)
+    
+    def save_map_output(self, tiles, output_file, title, location, position):
+        """Save map output to file"""
+        formatted_output = self.format_map_for_comparison(tiles, title, location, position)
+        
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+        with open(output_file, 'w') as f:
+            f.write(formatted_output)
+        
+        return formatted_output
+    
+    def test_direct_emulator_house_to_outside(self, output_dir):
+        """Test direct emulator movement from house to outside"""
+        print("🏠➡️🌳 DIRECT EMULATOR: House to Outside Movement Test")
+        
+        # Initialize emulator directly
+        rom_path = "Emerald-GBAdvance/rom.gba"
+        if not os.path.exists(rom_path):
+            pytest.skip(f"ROM not found at {rom_path}")
+        
+        emulator = EmeraldEmulator(rom_path=rom_path, headless=True, sound=False)
+        emulator.initialize()
+        emulator.load_state('tests/states/house.state')
+        
+        try:
+            # Get initial house map
+            print("\n1️⃣ Getting initial house map...")
+            house_state = emulator.get_comprehensive_state()
+            house_location = house_state['player']['location']
+            house_position = (house_state['player']['position']['x'], house_state['player']['position']['y'])
+            house_tiles = house_state['map']['tiles']
+            
+            print(f"House state: {house_location} at {house_position}")
+            
+            # Save house map
+            house_output_file = output_dir / "direct_emulator_house.txt"
+            house_content = self.save_map_output(
+                house_tiles, house_output_file,
+                f"Direct Emulator House - {house_location}", house_location, house_position
+            )
+            
+            # Analyze house map
+            house_corruption = self.analyze_map_corruption(house_tiles)
+            print(f"House map: {house_corruption['total']} tiles, {house_corruption['im_count']} IM tiles")
+            
+            # Move to outside area
+            print("\n2️⃣ Moving to outside area...")
+            moves_made = 0
+            max_moves = 8
+            
+            for move_num in range(max_moves):
+                print(f"Move {move_num + 1}: Pressing DOWN")
+                emulator.press_buttons(['down'], hold_frames=25, release_frames=25)
+                time.sleep(0.1)  # Small delay for transition
+                moves_made += 1
+                
+                # Check if we've left the house
+                current_state = emulator.get_comprehensive_state()
+                current_location = current_state['player']['location']
+                current_position = (current_state['player']['position']['x'], current_state['player']['position']['y'])
+                
+                print(f"  Position: {current_position}, Location: {current_location}")
+                
+                if "HOUSE" not in current_location:
+                    print(f"✅ Reached outside area after {moves_made} moves!")
+                    break
+            else:
+                print(f"❌ Still in house after {max_moves} moves")
+            
+            # Wait for any transition effects to complete
+            time.sleep(0.5)
+            
+            # Get final outside map
+            print("\n3️⃣ Getting final outside map...")
+            outside_state = emulator.get_comprehensive_state()
+            outside_location = outside_state['player']['location']
+            outside_position = (outside_state['player']['position']['x'], outside_state['player']['position']['y'])
+            outside_tiles = outside_state['map']['tiles']
+            
+            print(f"Outside state: {outside_location} at {outside_position}")
+            
+            # Save outside map
+            outside_output_file = output_dir / "direct_emulator_outside.txt"
+            outside_content = self.save_map_output(
+                outside_tiles, outside_output_file,
+                f"Direct Emulator Outside - {outside_location}", outside_location, outside_position
+            )
+            
+            # Analyze outside map
+            outside_corruption = self.analyze_map_corruption(outside_tiles)
+            print(f"Outside map: {outside_corruption['total']} tiles, {outside_corruption['im_count']} IM tiles")
+            
+            print(f"\n4️⃣ Map Analysis:")
+            print(f"House map saved to: {house_output_file}")
+            print(f"Outside map saved to: {outside_output_file}")
+            
+            # Test assertions
+            assert house_tiles is not None, "House map should exist"
+            assert outside_tiles is not None, "Outside map should exist"
+            assert len(house_tiles) == 15, "House map should be 15x15"
+            assert len(outside_tiles) == 15, "Outside map should be 15x15"
+            
+            # Check that we actually moved to outside area
+            assert "HOUSE" not in outside_location, f"Should be outside, but location is: {outside_location}"
+            
+            # Check for reasonable corruption levels
+            if outside_corruption['im_count'] > 50:
+                print(f"⚠️  WARNING: High corruption in outside map ({outside_corruption['im_count']} IM tiles)")
+                print("This indicates area transition detection may not be working properly")
+            else:
+                print(f"✅ Outside map looks clean ({outside_corruption['im_count']} IM tiles is acceptable)")
+            
+            print("✅ DIRECT EMULATOR TEST PASSED!")
+            
+        finally:
+            emulator.stop()
+    
+    def analyze_map_corruption(self, tiles):
+        """Analyze map for corruption (IM tiles)"""
+        if not tiles:
+            return {'total': 0, 'im_count': 0, 'corruption_ratio': 0.0}
+        
+        total_tiles = sum(len(row) for row in tiles)
+        im_count = 0
+        behavior_distribution = {}
+        
+        for row in tiles:
+            for tile in row:
+                if len(tile) >= 2:
+                    behavior = tile[1].value if hasattr(tile[1], 'value') else tile[1]
+                    behavior_distribution[behavior] = behavior_distribution.get(behavior, 0) + 1
+                    
+                    if behavior == 51:  # IMPASSABLE_SOUTH
+                        im_count += 1
+        
+        corruption_ratio = im_count / total_tiles if total_tiles > 0 else 0.0
+        
+        return {
+            'total': total_tiles,
+            'im_count': im_count,
+            'corruption_ratio': corruption_ratio,
+            'behavior_distribution': behavior_distribution
+        }
+    
+    def test_direct_agent_simulation(self, output_dir):
+        """Test simulating agent decision-making with direct emulator access"""
+        print("🤖 DIRECT AGENT SIMULATION: Testing agent-like behavior")
+        
+        rom_path = "Emerald-GBAdvance/rom.gba"
+        if not os.path.exists(rom_path):
+            pytest.skip(f"ROM not found at {rom_path}")
+        
+        emulator = EmeraldEmulator(rom_path=rom_path, headless=True, sound=False)
+        emulator.initialize()
+        emulator.load_state('tests/states/house.state')
+        
+        try:
+            print("\n🎯 Goal: Navigate from house to outside using agent-like logic")
+            
+            steps = 0
+            max_steps = 10
+            
+            while steps < max_steps:
+                # Get current state (like agent perception)
+                current_state = emulator.get_comprehensive_state()
+                location = current_state['player']['location']
+                position = (current_state['player']['position']['x'], current_state['player']['position']['y'])
+                
+                print(f"\nStep {steps + 1}: {location} at {position}")
+                
+                # Simple agent logic: if in house, move down
+                if "HOUSE" in location:
+                    print("  🤖 Agent decision: In house, moving DOWN")
+                    emulator.press_buttons(['down'], hold_frames=25, release_frames=25)
+                    time.sleep(0.1)
+                else:
+                    print("  🎉 Agent goal achieved: Reached outside area!")
+                    break
+                
+                steps += 1
+            
+            # Get final state for analysis
+            final_state = emulator.get_comprehensive_state()
+            final_location = final_state['player']['location']
+            final_position = (final_state['player']['position']['x'], final_state['player']['position']['y'])
+            final_tiles = final_state['map']['tiles']
+            
+            print(f"\n📊 Final Result:")
+            print(f"Location: {final_location}")
+            print(f"Position: {final_position}")
+            print(f"Steps taken: {steps}")
+            
+            # Save agent simulation result
+            agent_output_file = output_dir / "direct_agent_simulation.txt"
+            self.save_map_output(
+                final_tiles, agent_output_file,
+                f"Direct Agent Simulation - {final_location}", final_location, final_position
+            )
+            
+            corruption = self.analyze_map_corruption(final_tiles)
+            print(f"Map quality: {corruption['total']} tiles, {corruption['im_count']} IM tiles")
+            print(f"Agent simulation saved to: {agent_output_file}")
+            
+            # Test passed if agent successfully navigated
+            success = "HOUSE" not in final_location
+            if success:
+                print("✅ AGENT SIMULATION SUCCESSFUL!")
+            else:
+                print("❌ Agent failed to navigate out of house")
+            
+            assert steps < max_steps, "Agent should complete navigation within step limit"
+            
+        finally:
+            emulator.stop()
+
+
+if __name__ == "__main__":
+    # Allow running as script for manual testing
+    import sys
+    sys.exit(pytest.main([__file__, "-v", "-s"]))

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

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""
+Pytest version of FPS adjustment system test for Pokemon Emerald emulator
+
+This test verifies that the FPS adjustment system correctly:
+1. Runs at 30 FPS in normal overworld state
+2. Speeds up to 120 FPS (4x) when dialog is detected
+3. Reverts to 30 FPS when dialog ends
+
+Test States:
+- Base overworld: Emerald-GBAdvance/simple_test.state (expected: 30 FPS)
+- Dialog state: server/dialog.state (expected: 120 FPS)  
+- Dialog state 2: server/dialog2.state (expected: 120 FPS)
+- After dialog: server/after_dialog.state (expected: 30 FPS)
+"""
+
+import pytest
+import subprocess
+import time
+import requests
+import os
+import sys
+
+# Test data
+TEST_CASES = [
+    {
+        "state_file": "tests/states/simple_test.state",
+        "expected_fps": 30,
+        "test_name": "Base Overworld State"
+    },
+    {
+        "state_file": "tests/states/dialog.state", 
+        "expected_fps": 120,
+        "test_name": "Dialog State"
+    },
+    {
+        "state_file": "tests/states/dialog2.state",
+        "expected_fps": 120,
+        "test_name": "Dialog State 2"
+    },
+    {
+        "state_file": "tests/states/after_dialog.state",
+        "expected_fps": 30,
+        "test_name": "After Dialog Ends"
+    }
+]
+
+class ServerManager:
+    """Manages server startup and shutdown for tests"""
+    
+    def __init__(self):
+        self.server_process = None
+    
+    def start_server(self, state_file):
+        """Start the server with a specific state file"""
+        print(f"🚀 Starting server with state: {state_file}")
+        cmd = ["python", "-m", "server.app", "--manual", "--load-state", state_file]
+        
+        try:
+            self.server_process = subprocess.Popen(
+                cmd, 
+                stdout=subprocess.PIPE, 
+                stderr=subprocess.PIPE
+            )
+            
+            # Wait for server to start
+            print("⏳ Waiting for server to start...")
+            time.sleep(5)
+            
+            # Test if server is responding
+            response = requests.get("http://localhost:8000/status", timeout=5)
+            if response.status_code == 200:
+                print("✅ Server started successfully")
+                return True
+            else:
+                print(f"❌ Server not responding: {response.status_code}")
+                return False
+                
+        except Exception as e:
+            print(f"❌ Failed to start server: {e}")
+            return False
+    
+    def stop_server(self):
+        """Stop the server cleanly"""
+        if self.server_process:
+            print("🛑 Stopping server...")
+            try:
+                # Try graceful shutdown first
+                requests.post("http://localhost:8000/stop", timeout=2)
+                time.sleep(1)
+            except:
+                pass
+            
+            # Force terminate if still running
+            try:
+                self.server_process.terminate()
+                self.server_process.wait(timeout=5)
+                print("✅ Server stopped gracefully")
+            except subprocess.TimeoutExpired:
+                print("⚠️  Server didn't stop gracefully, force killing...")
+                self.server_process.kill()
+                self.server_process.wait()
+                print("✅ Server force killed")
+
+def check_fps(expected_fps, test_name):
+    """Check if the current FPS matches the expected value"""
+    try:
+        response = requests.get("http://localhost:8000/status", timeout=5)
+        if response.status_code != 200:
+            print(f"❌ Server not responding: {response.status_code}")
+            return False
+        
+        status = response.json()
+        base_fps = status.get('base_fps')
+        current_fps = status.get('current_fps')
+        is_dialog = status.get('is_dialog')
+        fps_multiplier = status.get('fps_multiplier')
+        
+        print(f"   Base FPS: {base_fps}")
+        print(f"   Current FPS: {current_fps}")
+        print(f"   Is Dialog: {is_dialog}")
+        print(f"   FPS Multiplier: {fps_multiplier}")
+        
+        if current_fps == expected_fps:
+            print(f"✅ {test_name}: {current_fps} FPS (expected: {expected_fps}) - PASS")
+            return True
+        else:
+            print(f"❌ {test_name}: {current_fps} FPS (expected: {expected_fps}) - FAIL")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error checking FPS: {e}")
+        return False
+
+@pytest.fixture(scope="session", autouse=True)
+def check_environment():
+    """Check that we're in the right environment before running tests"""
+    # Check if we're in the right directory
+    if not os.path.exists("server/app.py"):
+        pytest.fail("❌ Error: This test must be run from the project root directory")
+    
+    # Check if state files exist
+    required_files = [
+        "tests/states/simple_test.state",
+        "tests/states/dialog.state", 
+        "tests/states/dialog2.state",
+        "tests/states/after_dialog.state"
+    ]
+    
+    missing_files = [f for f in required_files if not os.path.exists(f)]
+    if missing_files:
+        pytest.fail(f"❌ Error: Missing required state files: {missing_files}")
+
+@pytest.mark.parametrize("test_case", TEST_CASES)
+def test_fps_adjustment(test_case):
+    """Test FPS adjustment for a specific state"""
+    state_file = test_case["state_file"]
+    expected_fps = test_case["expected_fps"]
+    test_name = test_case["test_name"]
+    
+    print(f"\n🎮 Testing {test_name}")
+    print("=" * 50)
+    print(f"State file: {state_file}")
+    print(f"Expected FPS: {expected_fps}")
+    
+    # Check if state file exists
+    if not os.path.exists(state_file):
+        pytest.fail(f"❌ State file not found: {state_file}")
+    
+    # Start server
+    server = ServerManager()
+    if not server.start_server(state_file):
+        pytest.fail("Failed to start server")
+    
+    try:
+        # For after_dialog state, wait for the 5-second timeout to expire
+        if "after_dialog" in state_file:
+            print("⏳ Waiting 6 seconds for dialog FPS timeout to expire...")
+            time.sleep(6)
+        
+        # Check FPS
+        result = check_fps(expected_fps, test_name)
+        
+        # Assert the result
+        assert result, f"FPS check failed for {test_name}"
+        
+    finally:
+        # Stop server
+        server.stop_server()
+        
+        # Wait between tests
+        time.sleep(2)
+
+def test_fps_adjustment_summary():
+    """Test summary - this will run after all individual tests"""
+    print("\n📋 FPS Adjustment System Test Summary")
+    print("=" * 50)
+    print("This test verifies the FPS adjustment system:")
+    print("1. Base overworld state: 30 FPS")
+    print("2. Dialog state: 120 FPS (4x speedup)")
+    print("3. Dialog state 2: 120 FPS (4x speedup) - Currently failing, needs investigation")
+    print("4. After dialog ends: 30 FPS (reverted)")
+    print()
+    print("🎉 All individual FPS tests completed!")
+    print("Note: Dialog State 2 is expected to fail until the dialog detection is improved")