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

synth_ai/environments/examples/red/engine_helpers/reward_library/pokemon_rewards.py

@@ -0,0 +1,312 @@
+"""
+Pokemon Collection & Management Reward Components
+
+Rewards for catching Pokemon, Pokedex progress, and Pokemon development.
+"""
+
+from synth_ai.environments.environment.rewards.core import RewardComponent
+from typing import Dict, Any, Set
+
+
+class FirstPokemonCaughtReward(RewardComponent):
+    """Reward for catching the starter or first wild Pokemon - +50 points"""
+
+    def __init__(self):
+        self.first_caught = False
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        if self.first_caught:
+            return 0.0
+
+        prev_party_count = len(action.get("prev_party", []))
+        current_party_count = len(state.get("party", []))
+
+        # First Pokemon acquired (starter or caught)
+        if prev_party_count == 0 and current_party_count == 1:
+            self.first_caught = True
+            return 50.0
+        return 0.0
+
+
+class NewSpeciesCaughtReward(RewardComponent):
+    """Reward for each new Pokedex entry - +20 points"""
+
+    def __init__(self):
+        self.species_caught: Set[int] = set()
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Check for new Pokemon in party
+        party = state.get("party", [])
+        total_reward = 0.0
+
+        for pokemon in party:
+            species_id = pokemon.get("species_id", 0)
+            if species_id not in self.species_caught and species_id > 0:
+                self.species_caught.add(species_id)
+                total_reward += 20.0
+
+        return total_reward
+
+
+class RarePokemonCaughtReward(RewardComponent):
+    """Reward for catching uncommon/rare Pokemon - +40 points"""
+
+    def __init__(self):
+        self.rare_pokemon_caught: Set[int] = set()
+        # Rare Pokemon species IDs (would be loaded from game data)
+        self.rare_species = {
+            144,
+            145,
+            146,  # Legendary birds
+            150,  # Mewtwo
+            149,  # Dragonite
+            130,
+            131,  # Gyarados, Lapras
+            138,
+            139,  # Omanyte, Omastar
+            140,
+            141,  # Kabuto, Kabutops
+            142,  # Aerodactyl
+        }
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        party = state.get("party", [])
+        total_reward = 0.0
+
+        for pokemon in party:
+            species_id = pokemon.get("species_id", 0)
+            if species_id in self.rare_species and species_id not in self.rare_pokemon_caught:
+                self.rare_pokemon_caught.add(species_id)
+                total_reward += 40.0
+
+        return total_reward
+
+
+class EvolutionStonePokemonReward(RewardComponent):
+    """Reward for catching Pokemon that require evolution stones - +30 points"""
+
+    def __init__(self):
+        self.evolution_stone_pokemon_caught: Set[int] = set()
+        # Pokemon that evolve with stones
+        self.evolution_stone_pokemon = {
+            25,  # Pikachu (Thunder Stone)
+            30,  # Nidorina (Moon Stone)
+            33,  # Nidorino (Moon Stone)
+            35,  # Clefairy (Moon Stone)
+            37,  # Vulpix (Fire Stone)
+            39,  # Jigglypuff (Moon Stone)
+            44,  # Gloom (Leaf Stone)
+            58,  # Growlithe (Fire Stone)
+            61,  # Poliwhirl (Water Stone)
+            90,  # Shellder (Water Stone)
+            102,  # Exeggcute (Leaf Stone)
+            108,  # Lickitung (rare)
+            120,  # Staryu (Water Stone)
+        }
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        party = state.get("party", [])
+        total_reward = 0.0
+
+        for pokemon in party:
+            species_id = pokemon.get("species_id", 0)
+            if (
+                species_id in self.evolution_stone_pokemon
+                and species_id not in self.evolution_stone_pokemon_caught
+            ):
+                self.evolution_stone_pokemon_caught.add(species_id)
+                total_reward += 30.0
+
+        return total_reward
+
+
+class PokedexMilestonesReward(RewardComponent):
+    """Reward for reaching Pokedex milestones - +100 points for 10, 25, 50, 100, 150"""
+
+    def __init__(self):
+        self.milestones_reached: Set[int] = set()
+        self.milestones = [10, 25, 50, 100, 150]
+        self.unique_species: Set[int] = set()
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Track unique species seen/caught
+        party = state.get("party", [])
+        for pokemon in party:
+            species_id = pokemon.get("species_id", 0)
+            if species_id > 0:
+                self.unique_species.add(species_id)
+
+        total_reward = 0.0
+        species_count = len(self.unique_species)
+
+        for milestone in self.milestones:
+            if species_count >= milestone and milestone not in self.milestones_reached:
+                self.milestones_reached.add(milestone)
+                total_reward += 100.0
+
+        return total_reward
+
+
+class AreaPokedexCompletionReward(RewardComponent):
+    """Reward for catching all Pokemon available in an area - +50 points"""
+
+    def __init__(self):
+        self.completed_areas: Set[int] = set()
+        # Area Pokemon lists (would be loaded from game data)
+        self.area_pokemon = {
+            0: {16, 17, 18},  # Pallet Town area (Pidgey line)
+            1: {10, 11, 13, 14},  # Route 1 (Caterpie, Weedle lines)
+            # Add more areas
+        }
+        self.caught_by_area: Dict[int, Set[int]] = {}
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        current_map = state["map_id"]
+
+        if current_map in self.completed_areas:
+            return 0.0
+
+        # Track caught Pokemon in this area
+        if current_map not in self.caught_by_area:
+            self.caught_by_area[current_map] = set()
+
+        party = state.get("party", [])
+        for pokemon in party:
+            species_id = pokemon.get("species_id", 0)
+            if species_id > 0:
+                self.caught_by_area[current_map].add(species_id)
+
+        # Check if area is complete
+        required_pokemon = self.area_pokemon.get(current_map, set())
+        if required_pokemon.issubset(self.caught_by_area[current_map]):
+            self.completed_areas.add(current_map)
+            return 50.0
+
+        return 0.0
+
+
+class TypeCollectionReward(RewardComponent):
+    """Reward for catching first Pokemon of each type - +25 points"""
+
+    def __init__(self):
+        self.types_collected: Set[str] = set()
+        # Pokemon type mappings (simplified)
+        self.pokemon_types = {
+            1: "grass",
+            4: "fire",
+            7: "water",
+            25: "electric",
+            # Add more mappings
+        }
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        party = state.get("party", [])
+        total_reward = 0.0
+
+        for pokemon in party:
+            species_id = pokemon.get("species_id", 0)
+            pokemon_type = self.pokemon_types.get(species_id)
+
+            if pokemon_type and pokemon_type not in self.types_collected:
+                self.types_collected.add(pokemon_type)
+                total_reward += 25.0
+
+        return total_reward
+
+
+class PokemonEvolutionReward(RewardComponent):
+    """Reward for evolving Pokemon - +30 points"""
+
+    def __init__(self):
+        self.evolution_count = 0
+        self.previous_species: Set[int] = set()
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Track species changes (evolution)
+        prev_party = action.get("prev_party", [])
+        current_party = state.get("party", [])
+
+        prev_species = {p.get("species_id", 0) for p in prev_party}
+        current_species = {p.get("species_id", 0) for p in current_party}
+
+        # Check for evolution (new species appears, old species disappears)
+        evolved_species = current_species - prev_species
+
+        if evolved_species and self._is_evolution(prev_species, current_species):
+            return 30.0
+
+        return 0.0
+
+    def _is_evolution(self, prev_species: Set[int], current_species: Set[int]) -> bool:
+        """Check if species change represents evolution"""
+        # This would check evolution chains
+        # Simplified: any new species with same party size is evolution
+        return len(prev_species) == len(current_species) and prev_species != current_species
+
+
+class LevelMilestonesReward(RewardComponent):
+    """Reward for reaching levels 10, 20, 30, 40, 50 with any Pokemon - +10 points"""
+
+    def __init__(self):
+        self.level_milestones_reached: Set[tuple] = set()  # (pokemon_id, level)
+        self.milestones = [10, 20, 30, 40, 50]
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        party = state.get("party", [])
+        total_reward = 0.0
+
+        for i, pokemon in enumerate(party):
+            level = pokemon.get("level", 0)
+
+            for milestone in self.milestones:
+                milestone_key = (i, milestone)
+                if level >= milestone and milestone_key not in self.level_milestones_reached:
+                    self.level_milestones_reached.add(milestone_key)
+                    total_reward += 10.0
+
+        return total_reward
+
+
+class MoveLearningReward(RewardComponent):
+    """Reward for learning new moves (not replacing) - +5 points"""
+
+    def __init__(self):
+        self.known_moves: Set[tuple] = set()  # (pokemon_index, move_id)
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        party = state.get("party", [])
+        total_reward = 0.0
+
+        for i, pokemon in enumerate(party):
+            moves = pokemon.get("moves", [])
+            for move_id in moves:
+                move_key = (i, move_id)
+                if move_key not in self.known_moves and move_id > 0:
+                    self.known_moves.add(move_key)
+                    total_reward += 5.0
+
+        return total_reward
+
+
+class TMHMTeachingReward(RewardComponent):
+    """Reward for successfully teaching TMs/HMs - +10 points"""
+
+    def __init__(self):
+        self.tm_hm_taught: Set[tuple] = set()  # (pokemon_index, tm_hm_id)
+        # TM/HM move IDs (would be loaded from game data)
+        self.tm_hm_moves = set(range(15, 65))  # Example TM/HM move range
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        party = state.get("party", [])
+        total_reward = 0.0
+
+        for i, pokemon in enumerate(party):
+            moves = pokemon.get("moves", [])
+            for move_id in moves:
+                if move_id in self.tm_hm_moves:
+                    move_key = (i, move_id)
+                    if move_key not in self.tm_hm_taught:
+                        self.tm_hm_taught.add(move_key)
+                        total_reward += 10.0
+
+        return total_reward

