limited expansion of strict testing to early gens

Author: cameronangliss

src/poke_env/battle/abstract_battle.py

@@ -496,14 +496,21 @@ def parse_message(self, split_message: List[str]):
             while event[-1].startswith("[spread]"):
                 event = event[:-1]
 
-            if event[-1] in {"[from] lockedmove", "[from]lockedmove"}:
+            if event[-1] in {
+                "[from] lockedmove",
+                "[from]lockedmove",
+                "[from] Sky Attack",
+            }:
                 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]
 
@@ -555,8 +562,10 @@ def parse_message(self, split_message: List[str]):
                         self.battle_tag,
                         self.turn,
                     )
-            if event[-1] == "[from] Magic Coat":
-                return
+            if event[-1] == "[from] Magic Coat" or event[-1] == "[from] Mirror Move":
+                use = False
+                reveal = False
+                event = event[:-1]
 
             while event[-1] == "[still]":
                 event = event[:-1]
@@ -614,8 +623,8 @@ def parse_message(self, split_message: List[str]):
                 # We're setting use=False in the one (with the override) in order to prevent two pps from being used
                 # incorrectly.
                 mon.moved(move, failed=failed, use=False, reveal=reveal)
-                overriden = mon.moves[Move.retrieve_id(overridden_move)]
-                overriden.use(pressure)
+                overridden = mon.moves[Move.retrieve_id(overridden_move)]
+                overridden.use(pressure)
             else:
                 if not failed and move in {
                     "Sleep Talk",
@@ -742,6 +751,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._data.gen, from_mimic=True
+                    )
                 mon.start_effect(effect)
 
             if mon.is_dynamaxed:
@@ -778,6 +791,11 @@ def parse_message(self, split_message: List[str]):
                 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)
+            if effect == "move: Mimic":
+                mon = self.get_pokemon(target)
+                mon._mimic_move = Move(
+                    Move.retrieve_id(event[4]), gen=self._data.gen, from_mimic=True
+                )
             elif target != "":  # ['', '-activate', '', 'move: Splash']
                 self.get_pokemon(target).start_effect(effect)
         elif event[1] == "-status":

src/poke_env/battle/move.py

@@ -77,15 +77,23 @@ class Move:
         "_base_power_override",
         "_current_pp",
         "_dynamaxed_move",
+        "_from_mimic",
         "_gen",
         "_moves_dict",
         "_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
         self._moves_dict = GenData.from_gen(gen).moves
 
         if move_id.startswith("hiddenpower") and raw_id is not None:
@@ -440,7 +448,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]:

src/poke_env/battle/pokemon.py

@@ -33,6 +33,7 @@ class Pokemon:
         "_last_request",
         "_level",
         "_max_hp",
+        "_mimic_move",
         "_forme_change_ability",
         "_moves",
         "_must_recharge",
@@ -125,6 +126,7 @@ def __init__(
         self._temporary_ability: Optional[str] = None
         self._forme_change_ability: Optional[str] = None
         self._temporary_types: List[PokemonType] = []
+        self._mimic_move: Optional[Move] = None
 
         if request_pokemon:
             self.update_from_request(request_pokemon)
@@ -155,6 +157,8 @@ def __str__(self) -> str:
     def _add_move(self, move_id: str) -> Optional[Move]:
         """Store the move if applicable."""
         id_ = Move.retrieve_id(move_id)
+        if id_ in self.moves:
+            return self.moves[id_]
         if not Move.should_be_stored(id_, self._data.gen):
             return None
         if id_ not in self._moves:
@@ -210,6 +214,8 @@ def check_consistency(self, pkmn_request: Dict[str, Any], player_role: str):
             pkmn_request["active"] == self.active
         ), f"{pkmn_request['active']} != {self.active}\nrequest: {pkmn_request}"
         if self.item == "unknown_item":
+            # needed for ability initialization in start of game,
+            # done anyway in update_from_request()
             self._item = pkmn_request["item"]
         if self._data.gen > 4:
             assert pkmn_request["item"] == (
@@ -222,11 +228,18 @@ def check_consistency(self, pkmn_request: Dict[str, Any], player_role: str):
         ), f"{pkmn_request['condition']} != {self.hp_status}\nrequest: {pkmn_request}"
         if self.base_species == "mew":
             return
-        for move_request, move in zip(pkmn_request["moves"], self.moves.values()):
-            assert Move.retrieve_id(move_request) == Move.retrieve_id(
-                move.id
-            ), f"{Move.retrieve_id(move_request)} != {Move.retrieve_id(move.id)}\nrequest: {pkmn_request}"
+        if not (
+            self._mimic_move is not None
+            and self._mimic_move.id in [m.id for m in self._moves.values()]
+        ):
+            # Ensures no duplicate move due to mimic copying an already-known move
+            for move_request, move in zip(pkmn_request["moves"], self.moves.values()):
+                assert Move.retrieve_id(move_request) == Move.retrieve_id(
+                    move.id
+                ), f"{Move.retrieve_id(move_request)} != {Move.retrieve_id(move.id)}\nrequest: {pkmn_request}"
         if self.ability is None:
