synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

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

@@ -1,284 +0,0 @@
-"""
-Battle & Combat Reward Components
-
-Rewards for battle victories, combat strategy, and battle efficiency.
-"""
-
-from typing import Any, Dict, Set
-
-from synth_ai.environments.environment.rewards.core import RewardComponent
-
-
-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

@@ -1,150 +0,0 @@
-"""
-Composite & Milestone Reward Components
-
-Rewards for achievement combinations and progression streaks.
-"""
-
-from typing import Any, Dict, Set
-
-from synth_ai.environments.environment.rewards.core import RewardComponent
-
-
-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

@@ -1,138 +0,0 @@
-"""
-Economy & Resource Management Reward Components
-
-Rewards for money management and inventory optimization.
-"""
-
-from typing import Any, Dict, Set
-
-from synth_ai.environments.environment.rewards.core import RewardComponent
-
-
-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

@@ -1,57 +0,0 @@
-"""
-Efficiency & Optimization Reward Components
-
-Rewards for optimal play, routing, and game knowledge.
-"""
-
-from typing import Any, Dict
-
-from synth_ai.environments.environment.rewards.core import RewardComponent
-
-
-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