synth-ai 0.2.4.dev3__py3-none-any.whl → 0.2.4.dev5__py3-none-any.whl

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

@@ -0,0 +1,283 @@
+"""
+Battle & Combat Reward Components
+
+Rewards for battle victories, combat strategy, and battle efficiency.
+"""
+
+from synth_ai.environments.environment.rewards.core import RewardComponent
+from typing import Dict, Any, Set
+
+
+class WildPokemonDefeatedReward(RewardComponent):
+    """Reward for defeating wild Pokemon - +3 points per defeat"""
+
+    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)
+
+        # Exiting battle with victory (outcome = 1)
+        if prev_in_battle and not current_in_battle and battle_outcome == 1:
+            # Check if it was a wild Pokemon battle (no trainer)
+            # This would need additional state to distinguish wild vs trainer battles
+            return 3.0
+        return 0.0
+
+
+class TrainerBattleVictoryReward(RewardComponent):
+    """Reward for defeating trainers - +15 points"""
+
+    def __init__(self):
+        self.trainers_defeated: Set[tuple] = set()
+
+    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)
+
+        # Exiting battle with victory
+        if prev_in_battle and not current_in_battle and battle_outcome == 1:
+            # Use location as trainer identifier
+            trainer_key = (state["player_x"], state["player_y"], state["map_id"])
+            if trainer_key not in self.trainers_defeated:
+                self.trainers_defeated.add(trainer_key)
+                return 15.0
+        return 0.0
+
+
+class GymLeaderVictoryReward(RewardComponent):
+    """Reward for defeating gym leaders - +100 points"""
+
+    def __init__(self):
+        self.gym_leaders_defeated: Set[int] = set()
+        # Gym map IDs (would be loaded from game data)
+        self.gym_maps = {20, 21, 22, 23, 24, 25, 26, 27}
+
+    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"]
+
+        # Victory in a gym
+        if (
+            prev_in_battle
+            and not current_in_battle
+            and battle_outcome == 1
+            and current_map in self.gym_maps
+        ):
+            if current_map not in self.gym_leaders_defeated:
+                self.gym_leaders_defeated.add(current_map)
+                return 100.0
+        return 0.0
+
+
+class EliteFourMemberVictoryReward(RewardComponent):
+    """Reward for defeating Elite Four members - +200 points each"""
+
+    def __init__(self):
+        self.elite_four_defeated: Set[int] = set()
+        # Elite Four room IDs (would be loaded from game data)
+        self.elite_four_maps = {100, 101, 102, 103}
+
+    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"]
+
+        # Victory against Elite Four
+        if (
+            prev_in_battle
+            and not current_in_battle
+            and battle_outcome == 1
+            and current_map in self.elite_four_maps
+        ):
+            if current_map not in self.elite_four_defeated:
+                self.elite_four_defeated.add(current_map)
+                return 200.0
+        return 0.0
+
+
+class ChampionVictoryReward(RewardComponent):
+    """Reward for defeating the Champion - +500 points"""
+
+    def __init__(self):
+        self.champion_defeated = False
+        self.champion_map = 104  # Champion room ID
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        if self.champion_defeated:
+            return 0.0
+
+        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"]
+
+        # Victory against Champion
+        if (
+            prev_in_battle
+            and not current_in_battle
+            and battle_outcome == 1
+            and current_map == self.champion_map
+        ):
+            self.champion_defeated = True
+            return 500.0
+        return 0.0
+
+
+class TypeAdvantageUsageReward(RewardComponent):
+    """Reward for using super effective moves - +5 points"""
+
+    def __init__(self):
+        self.super_effective_count = 0
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # This would need move effectiveness tracking
+        # Placeholder implementation - would need battle log analysis
+        if state["in_battle"]:
+            # Simplified: assume some moves are super effective
+            # Real implementation would track move types vs opponent types
+            move_used = action.get("move_used")
+            opponent_type = action.get("opponent_type")
+
+            if move_used and opponent_type:
+                if self._is_super_effective(move_used, opponent_type):
+                    return 5.0
+        return 0.0
+
+    def _is_super_effective(self, move_type: str, opponent_type: str) -> bool:
+        """Check if move is super effective against opponent"""
+        # Simplified type effectiveness chart
+        effectiveness = {
+            ("water", "fire"): True,
+            ("fire", "grass"): True,
+            ("grass", "water"): True,
+            ("electric", "water"): True,
+            # Add more type matchups
+        }
+        return effectiveness.get((move_type, opponent_type), False)
+
+
+class CriticalHitReward(RewardComponent):
+    """Reward for landing critical hits - +3 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # This would need battle log analysis to detect critical hits
+        # Placeholder implementation
+        if state["in_battle"]:
+            critical_hit = action.get("critical_hit", False)
+            if critical_hit:
+                return 3.0
+        return 0.0
+
+
+class StatusEffectUsageReward(RewardComponent):
+    """Reward for successfully applying status effects - +5 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # This would need status effect tracking
+        # Placeholder implementation
+        if state["in_battle"]:
+            status_applied = action.get("status_applied")
+            if status_applied in ["paralysis", "poison", "sleep", "burn", "freeze"]:
+                return 5.0
+        return 0.0
+
+
+class OHKOReward(RewardComponent):
+    """Reward for one-shot defeats - +10 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # This would need damage tracking to detect OHKO
+        # Placeholder implementation
+        if state["in_battle"]:
+            opponent_defeated = action.get("opponent_defeated", False)
+            damage_dealt = action.get("damage_dealt", 0)
+            opponent_max_hp = action.get("opponent_max_hp", 100)
+
+            # OHKO if damage equals or exceeds max HP
+            if opponent_defeated and damage_dealt >= opponent_max_hp:
+                return 10.0
+        return 0.0
+
+
+class FlawlessVictoryReward(RewardComponent):
+    """Reward for winning without taking damage - +20 points"""
+
+    def __init__(self):
+        self.battle_start_hp: Dict[int, int] = {}  # Track HP at battle start
+
+    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)
+
+        # Track battle start
+        if not prev_in_battle and current_in_battle:
+            # Battle started - record current HP
+            party = state.get("party", [])
+            for i, pokemon in enumerate(party):
+                self.battle_start_hp[i] = pokemon.get("hp_current", 0)
+
+        # Check for flawless victory
+        elif prev_in_battle and not current_in_battle and battle_outcome == 1:
+            # Battle ended in victory - check if HP unchanged
+            party = state.get("party", [])
+            flawless = True
+            for i, pokemon in enumerate(party):
+                start_hp = self.battle_start_hp.get(i, 0)
+                current_hp = pokemon.get("hp_current", 0)
+                if current_hp < start_hp:
+                    flawless = False
+                    break
+
+            # Clear battle HP tracking
+            self.battle_start_hp.clear()
+
+            if flawless:
+                return 20.0
+
+        return 0.0
+
+
+class UnderleveledVictoryReward(RewardComponent):
+    """Reward for winning with significantly lower level Pokemon - +25 points"""
+
+    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)
+
+        # Victory with level disadvantage
+        if prev_in_battle and not current_in_battle and battle_outcome == 1:
+            player_level = action.get("player_pokemon_level", 0)
+            opponent_level = action.get("opponent_pokemon_level", 0)
+
+            # Reward if player Pokemon is 5+ levels lower
+            if opponent_level - player_level >= 5:
+                return 25.0
+        return 0.0
+
+
+class BattleStreakReward(RewardComponent):
+    """Reward for consecutive battle wins - +5 points per battle in streak"""
+
+    def __init__(self):
+        self.current_streak = 0
+
+    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)
+
+        # Battle ended
+        if prev_in_battle and not current_in_battle:
+            if battle_outcome == 1:  # Victory
+                self.current_streak += 1
+                return 5.0
+            else:  # Loss or other outcome
+                self.current_streak = 0
+
+        return 0.0

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

@@ -0,0 +1,149 @@
+"""
+Composite & Milestone Reward Components
+
+Rewards for achievement combinations and progression streaks.
+"""
+
+from synth_ai.environments.environment.rewards.core import RewardComponent
+from typing import Dict, Any, Set
+
+
+class PerfectGymRunReward(RewardComponent):
+    """Reward for defeating gym without losing any Pokemon - +200 points"""
+
+    def __init__(self):
+        self.gym_maps = {20, 21, 22, 23, 24, 25, 26, 27}
+        self.perfect_gyms: Set[int] = set()
+        self.gym_start_party_state: Dict[int, list] = {}
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        current_map = state["map_id"]
+
+        if current_map in self.gym_maps:
+            # Track gym entry
+            prev_map = action.get("prev_map_id", -1)
+            if prev_map not in self.gym_maps:
+                # Entering gym - record party state
+                self.gym_start_party_state[current_map] = state.get("party", [])
+
+            # Check for gym completion
+            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
+                and current_map not in self.perfect_gyms
+            ):
+                # Gym leader defeated - check if perfect run
+                start_party = self.gym_start_party_state.get(current_map, [])
+                current_party = state.get("party", [])
+
+                # Check if all Pokemon maintained their HP
+                perfect = True
+                for i, (start_pkmn, current_pkmn) in enumerate(zip(start_party, current_party)):
+                    if current_pkmn.get("hp_current", 0) < start_pkmn.get("hp_current", 0):
+                        perfect = False
+                        break
+
+                if perfect:
+                    self.perfect_gyms.add(current_map)
+                    return 200.0
+
+        return 0.0
+
+
+class AreaMasteryReward(RewardComponent):
+    """Reward for full area completion - +100 points"""
+
+    def __init__(self):
+        self.mastered_areas: Set[int] = set()
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Placeholder - would need comprehensive area tracking
+        return 0.0
+
+
+class SpeedrunMilestonesReward(RewardComponent):
+    """Reward for reaching story points within time limits - +50 points"""
+
+    def __init__(self):
+        self.milestones_reached: Set[str] = set()
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Placeholder - would need time tracking
+        return 0.0
+
+
+class ExplorationStreakReward(RewardComponent):
+    """Reward for consecutive new area discoveries - +2 points per consecutive area"""
+
+    def __init__(self):
+        self.streak = 0
+        self.last_area = -1
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        current_map = state["map_id"]
+        prev_map = action.get("prev_map_id", -1)
+
+        if current_map != prev_map and current_map != self.last_area:
+            # New area discovered
+            self.streak += 1
+            self.last_area = current_map
+            return 2.0 * self.streak
+        elif current_map == prev_map:
+            # Stayed in same area - reset streak
+            self.streak = 0
+
+        return 0.0
+
+
+class BattleWinStreakReward(RewardComponent):
+    """Reward for consecutive battle wins - +3 points per consecutive win"""
+
+    def __init__(self):
+        self.win_streak = 0
+
+    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)
+
+        if prev_in_battle and not current_in_battle:
+            if battle_outcome == 1:  # Victory
+                self.win_streak += 1
+                return 3.0 * self.win_streak
+            else:  # Loss
+                self.win_streak = 0
+
+        return 0.0
+
+
+class PerfectDayReward(RewardComponent):
+    """Reward for a session with no Pokemon fainting - +100 points"""
+
+    def __init__(self):
+        self.perfect_day_achieved = False
+        self.any_pokemon_fainted = False
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        if self.perfect_day_achieved:
+            return 0.0
+
+        # Check if any Pokemon fainted
+        party = state.get("party", [])
+        for pokemon in party:
+            if pokemon.get("hp_current", 1) == 0:
+                self.any_pokemon_fainted = True
+                break
+
+        # Check for end of session (would need session detection)
+        # Placeholder implementation
+        step_count = state.get("step_count", 0)
+        if step_count >= 100 and not self.any_pokemon_fainted:  # Example session length
+            self.perfect_day_achieved = True
+            return 100.0
+
+        return 0.0

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

@@ -0,0 +1,137 @@
+"""
+Economy & Resource Management Reward Components
+
+Rewards for money management and inventory optimization.
+"""
+
+from synth_ai.environments.environment.rewards.core import RewardComponent
+from typing import Dict, Any, Set
+
+
+class FirstEarningsReward(RewardComponent):
+    """Reward for earning first money from battles - +10 points"""
+
+    def __init__(self):
+        self.first_earnings = False
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        if self.first_earnings:
+            return 0.0
+
+        prev_money = action.get("prev_money", 0)
+        current_money = state.get("money", 0)
+
+        if current_money > prev_money and prev_money == 0:
+            self.first_earnings = True
+            return 10.0
+        return 0.0
+
+
+class WealthMilestonesReward(RewardComponent):
+    """Reward for reaching money milestones - +25 points"""
+
+    def __init__(self):
+        self.milestones_reached: Set[int] = set()
+        self.milestones = [1000, 5000, 10000, 50000]
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        current_money = state.get("money", 0)
+        total_reward = 0.0
+
+        for milestone in self.milestones:
+            if current_money >= milestone and milestone not in self.milestones_reached:
+                self.milestones_reached.add(milestone)
+                total_reward += 25.0
+
+        return total_reward
+
+
+class SmartPurchasesReward(RewardComponent):
+    """Reward for buying useful items - +10 points"""
+
+    def __init__(self):
+        self.useful_items = {4, 5, 6, 10, 11, 12}  # Pokeballs, Potions
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        prev_inventory = action.get("prev_inventory", [])
+        current_inventory = state.get("inventory", [])
+        prev_money = action.get("prev_money", 0)
+        current_money = state.get("money", 0)
+
+        # Money decreased (purchase made)
+        if current_money < prev_money:
+            prev_items = {item.get("item_id") for item in prev_inventory}
+            current_items = {item.get("item_id") for item in current_inventory}
+            new_items = current_items - prev_items
+
+            for item_id in new_items:
+                if item_id in self.useful_items:
+                    return 10.0
+        return 0.0
+
+
+class RarePurchaseReward(RewardComponent):
+    """Reward for buying expensive items - +20 points"""
+
+    def __init__(self):
+        self.expensive_items = {50, 51, 52}  # TMs, evolution stones
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        prev_inventory = action.get("prev_inventory", [])
+        current_inventory = state.get("inventory", [])
+        prev_money = action.get("prev_money", 0)
+        current_money = state.get("money", 0)
+
+        # Money decreased significantly (expensive purchase)
+        if current_money < prev_money - 1000:
+            prev_items = {item.get("item_id") for item in prev_inventory}
+            current_items = {item.get("item_id") for item in current_inventory}
+            new_items = current_items - prev_items
+
+            for item_id in new_items:
+                if item_id in self.expensive_items:
+                    return 20.0
+        return 0.0
+
+
+class InventoryOrganizationReward(RewardComponent):
+    """Reward for effective bag management - +5 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # This would need inventory management tracking
+        # Placeholder implementation
+        return 0.0
+
+
+class HealingItemUsageReward(RewardComponent):
+    """Reward for timely use of potions/healing items - +3 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Check for healing item usage when Pokemon HP is low
+        party = state.get("party", [])
+        prev_inventory = action.get("prev_inventory", [])
+        current_inventory = state.get("inventory", [])
+
+        # Item count decreased (item used)
+        if len(current_inventory) < len(prev_inventory):
+            for pokemon in party:
+                hp_percentage = pokemon.get("hp_current", 0) / max(pokemon.get("hp_max", 1), 1)
+                if hp_percentage < 0.5:  # Low HP
+                    return 3.0
+        return 0.0
+
+
+class PokeballEfficiencyReward(RewardComponent):
+    """Reward for successful captures - +5 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Check for Pokemon capture (party size increase + pokeball usage)
+        prev_party_count = len(action.get("prev_party", []))
+        current_party_count = len(state.get("party", []))
+        prev_inventory = action.get("prev_inventory", [])
+        current_inventory = state.get("inventory", [])
+
+        # Pokemon captured and pokeball used
+        if current_party_count > prev_party_count and len(current_inventory) < len(prev_inventory):
+            return 5.0
+        return 0.0

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

