Fix move tracking

src/poke_env/battle/abstract_battle.py

@@ -6,6 +6,7 @@
 
 from poke_env.battle.effect import Effect
 from poke_env.battle.field import Field
+from poke_env.battle.move import Move
 from poke_env.battle.observation import Observation
 from poke_env.battle.observed_pokemon import ObservedPokemon
 from poke_env.battle.pokemon import Pokemon
@@ -473,9 +474,10 @@ def parse_message(self, split_message: List[str]):
             self._check_damage_message_for_item(event)
             self._check_damage_message_for_ability(event)
         elif event[1] == "move":
+            use = True
             failed = False
-            override_move = None
-            reveal_other_move = False
+            reveal = True
+            overridden_move = None
 
             for move_failed_suffix in ["[miss]", "[still]", "[notarget]"]:
                 if event[-1] == move_failed_suffix:
@@ -485,37 +487,47 @@ def parse_message(self, split_message: List[str]):
             if event[-1] == "[notarget]":
                 event = event[:-1]
 
-            if event[-1].startswith("[spread]"):
+            while event[-1].startswith("[spread]"):
                 event = event[:-1]
 
             if event[-1] in {
                 "[from] lockedmove",
-                "[from] Pursuit",
                 "[from]lockedmove",
                 "[from] Sky Attack",
-                "[from]Pursuit",
-                "[zeffect]",
             }:
+                use = False
+                reveal = False
                 event = event[:-1]
 
+            if event[-1] in {"[from] Pursuit", "[from]Pursuit", "[zeffect]"}:
+                event = event[:-1]
+
+            if event[-1] == "[from] Sleep Talk":
+                event[-1] = "[from] move: Sleep Talk"
+
             if event[-1].startswith("[anim]"):
                 event = event[:-1]
 
             if event[-1].startswith(("[from] move: ", "[from]move: ")):
-                override_move = event.pop().split(": ")[-1]
+                overridden_move = event.pop().split(": ")[-1]
 
-                if override_move == "Sleep Talk":
-                    # Sleep talk was used, but also reveals another move
-                    reveal_other_move = True
-                elif override_move in {"Copycat", "Metronome", "Nature Power", "Round"}:
+                if overridden_move == "Sleep Talk":
                     pass
-                elif override_move in {"Grass Pledge", "Water Pledge", "Fire Pledge"}:
-                    override_move = None
+                elif overridden_move in {
+                    "Copycat",
+                    "Metronome",
+                    "Nature Power",
+                    "Round",
+                }:
+                    # triggers moves not owned by actor, so no reveal
+                    reveal = False
+                elif overridden_move in {"Grass Pledge", "Water Pledge", "Fire Pledge"}:
+                    overridden_move = None
                 elif self.logger is not None:
                     self.logger.warning(
                         "Unmanaged [from] move message received - move %s in cleaned up "
                         "message %s in battle %s turn %d",
-                        override_move,
+                        overridden_move,
                         event,
                         self.battle_tag,
                         self.turn,
@@ -531,7 +543,8 @@ def parse_message(self, split_message: List[str]):
                 self.get_pokemon(pokemon).ability = revealed_ability
 
                 if revealed_ability == "Magic Bounce":
-                    return
+                    use = False
+                    reveal = False
                 elif revealed_ability == "Dancer":
                     return
                 elif self.logger is not None:
@@ -543,21 +556,22 @@ def parse_message(self, split_message: List[str]):
                         self.battle_tag,
                         self.turn,
                     )
-            if event[-1] == "[from] Magic Coat":
-                return
-
-            while event[-1] == "[still]":
+            if event[-1] == "[from] Magic Coat" or event[-1] == "[from] Mirror Move":
+                use = False
+                reveal = False
                 event = event[:-1]
 
-            if event[-1] == "":
+            while event[-1] == "[still]":
                 event = event[:-1]
 
+            presumed_target = None
             if len(event) == 4:
                 pokemon, move = event[2:4]
             elif len(event) == 5:
                 pokemon, move, presumed_target = event[2:5]