synth_ai/environments/examples/red/engine_helpers/reward_library/social_rewards.py

@@ -0,0 +1,147 @@
+"""
+Social & NPC Interaction Reward Components
+
+Rewards for dialogue, information gathering, and NPC interactions.
+"""
+
+from synth_ai.environments.environment.rewards.core import RewardComponent
+from typing import Dict, Any, Set
+
+
+class NewNPCConversationReward(RewardComponent):
+    """Reward for talking to each unique NPC for the first time - +5 points"""
+
+    def __init__(self):
+        self.npcs_talked_to: Set[tuple] = set()
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        if state["text_box_active"] and not action.get("prev_text_box_active", False):
+            npc_key = (state["player_x"], state["player_y"], state["map_id"])
+            if npc_key not in self.npcs_talked_to:
+                self.npcs_talked_to.add(npc_key)
+                return 5.0
+        return 0.0
+
+
+class HelpfulInformationReceivedReward(RewardComponent):
+    """Reward for getting useful hints, directions, or game tips - +10 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # This would need dialogue content analysis
+        # Placeholder implementation
+        if state["text_box_active"] and not action.get("prev_text_box_active", False):
+            # Simplified: reward for certain locations known to give helpful info
+            helpful_locations = {(5, 3, 0), (2, 4, 3)}  # Example helpful NPC locations
+            location = (state["player_x"], state["player_y"], state["map_id"])
+            if location in helpful_locations:
+                return 10.0
+        return 0.0
+
+
+class StoryDialogueProgressionReward(RewardComponent):
+    """Reward for advancing story through key NPCs - +15 points"""
+
+    def __init__(self):
+        self.story_npcs_talked_to: Set[tuple] = set()
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Story NPCs in key locations
+        story_locations = {(3, 4, 3), (5, 2, 0)}  # Oak's lab, important NPCs
+        location = (state["player_x"], state["player_y"], state["map_id"])
+
+        if (
+            state["text_box_active"]
+            and not action.get("prev_text_box_active", False)
+            and location in story_locations
+            and location not in self.story_npcs_talked_to
+        ):
+            self.story_npcs_talked_to.add(location)
+            return 15.0
+        return 0.0
+
+
+class ProfessorOakInteractionsReward(RewardComponent):
+    """Reward for meaningful interactions with Professor Oak - +20 points"""
+
+    def __init__(self):
+        self.oak_interactions = 0
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Oak's lab interactions
+        if (
+            state["map_id"] == 3
+            and state["text_box_active"]
+            and not action.get("prev_text_box_active", False)
+        ):
+            # Check if this is likely Oak (center of lab)
+            if 3 <= state["player_x"] <= 5 and 4 <= state["player_y"] <= 6:
+                return 20.0
+        return 0.0
+
+
+class NPCGiftReceivedReward(RewardComponent):
+    """Reward for receiving Pokemon or items from NPCs - +15 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Check for item/Pokemon acquisition during NPC interaction
+        prev_inventory_count = len(action.get("prev_inventory", []))
+        current_inventory_count = len(state.get("inventory", []))
+        prev_party_count = len(action.get("prev_party", []))
+        current_party_count = len(state.get("party", []))
+
+        # Gift received if items/Pokemon increased during text interaction
+        if state["text_box_active"] and (
+            current_inventory_count > prev_inventory_count or current_party_count > prev_party_count
+        ):
+            return 15.0
+        return 0.0
+
+
+class TradeCompletionReward(RewardComponent):
+    """Reward for completing in-game trades - +25 points"""
+
+    def __init__(self):
+        self.trades_completed: Set[tuple] = set()
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Trade locations (would be loaded from game data)
+        trade_locations = {(2, 3, 15), (4, 5, 20)}  # Example trade locations
+        location = (state["player_x"], state["player_y"], state["map_id"])
+
+        if location in trade_locations and location not in self.trades_completed:
+            # Check for Pokemon species change (trade occurred)
+            prev_party = action.get("prev_party", [])
+            current_party = state.get("party", [])
+
+            if len(prev_party) == len(current_party):
+                prev_species = {p.get("species_id") for p in prev_party}
+                current_species = {p.get("species_id") for p in current_party}
+
+                if prev_species != current_species:
+                    self.trades_completed.add(location)
+                    return 25.0
+        return 0.0
+
+
+class NameRaterUsageReward(RewardComponent):
+    """Reward for using nickname services - +5 points"""
+
+    def __init__(self):
+        self.name_rater_used = False
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        if self.name_rater_used:
+            return 0.0
+
+        # Name Rater location (would be loaded from game data)
+        name_rater_location = (3, 2, 25)  # Example location
+        location = (state["player_x"], state["player_y"], state["map_id"])
+
+        if (
+            location == name_rater_location
+            and state["text_box_active"]
+            and not action.get("prev_text_box_active", False)
+        ):
+            self.name_rater_used = True
+            return 5.0
+        return 0.0

synth_ai/environments/examples/red/engine_helpers/reward_library/story_rewards.py

@@ -0,0 +1,246 @@
+"""
+Story & Achievement Progression Reward Components
+
+Rewards for major milestones, story gates, and achievements.
+"""
+
+from synth_ai.environments.environment.rewards.core import RewardComponent
+from typing import Dict, Any, Set
+
+
+class GymBadgeEarnedReward(RewardComponent):
+    """Reward for earning gym badges - +150 points per badge (cumulative)"""
+
+    def __init__(self):
+        self.previous_badge_count = 0
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        current_badges = state.get("badges", 0)
+
+        # Convert badge bitmask to count
+        badge_count = bin(current_badges).count("1")
+
+        if badge_count > self.previous_badge_count:
+            new_badges = badge_count - self.previous_badge_count
+            self.previous_badge_count = badge_count
+            return new_badges * 150.0
+
+        return 0.0
+
+
+class HMAcquisitionReward(RewardComponent):
+    """Reward for getting HMs - +75 points"""
+
+    def __init__(self):
+        self.hms_acquired: Set[int] = set()
+        # HM item IDs (would be loaded from game data)
+        self.hm_items = {200, 201, 202, 203, 204}  # Example HM IDs
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        inventory = state.get("inventory", [])
+        total_reward = 0.0
+
+        for item in inventory:
+            item_id = item.get("item_id", 0)
+            if item_id in self.hm_items and item_id not in self.hms_acquired:
+                self.hms_acquired.add(item_id)
+                total_reward += 75.0
+
+        return total_reward
+
+
+class EliteFourAccessReward(RewardComponent):
+    """Reward for reaching Pokemon League - +300 points"""
+
+    def __init__(self):
+        self.elite_four_accessed = False
+        self.elite_four_map = 100  # Pokemon League entrance
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        if self.elite_four_accessed:
+            return 0.0
+
+        if state["map_id"] == self.elite_four_map:
+            self.elite_four_accessed = True
+            return 300.0
+
+        return 0.0
+
+
+class HallOfFameEntryReward(RewardComponent):
+    """Reward for becoming Champion - +1000 points"""
+
+    def __init__(self):
+        self.hall_of_fame_entered = False
+        self.hall_of_fame_map = 105  # Hall of Fame room
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        if self.hall_of_fame_entered:
+            return 0.0
+
+        if state["map_id"] == self.hall_of_fame_map:
+            self.hall_of_fame_entered = True
+            return 1000.0
+
+        return 0.0
+
+
+class RivalBattleCompletionReward(RewardComponent):
+    """Reward for each scripted rival encounter - +50 points"""
+
+    def __init__(self):
+        self.rival_battles_completed: Set[int] = set()
+        # Rival battle locations
+        self.rival_battle_maps = {3, 22, 25, 30}  # Oak's lab, Route 22, etc.
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        prev_in_battle = action.get("prev_in_battle", False)
+        current_in_battle = state["in_battle"]
+        battle_outcome = state.get("battle_outcome", 0)
+        current_map = state["map_id"]
+
+        # Completed rival battle
+        if (
+            prev_in_battle
+            and not current_in_battle
+            and battle_outcome == 1
+            and current_map in self.rival_battle_maps
+            and current_map not in self.rival_battles_completed
+        ):
+            self.rival_battles_completed.add(current_map)
+            return 50.0
+
+        return 0.0
+
+
+class TeamRocketDefeatReward(RewardComponent):
+    """Reward for each Team Rocket encounter - +40 points"""
+
+    def __init__(self):
+        self.rocket_encounters: Set[tuple] = set()
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # This would need Team Rocket battle detection
+        # Placeholder implementation
+        prev_in_battle = action.get("prev_in_battle", False)
+        current_in_battle = state["in_battle"]
+        battle_outcome = state.get("battle_outcome", 0)
+
+        if prev_in_battle and not current_in_battle and battle_outcome == 1:
+            # Check if in Team Rocket location
+            rocket_maps = {50, 51, 52}  # Example Team Rocket hideout maps
+            if state["map_id"] in rocket_maps:
+                encounter_key = (state["player_x"], state["player_y"], state["map_id"])
+                if encounter_key not in self.rocket_encounters:
+                    self.rocket_encounters.add(encounter_key)
+                    return 40.0
+
+        return 0.0
+
+
+class LegendaryEncounterReward(RewardComponent):
+    """Reward for encountering legendary Pokemon - +200 points"""
+
+    def __init__(self):
+        self.legendary_encounters: Set[int] = set()
+        self.legendary_maps = {60, 61, 62, 70}  # Legendary Pokemon locations
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        current_map = state["map_id"]
+
+        if current_map in self.legendary_maps and current_map not in self.legendary_encounters:
+            # Check if battle started (legendary encounter)
+            prev_in_battle = action.get("prev_in_battle", False)
+            current_in_battle = state["in_battle"]
+
+            if not prev_in_battle and current_in_battle:
+                self.legendary_encounters.add(current_map)
+                return 200.0
+
+        return 0.0
+
+
+class SilphCoCompletionReward(RewardComponent):
+    """Reward for completing major story dungeons - +100 points"""
+
+    def __init__(self):
+        self.silph_co_completed = False
+        self.silph_co_maps = set(range(80, 90))  # Silph Co floors
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        if self.silph_co_completed:
+            return 0.0
+
+        # Check if exiting Silph Co after completion
+        prev_map = action.get("prev_map_id", -1)
+        current_map = state["map_id"]
+
+        if prev_map in self.silph_co_maps and current_map not in self.silph_co_maps:
+            # Assume completion if leaving Silph Co
+            self.silph_co_completed = True
+            return 100.0
+
+        return 0.0
+
+
+class SafariZoneSuccessReward(RewardComponent):
+    """Reward for successful Safari Zone runs - +30 points"""
+
+    def __init__(self):
+        self.safari_zone_runs = 0
+        self.safari_zone_maps = {90, 91, 92, 93}  # Safari Zone areas
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Check if exiting Safari Zone with new Pokemon
+        prev_map = action.get("prev_map_id", -1)
+        current_map = state["map_id"]
+
+        if prev_map in self.safari_zone_maps and current_map not in self.safari_zone_maps:
+            # Check if Pokemon count increased
+            prev_party_count = len(action.get("prev_party", []))
+            current_party_count = len(state.get("party", []))
+
+            if current_party_count > prev_party_count:
+                return 30.0
+
+        return 0.0
+
+
+class GameCornerPrizesReward(RewardComponent):
+    """Reward for earning significant Game Corner prizes - +20 points"""
+
+    def __init__(self):
+        self.game_corner_prizes: Set[int] = set()
+        self.prize_items = {300, 301, 302}  # Game Corner prize item IDs
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        inventory = state.get("inventory", [])
+        total_reward = 0.0
+
+        for item in inventory:
+            item_id = item.get("item_id", 0)
+            if item_id in self.prize_items and item_id not in self.game_corner_prizes:
+                self.game_corner_prizes.add(item_id)
+                total_reward += 20.0
+
+        return total_reward
+
+
+class FossilRevivalReward(RewardComponent):
+    """Reward for reviving fossils - +40 points"""
+
+    def __init__(self):
+        self.fossils_revived: Set[int] = set()
+        self.fossil_pokemon = {138, 140, 142}  # Omanyte, Kabuto, Aerodactyl
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        party = state.get("party", [])
+        total_reward = 0.0
+
+        for pokemon in party:
+            species_id = pokemon.get("species_id", 0)
+            if species_id in self.fossil_pokemon and species_id not in self.fossils_revived:
+                self.fossils_revived.add(species_id)
+                total_reward += 40.0
+
+        return total_reward