+            # needed for ability initialization in start of game,
+            # done anyway in update_from_request()
             self.ability = pkmn_request["baseAbility"]
         assert pkmn_request["baseAbility"] == (
             self.base_ability or ""
@@ -237,10 +250,7 @@ def check_consistency(self, pkmn_request: Dict[str, Any], player_role: str):
             ), f"{pkmn_request['ability']} != {self.ability or ''}"
 
     def check_move_consistency(self, active_request: Dict[str, Any]):
-        if (
-            self.base_species in ["ditto", "mew"]
-            or "copycat" in [m.id for m in self.moves.values()]
-        ):
+        if self.base_species in ["ditto", "mew"]:
             return
         for move_request in active_request["moves"]:
             matches = [
@@ -252,7 +262,8 @@ def check_move_consistency(self, active_request: Dict[str, Any]):
             if not matches:
                 continue
             move = matches[0]
-            if "pp" in move_request and self._data.gen not in [7, 8]:
+            if "pp" in move_request and self._data.gen not in [1, 2, 3, 7, 8]:
+                # exclude early gens because of unreliable Showdown event messages
                 # exclude gen 7 and 8 because of Z-move and Max Move PP untrackability
                 assert (
                     move_request["pp"] == move.current_pp
@@ -368,6 +379,7 @@ def faint(self):
         self._current_hp = 0
         self._status = Status.FNT
         self.temporary_ability = None
+        self._mimic_move = None
         self._clear_effects()
 
     def forme_change(self, species: str):
@@ -563,6 +575,7 @@ def switch_out(self, fields: Dict[Field, int]):
         self._protect_counter = 0
         self.temporary_ability = None
         self._temporary_types = []
+        self._mimic_move = None
 
         if self._status == Status.TOX:
             self._status_counter = 0
@@ -603,7 +616,7 @@ def _update_from_pokedex(self, species: str, store_species: bool = True):
             self._possible_abilities = [
                 to_id_str(ability) for ability in dex_entry["abilities"].values()
             ]
-            if len(self._possible_abilities) == 1:
+            if len(self._possible_abilities) == 1 and self._data.gen >= 3:
                 self.ability = self._possible_abilities[0]
         else:
             self.forme_change_ability = None
@@ -955,6 +968,18 @@ def first_turn(self) -> bool:
         """
         return self._first_turn
 
+    @property
+    def forme_change_ability(self) -> Optional[str]:
+        """
+        :return: The pokemon's ability after changing forme. None if the pokemon hasn't changed forme.
+        :rtype: str, optional
+        """
+        return self._forme_change_ability
+
+    @forme_change_ability.setter
+    def forme_change_ability(self, ability: Optional[str]):
+        self._forme_change_ability = to_id_str(ability) if ability is not None else None
+
     @property
     def gender(self) -> Optional[PokemonGender]:
         """
@@ -1036,25 +1061,21 @@ def max_hp(self) -> int:
         """
         return self._max_hp or 0
 
-    @property
-    def forme_change_ability(self) -> Optional[str]:
-        """
-        :return: The pokemon's ability after changing forme. None if the pokemon hasn't changed forme.
-        :rtype: str, optional
-        """
-        return self._forme_change_ability
-
-    @forme_change_ability.setter
-    def forme_change_ability(self, ability: Optional[str]):
-        self._forme_change_ability = to_id_str(ability) if ability is not None else None
-
     @property
     def moves(self) -> Dict[str, Move]:
         """
         :return: A dictionary of the pokemon's known moves.
         :rtype: Dict[str, Move]
         """
-        return self._moves
+        if self._mimic_move is not None:
+            return dict(
+                [
+                    (k, v) if k != "mimic" else (self._mimic_move.id, self._mimic_move)
+                    for k, v in self._moves.items()
+                ]
+            )
+        else:
+            return self._moves
 
     @property
     def must_recharge(self) -> bool:

strict_integration_tests/test_strict.py

@@ -15,7 +15,7 @@ async def simple_cross_evaluation(n_battles, players):
 
 @pytest.mark.asyncio
 async def test_random_players():
-    for gen in range(4, 10):
+    for gen in range(1, 10):
         players = [
             RandomPlayer(
                 battle_format=f"gen{gen}randombattle", strict_battle_tracking=True
@@ -25,5 +25,5 @@ async def test_random_players():
             ),
         ]
         await asyncio.wait_for(
-            simple_cross_evaluation(100, players=players), timeout=60
+            simple_cross_evaluation(100, players=players), timeout=150
         )