-
-                if len(presumed_target) > 4 and presumed_target[:4] in {
+                if presumed_target == "":
+                    pass
+                elif len(presumed_target) > 4 and presumed_target[:4] in {
                     "p1: ",
                     "p2: ",
                     "p1a:",
@@ -594,16 +608,31 @@ def parse_message(self, split_message: List[str]):
                 temp_pokemon = self.get_pokemon(pokemon)
                 temp_pokemon.start_effect("MINIMIZE")
 
-            if override_move:
-                # Moves that can trigger this branch results in two `move` messages being sent.
-                # We're setting use=False in the one (with the override) in order to prevent two pps from being used
-                # incorrectly.
-                self.get_pokemon(pokemon).moved(override_move, failed=failed, use=False)
-            if override_move is None or reveal_other_move:
-                self.get_pokemon(pokemon).moved(move, failed=failed, use=False)
+            pressure = self._pressure_on(pokemon, move, presumed_target or None)
+            mon = self.get_pokemon(pokemon)
+            if overridden_move:
+                mon.moved(move, failed=failed, use=False, reveal=reveal)
+                overridden = mon.moves[Move.retrieve_id(overridden_move)]
+                overridden.use(pressure, overridden=True)
+            elif not failed and move in {
+                "Sleep Talk",
+                "Copycat",
+                "Metronome",
+                "Nature Power",
+            }:
+                # make preemptive deduction in case override move fails
+                mon.moved(move, failed=failed, use=use, reveal=reveal)
+            else:
+                mon.moved(
+                    move, failed=failed, use=use, reveal=reveal, pressure=pressure
+                )
         elif event[1] == "cant":
-            pokemon, _ = event[2:4]
-            self.get_pokemon(pokemon).cant_move()
+            if len(event) == 4:
+                pokemon, _ = event[2:4]
+                self.get_pokemon(pokemon).cant_move()
+            elif len(event) == 5:
+                pokemon, _, move = event[2:5]
+                self.get_pokemon(pokemon).cant_move(move)
         elif event[1] == "turn":
             # Saving the beginning-of-turn battle state and events as we go into the turn
             self.observations[self.turn] = self._current_observation
@@ -710,6 +739,10 @@ def parse_message(self, split_message: List[str]):
                     types = event[4]
                 mon.start_effect(effect, details=types)
             else:
+                if effect == "Mimic":
+                    mon._mimic_move = Move(
+                        Move.retrieve_id(event[4]), gen=self.gen, from_mimic=True
+                    )
                 mon.start_effect(effect)
 
             if mon.is_dynamaxed:
@@ -741,6 +774,20 @@ def parse_message(self, split_message: List[str]):
                     "[item] ", ""
                 )
                 self.get_pokemon(target).item = None
+            elif effect == "item: Leppa Berry":
+                mon = self.get_pokemon(target)
+                mv = mon.moves[to_id_str(event[4])]
+                # Don't let current pp exceed max pp
+                mv._current_pp = min(mv._current_pp + 10, mv.max_pp)
+            elif effect == "move: Mimic":
+                mon = self.get_pokemon(target)
+                mon._mimic_move = Move(
+                    Move.retrieve_id(event[4]), gen=self.gen, from_mimic=True
+                )
+            elif effect == "move: Trick":
+                mon = self.get_pokemon(target)
+                mon2 = self.get_pokemon(event[4].replace("[of] ", ""))
+                mon._item, mon2._item = mon2.item, mon.item
             elif target != "":  # ['', '-activate', '', 'move: Splash']
                 self.get_pokemon(target).start_effect(effect)
         elif event[1] == "-status":
@@ -839,9 +886,11 @@ def parse_message(self, split_message: List[str]):
                     self.get_pokemon(victim).item = None
                 else:
                     raise ValueError(f"Unhandled item message: {event}")
-
             else:
                 pokemon, item = event[2:4]
+                if len(event) > 4 and event[4] == "[from] move: Trick":
+                    # this event is handled in when consuming -activate event
+                    return
                 self.get_pokemon(pokemon).item = to_id_str(item)
         elif event[1] == "-mega":
             assert self.player_role is not None
@@ -1034,6 +1083,10 @@ def parse_request(
     ):
         pass
 
+    @abstractmethod
+    def _pressure_on(self, pokemon: str, move: str, target_str: Optional[str]) -> bool:
+        pass
+
     def _register_teampreview_pokemon(self, player: str, details: str):
         if player != self._player_role:
             mon = Pokemon(details=details, gen=self.gen)

src/poke_env/battle/battle.py

@@ -4,6 +4,7 @@
 from poke_env.battle.abstract_battle import AbstractBattle
 from poke_env.battle.move import Move
 from poke_env.battle.pokemon import Pokemon
+from poke_env.data import GenData
 from poke_env.player.battle_order import DefaultBattleOrder, SingleBattleOrder
 
 
@@ -96,6 +97,8 @@ def parse_request(
                 self._trapped = True
 
             if self.active_pokemon is not None:
+                if strict_battle_tracking:
+                    self.active_pokemon.check_move_consistency(active_request)
                 # TODO: the illusion handling here works around Zoroark's
                 # difficulties. This should be properly handled at some point.
                 try:
@@ -125,6 +128,40 @@ def parse_request(
                 if not pokemon.active and self.reviving == pokemon.fainted:
                     self._available_switches.append(pokemon)
 
+    def _pressure_on(self, pokemon: str, move: str, target_str: Optional[str]) -> bool:
+        move_id = Move.retrieve_id(move)
+        if move_id not in GenData.from_gen(self.gen).moves:
+            # This happens when `move` is a z-move. Since z-moves cannot be PP tracked
+            # anyway, we just return False here.
+            return False
+        move_data = GenData.from_gen(self.gen).moves[move_id]
+        if move_data["target"] == "all" or target_str is None:
+            target = (
+                self.opponent_active_pokemon
+                if self.player_role == pokemon[:2]
+                else self.active_pokemon
+            )
+            assert target is not None
+        else:
+            target = self.get_pokemon(target_str)
+        return (
+            target.ability == "pressure"
+            and not target.fainted
+            and (
+                move_data["target"]
+                in [
+                    "all",
+                    "allAdjacent",
+                    "allAdjacentFoes",
+                    "any",
+                    "normal",
+                    "randomNormal",
+                    "scripted",
+                ]
+                or "mustpressure" in move_data["flags"]
+            )
+        )
+
     def switch(self, pokemon_str: str, details: str, hp_status: str):
         identifier = pokemon_str.split(":")[0][:2]
 

src/poke_env/battle/double_battle.py

@@ -7,6 +7,7 @@
 from poke_env.battle.pokemon import Pokemon
 from poke_env.battle.pokemon_type import PokemonType
 from poke_env.battle.target import Target
+from poke_env.data import GenData
 from poke_env.player.battle_order import (
     DefaultBattleOrder,
     PassBattleOrder,
@@ -140,6 +141,8 @@ def parse_request(
                     force_self_team=True,
                     details=pokemon_dict["details"],
                 )
+                if strict_battle_tracking:
+                    active_pokemon.check_move_consistency(active_request)
                 if self.player_role is not None:
                     if (
                         active_pokemon_number == 0
@@ -210,6 +213,45 @@ def parse_request(
                     if not pokemon.active and self.reviving == pokemon.fainted:
                         self._available_switches[i].append(pokemon)
 
+    def _pressure_on(self, pokemon: str, move: str, target_str: Optional[str]) -> bool:
+        move_id = Move.retrieve_id(move)
+        if move_id not in GenData.from_gen(self.gen).moves:
+            # This happens when `move` is a z-move. Since z-moves cannot be PP tracked
+            # anyway, we just return False here.
+            return False
+        move_data = GenData.from_gen(self.gen).moves[move_id]
+        if move_data["target"] == "all" or target_str is None:
+            targets = (
+                self.opponent_active_pokemon
+                if self.player_role == pokemon[:2]
+                else self.active_pokemon
+            )
+            cleaned_targets = [t for t in targets if t is not None]
+            if not cleaned_targets:
+                return False
+            target = cleaned_targets[0]
+            for t in cleaned_targets:
+                if target.ability != "pressure":
+                    target = t
+            assert target is not None
+        else:
+            target = self.get_pokemon(target_str)
+        return (
+            target.ability == "pressure"
+            and not target.fainted
+            and move_data["target"]
+            in [
+                "all",
+                "allAdjacent",
+                "allAdjacentFoes",
+                "any",
+                "normal",
+                "randomNormal",
+                "scripted",
+            ]
+            or "mustpressure" in move_data["flags"]
+        )
+
     def switch(self, pokemon_str: str, details: str, hp_status: str):
         pokemon_identifier = pokemon_str.split(":")[0][:3]
         player_identifier = pokemon_identifier[:2]

src/poke_env/battle/move.py

@@ -12,7 +12,6 @@
 from poke_env.data import GenData, to_id_str
 
 SPECIAL_MOVES: Set[str] = {"struggle", "recharge"}
-
 _PROTECT_MOVES = {
     "protect",
     "detect",
@@ -78,14 +77,22 @@ class Move:
         "_base_power_override",
         "_current_pp",
         "_dynamaxed_move",
+        "_from_mimic",
         "_gen",
         "_request_target",
     )
 
-    def __init__(self, move_id: str, gen: int, raw_id: Optional[str] = None):
+    def __init__(
+        self,
+        move_id: str,
+        gen: int,
+        raw_id: Optional[str] = None,
+        from_mimic: bool = False,
+    ):
         self._id = move_id
         self._base_power_override = None
         self._gen = gen
+        self._from_mimic = from_mimic
 
         if move_id.startswith("hiddenpower") and raw_id is not None:
             base_power = "".join([c for c in raw_id if c.isdigit()])
@@ -105,8 +112,14 @@ def __init__(self, move_id: str, gen: int, raw_id: Optional[str] = None):
     def __repr__(self) -> str:
         return f"{self._id} (Move object)"
 
-    def use(self):
-        self._current_pp -= 1
+    def use(self, pressure: bool = False, overridden: bool = False):
+        decrement = 1
+        if pressure:
+            decrement += 1
+        if overridden:
+            decrement -= 1
+        # don't let PP go below 0
+        self._current_pp = max(self._current_pp - decrement, 0)
 
     @staticmethod
     def is_id_z(id_: str, gen: int) -> bool:
@@ -446,7 +459,10 @@ def max_pp(self) -> int:
         :return: The move's max pp.
         :rtype: int
         """
-        return self.entry["pp"] * 8 // 5
+        max_pp = self.entry["pp"] * 8 // 5
+        if self._gen < 3 and not self._from_mimic:
+            max_pp = min(max_pp, 61)
+        return max_pp
 
     @property
     def n_hit(self) -> Tuple[int, int]: