synth-ai 0.1.9__py3-none-any.whl → 0.2.1.dev0__py3-none-any.whl

synth_ai/environments/examples/red/units/test_integration.py

@@ -0,0 +1,217 @@
+import pytest
+from synth_ai.environments.examples.red.environment import PokemonRedEnvironment
+from synth_ai.environments.examples.red.taskset import INSTANCE as POKEMON_TASK
+from synth_ai.environments.environment.tools import EnvToolCall
+
+
+class TestPokemonRedIntegration:
+    """Integration tests for Pokemon Red environment with REAL ROM"""
+
+    @pytest.mark.asyncio
+    async def test_full_workflow_real(self):
+        """Test complete workflow from initialization to termination with REAL ROM"""
+        # Initialize environment with real ROM
+        env = PokemonRedEnvironment(POKEMON_TASK)
+
+        # Test initialization
+        obs = await env.initialize()
+        assert "position" in obs
+        assert "badges_earned" in obs
+        # Note: badges_earned might be 0 or could have some initial value from ROM
+        assert isinstance(obs["badges_earned"], int)
+
+        # Test series of actions
+        actions = [
+            EnvToolCall(tool="press_button", args={"button": "RIGHT", "frames": 1}),
+            EnvToolCall(tool="press_button", args={"button": "UP", "frames": 2}),
+            EnvToolCall(tool="press_button", args={"button": "A", "frames": 1}),
+        ]
+
+        for action in actions:
+            obs = await env.step(action)
+            assert "step_count" in obs
+            assert "total_reward" in obs
+            assert isinstance(obs["step_count"], int)
+            assert isinstance(obs["total_reward"], float)
+
+        # Test checkpointing
+        checkpoint_obs = await env.checkpoint()
+        assert "engine_snapshot_data" in checkpoint_obs
+
+        # Test termination
+        final_obs = await env.terminate()
+        assert final_obs["terminated"] is True
+
+    @pytest.mark.asyncio
+    async def test_button_sequence_real(self):
+        """Test sequence of different button presses with real ROM"""
+        env = PokemonRedEnvironment(POKEMON_TASK)
+        await env.initialize()
+
+        # Test all basic buttons
+        buttons = ["A", "B", "UP", "DOWN", "LEFT", "RIGHT", "START", "SELECT"]
+
+        for i, button in enumerate(buttons):
+            action = EnvToolCall(tool="press_button", args={"button": button, "frames": 1})
+            obs = await env.step(action)
+
+            assert obs["step_count"] == i + 1
+            assert "position" in obs
+            assert "badges_earned" in obs
+            assert "hp_status" in obs
+            assert "party_level" in obs
+
+    @pytest.mark.asyncio
+    async def test_multiple_frame_actions_real(self):
+        """Test actions with multiple frames using real ROM"""
+        env = PokemonRedEnvironment(POKEMON_TASK)
+        await env.initialize()
+
+        # Test holding buttons for multiple frames
+        action = EnvToolCall(tool="press_button", args={"button": "RIGHT", "frames": 5})
+        obs = await env.step(action)
+
+        assert obs["step_count"] == 1  # Should count as one step
+        assert "position" in obs
+
+        # Test another multi-frame action
+        action = EnvToolCall(tool="press_button", args={"button": "A", "frames": 3})
+        obs = await env.step(action)
+
+        assert obs["step_count"] == 2
+
+    @pytest.mark.asyncio
+    async def test_state_consistency_real(self):
+        """Test that game state remains consistent across steps with real ROM"""
+        env = PokemonRedEnvironment(POKEMON_TASK)
+
+        obs1 = await env.initialize()
+        initial_position = obs1["position"]
+        initial_badges = obs1["badges_earned"]
+        initial_hp = obs1["hp_status"]
+
+        # Take some actions
+        for _ in range(5):
+            action = EnvToolCall(tool="press_button", args={"button": "A", "frames": 1})
+            obs = await env.step(action)
+
+            # State should remain valid even if unchanged
+            assert "position" in obs
+            assert "badges_earned" in obs
+            assert "hp_status" in obs
+            assert isinstance(obs["badges_earned"], int)
+
+    @pytest.mark.asyncio
+    async def test_reward_accumulation_real(self):
+        """Test that rewards accumulate properly with real ROM"""
+        env = PokemonRedEnvironment(POKEMON_TASK)
+
+        obs = await env.initialize()
+        initial_reward = obs["total_reward"]
+
+        # Take several steps and track reward changes
+        for i in range(3):
+            action = EnvToolCall(tool="press_button", args={"button": "DOWN", "frames": 1})
+            obs = await env.step(action)
+
+            # Reward should change (likely negative step penalty)
+            assert obs["total_reward"] != initial_reward
+            assert isinstance(obs["total_reward"], float)
+            assert obs["step_count"] == i + 1
+
+    @pytest.mark.asyncio
+    async def test_checkpointing_real(self):
+        """Test checkpointing functionality with real ROM"""
+        env = PokemonRedEnvironment(POKEMON_TASK)
+
+        # Initialize and take some steps
+        await env.initialize()
+        action = EnvToolCall(tool="press_button", args={"button": "RIGHT", "frames": 1})
+        await env.step(action)
+
+        # Create checkpoint
+        checkpoint_obs = await env.checkpoint()
+
+        assert "engine_snapshot_data" in checkpoint_obs
+        snapshot = checkpoint_obs["engine_snapshot_data"]
+        assert "state_data" in snapshot
+        assert "total_reward" in snapshot
+        assert "step_count" in snapshot
+        assert isinstance(snapshot["total_reward"], float)
+        assert isinstance(snapshot["step_count"], int)
+
+    @pytest.mark.asyncio
+    async def test_invalid_button_handling_real(self):
+        """Test handling of invalid buttons with real ROM"""
+        env = PokemonRedEnvironment(POKEMON_TASK)
+        await env.initialize()
+
+        # Try invalid button
+        action = EnvToolCall(tool="press_button", args={"button": "INVALID", "frames": 1})
+
+        # Should handle gracefully and return valid observation
+        obs = await env.step(action)
+        assert "position" in obs
+        assert "step_count" in obs
+
+    @pytest.mark.asyncio
+    async def test_observation_format_real(self):
+        """Test that observations have expected format with real ROM"""
+        env = PokemonRedEnvironment(POKEMON_TASK)
+
+        obs = await env.initialize()
+
+        # Check required observation keys (based on actual observation format)
+        required_keys = [
+            "position",
+            "badges_earned",
+            "badges_bitfield",
+            "hp_status",
+            "party_level",
+            "party_xp",
+            "in_battle",
+            "step_count",
+            "reward_last_step",
+            "total_reward",
+            "terminated",
+        ]
+
+        for key in required_keys:
+            assert key in obs, f"Missing key: {key}"
+
+        # Check types
+        assert isinstance(obs["position"], str)
+        assert isinstance(obs["badges_earned"], int)
+        assert isinstance(obs["badges_bitfield"], int)
+        assert isinstance(obs["hp_status"], str)
+        assert isinstance(obs["party_level"], int)
+        assert isinstance(obs["party_xp"], int)
+        assert isinstance(obs["in_battle"], bool)
+        assert isinstance(obs["step_count"], int)
+        assert isinstance(obs["reward_last_step"], float)
+        assert isinstance(obs["total_reward"], float)
+        assert isinstance(obs["terminated"], bool)
+
+    @pytest.mark.asyncio
+    async def test_rom_memory_integration_real(self):
+        """Test that we can access and read ROM memory consistently"""
+        env = PokemonRedEnvironment(POKEMON_TASK)
+        await env.initialize()
+
+        # Should be able to access engine and emulator
+        assert env.engine is not None
+        assert env.engine.emulator is not None
+        assert hasattr(env.engine.emulator, "memory")
+
+        # Memory reads should be consistent
+        memory = env.engine.emulator.memory
+        badge_flags1 = memory[0xD356]
+        badge_flags2 = memory[0xD356]
+        assert badge_flags1 == badge_flags2  # Should be deterministic
+
+        # After taking an action, memory should still be accessible
+        action = EnvToolCall(tool="press_button", args={"button": "A", "frames": 1})
+        await env.step(action)
+
+        badge_flags3 = memory[0xD356]
+        assert isinstance(badge_flags3, int)  # Should still be valid