@@ -0,0 +1,56 @@
+"""
+Efficiency & Optimization Reward Components
+
+Rewards for optimal play, routing, and game knowledge.
+"""
+
+from synth_ai.environments.environment.rewards.core import RewardComponent
+from typing import Dict, Any
+
+
+class FastTravelUsageReward(RewardComponent):
+    """Reward for using Fly effectively - +10 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Placeholder - would detect Fly usage
+        return 0.0
+
+
+class OptimalRoutingReward(RewardComponent):
+    """Reward for taking efficient paths - +15 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Placeholder - would analyze path efficiency
+        return 0.0
+
+
+class PuzzleSolvingReward(RewardComponent):
+    """Reward for solving puzzles quickly - +25 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Placeholder - would detect puzzle completion
+        return 0.0
+
+
+class MoveEffectivenessReward(RewardComponent):
+    """Reward for consistently using type advantages - +8 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Placeholder - would track type effectiveness usage
+        return 0.0
+
+
+class EvolutionTimingReward(RewardComponent):
+    """Reward for evolving Pokemon at optimal times - +15 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Placeholder - would analyze evolution timing
+        return 0.0
+
+
+class HMUsageReward(RewardComponent):
+    """Reward for using HMs in appropriate situations - +10 points"""
+
+    async def score(self, state: Dict[str, Any], action: Dict[str, Any]) -> float:
+        # Placeholder - would detect appropriate HM usage
+        return 0.0