Putting "pass" in message when battle order is None in DoubleBattleOrder

src/poke_env/environment/double_battle.py

@@ -130,6 +130,13 @@ def parse_request(self, request: Dict[str, Any]) -> None:
         if side["pokemon"]:
             self._player_role = side["pokemon"][0]["ident"][:2]
         self._update_team_from_request(side)
+        if self.player_role is not None:
+            self._active_pokemon[f"{self.player_role}a"] = self.team[
+                request["side"]["pokemon"][0]["ident"]
+            ]
+            self._active_pokemon[f"{self.player_role}b"] = self.team[
+                request["side"]["pokemon"][1]["ident"]
+            ]
 
         if "active" in request:
             for active_pokemon_number, active_request in enumerate(request["active"]):
@@ -139,41 +146,6 @@ def parse_request(self, request: Dict[str, Any]) -> None:
                     force_self_team=True,
                     details=pokemon_dict["details"],
                 )
-                if self.player_role is not None:
-                    if (
-                        active_pokemon_number == 0
-                        and f"{self.player_role}a" not in self._active_pokemon
-                    ):
-                        self._active_pokemon[f"{self.player_role}a"] = active_pokemon
-                    elif f"{self.player_role}b" not in self._active_pokemon:
-                        self._active_pokemon[f"{self.player_role}b"] = active_pokemon
-                    elif (
-                        active_pokemon_number == 0
-                        and self._active_pokemon[f"{self.player_role}a"].fainted
-                        and self._active_pokemon[f"{self.player_role}b"]
-                        == active_pokemon
-                    ):
-                        (
-                            self._active_pokemon[f"{self.player_role}a"],
-                            self._active_pokemon[f"{self.player_role}b"],
-                        ) = (
-                            self._active_pokemon[f"{self.player_role}b"],
-                            self._active_pokemon[f"{self.player_role}a"],
-                        )
-                    elif (
-                        active_pokemon_number == 1
-                        and self._active_pokemon[f"{self.player_role}b"].fainted
-                        and not active_pokemon.fainted
-                        and self._active_pokemon[f"{self.player_role}a"]
-                        == active_pokemon
-                    ):
-                        (
-                            self._active_pokemon[f"{self.player_role}a"],
-                            self._active_pokemon[f"{self.player_role}b"],
-                        ) = (
-                            self._active_pokemon[f"{self.player_role}b"],
-                            self._active_pokemon[f"{self.player_role}a"],
-                        )
 
                 if active_pokemon.fainted:
                     continue

src/poke_env/player/baselines.py

@@ -1,5 +1,5 @@
 import random
-from typing import List
+from typing import List, Optional
 
 from poke_env.environment.abstract_battle import AbstractBattle
 from poke_env.environment.double_battle import DoubleBattle
@@ -29,7 +29,7 @@ def choose_singles_move(self, battle: AbstractBattle):
         return self.choose_random_move(battle)
 
     def choose_doubles_move(self, battle: DoubleBattle):
-        orders: List[BattleOrder] = []
+        orders: List[Optional[BattleOrder]] = []
         switched_in = None
 
         if any(battle.force_switch):
@@ -51,7 +51,7 @@ def choose_doubles_move(self, battle: DoubleBattle):
             switches = [s for s in switches if s != switched_in]
 
             if not mon or mon.fainted:
-                orders.append(DefaultBattleOrder())
+                orders.append(None)
                 continue
             elif not moves and switches:
                 mon_to_switch_in = random.choice(switches)

src/poke_env/player/battle_order.py

@@ -73,9 +73,9 @@ def message(self) -> str:
                 + self.second_order.message.replace("/choose ", "")
             )
         elif self.first_order:
-            return self.first_order.message + ", default"
+            return self.first_order.message + ", pass"
         elif self.second_order:
-            return self.second_order.message + ", default"
+            return "/choose pass, " + self.second_order.message.replace("/choose ", "")
         else:
             return self.DEFAULT_ORDER
 
@@ -95,10 +95,11 @@ def join_orders(first_orders: List[BattleOrder], second_orders: List[BattleOrder
             if orders:
                 return orders
         elif first_orders:
-            return [DoubleBattleOrder(first_order=order) for order in first_orders]
+            return [DoubleBattleOrder(order, None) for order in first_orders]
         elif second_orders:
-            return [DoubleBattleOrder(first_order=order) for order in second_orders]
-        return [DefaultBattleOrder()]
+            return [DoubleBattleOrder(None, order) for order in second_orders]
+        else:
+            return [DoubleBattleOrder(None, None)]
 
 
 class ForfeitBattleOrder(BattleOrder):

src/poke_env/player/player.py

@@ -532,9 +532,7 @@ def choose_random_doubles_move(battle: DoubleBattle) -> BattleOrder:
                     second_switch_in = random.choice(available_switches)
                     second_order = BattleOrder(second_switch_in)
 
-            if first_order and second_order:
-                return DoubleBattleOrder(first_order, second_order)
-            return DoubleBattleOrder(first_order or second_order, None)
+            return DoubleBattleOrder(first_order, second_order)
 
         for (
             orders,

unit_tests/player/test_battle_orders.py

@@ -35,10 +35,8 @@ def test_double_orders():
         DoubleBattleOrder(mon, move).message
         == "/choose switch lugia, move selfdestruct 2"
     )
-    assert DoubleBattleOrder(mon).message == "/choose switch lugia, default"
-    assert (
-        DoubleBattleOrder(None, move).message == "/choose move selfdestruct 2, default"
-    )
+    assert DoubleBattleOrder(mon).message == "/choose switch lugia, pass"
+    assert DoubleBattleOrder(None, move).message == "/choose pass, move selfdestruct 2"
     assert DoubleBattleOrder().message == "/choose default"
 
     orders = [move, mon]
@@ -53,12 +51,12 @@ def test_double_orders():
         "/choose switch lugia, move selfdestruct 2",
     }
     assert first == {
-        "/choose move selfdestruct 2, default",
-        "/choose switch lugia, default",
+        "/choose move selfdestruct 2, pass",
+        "/choose switch lugia, pass",
     }
     assert second == {
-        "/choose move selfdestruct 2, default",
-        "/choose switch lugia, default",
+        "/choose pass, move selfdestruct 2",
+        "/choose pass, switch lugia",
     }
     assert none == {"/choose default"}
 

unit_tests/player/test_doubles_baselines.py

@@ -17,11 +17,11 @@ def test_doubles_max_damage_player():
     battle._active_pokemon["p1a"] = active_pikachu
 
     # calls player.choose_random_doubles_move(battle)
-    assert player.choose_move(battle).message == "/choose default, default"
+    assert player.choose_move(battle).message == "/choose default, pass"
 
     # calls player.choose_random_doubles_move(battle)
     battle._available_switches[0].append(Pokemon(species="ponyta", gen=8))
-    assert player.choose_move(battle).message == "/choose switch ponyta, default"
+    assert player.choose_move(battle).message == "/choose switch ponyta, pass"
 
     active_raichu = Pokemon(species="raichu", gen=8)
     active_raichu.switch_in()
@@ -65,12 +65,12 @@ def test_doubles_max_damage_player():
     # forced switch
     battle._force_switch = [True, False]
     assert player.choose_move(battle).message in [
-        "/choose switch ponyta, default",
+        "/choose switch ponyta, pass",
     ]
 
     battle._force_switch = [False, True]
     assert player.choose_move(battle).message in [
-        "/choose switch rapidash, default",
+        "/choose pass, switch rapidash",
     ]
 
     battle._force_switch = [True, True]