synth_ai/environments/examples/red/units/test_memory_extraction.py

@@ -0,0 +1,111 @@
+from synth_ai.environments.examples.red.engine_helpers.state_extraction import (
+    extract_game_state,
+    get_badge_count,
+    format_position,
+    format_hp_status,
+    get_byte,
+    get_word,
+    get_3byte_int,
+)
+from synth_ai.environments.examples.red.engine_helpers.memory_map import *
+
+
+class TestMemoryExtraction:
+    """Test memory extraction functions"""
+
+    def test_get_byte(self):
+        """Test single byte extraction"""
+        memory = bytearray([0x00, 0x42, 0xFF, 0x80])
+        assert get_byte(memory, 0) == 0x00
+        assert get_byte(memory, 1) == 0x42
+        assert get_byte(memory, 2) == 0xFF
+        assert get_byte(memory, 3) == 0x80
+
+        # Test bounds checking
+        assert get_byte(memory, 100) == 0
+
+    def test_get_word(self):
+        """Test 16-bit word extraction (little endian)"""
+        memory = bytearray([0x34, 0x12, 0xFF, 0x00])
+        assert get_word(memory, 0) == 0x1234
+        assert get_word(memory, 2) == 0x00FF
+
+    def test_get_3byte_int(self):
+        """Test 24-bit integer extraction for XP values"""
+        memory = bytearray([0x56, 0x34, 0x12, 0x00])
+        assert get_3byte_int(memory, 0) == 0x123456
+
+    def test_extract_game_state(self):
+        """Test full game state extraction"""
+        # Create mock Game Boy memory
+        memory = bytearray(0x10000)  # 64KB
+
+        # Set test values at known addresses
+        memory[MAP_ID] = 0x03  # Pewter City
+        memory[PLAYER_X] = 10  # X position
+        memory[PLAYER_Y] = 8  # Y position
+        memory[BADGE_FLAGS] = 0x01  # Boulder Badge
+        memory[IN_BATTLE_FLAG] = 0  # Not in battle
+        memory[PARTY_COUNT] = 1  # One Pokemon in party
+        memory[PARTY_LEVELS] = 12  # Level 12
+        memory[PARTY_HP_CURRENT] = 35  # Current HP (low byte)
+        memory[PARTY_HP_CURRENT + 1] = 0  # Current HP (high byte)
+        memory[PARTY_HP_MAX] = 42  # Max HP (low byte)
+        memory[PARTY_HP_MAX + 1] = 0  # Max HP (high byte)
+        memory[PARTY_XP] = 0x40  # XP (low byte)
+        memory[PARTY_XP + 1] = 0x42  # XP (mid byte)
+        memory[PARTY_XP + 2] = 0x0F  # XP (high byte)
+
+        state = extract_game_state(memory)
+
+        assert state["map_id"] == 0x03
+        assert state["player_x"] == 10
+        assert state["player_y"] == 8
+        assert state["badges"] == 0x01
+        assert state["in_battle"] == False
+        assert state["party_level"] == 12
+        assert state["party_hp_current"] == 35
+        assert state["party_hp_max"] == 42
+        assert state["party_xp"] == 0x0F4240  # 1000000 in decimal
+
+    def test_get_badge_count(self):
+        """Test badge counting from bitfield"""
+        assert get_badge_count(0x00) == 0  # No badges
+        assert get_badge_count(0x01) == 1  # Boulder Badge
+        assert get_badge_count(0x03) == 2  # Boulder + Cascade
+        assert get_badge_count(0xFF) == 8  # All badges
+        assert get_badge_count(0x55) == 4  # Every other badge
+
+    def test_format_position(self):
+        """Test position formatting"""
+        assert format_position(10, 8, 3) == "Map03:(10,8)"
+        assert format_position(0, 0, 255) == "MapFF:(0,0)"
+
+    def test_format_hp_status(self):
+        """Test HP status formatting"""
+        assert format_hp_status(35, 50) == "HP: 35/50 (70%)"
+        assert format_hp_status(0, 35) == "HP: 0/35 (0%)"
+        assert format_hp_status(35, 35) == "HP: 35/35 (100%)"
+        assert format_hp_status(10, 0) == "HP: Unknown"
+
+    def test_memory_addresses_valid(self):
+        """Test that all memory addresses are valid Game Boy addresses"""
+        addresses = [
+            BADGE_FLAGS,
+            MAP_ID,
+            PLAYER_X,
+            PLAYER_Y,
+            IN_BATTLE_FLAG,
+            BATTLE_OUTCOME,
+            PARTY_LEVELS,
+            PARTY_HP_CURRENT,
+            PARTY_HP_MAX,
+            PARTY_XP,
+            INVENTORY_COUNT,
+            INVENTORY_START,
+            MENU_STATE,
+            WARP_FLAG,
+        ]
+
+        for addr in addresses:
+            assert 0x8000 <= addr <= 0xFFFF, f"Address {hex(addr)} outside Game Boy RAM range"