Merge 6866248b41 into bb86bdd2a6

[Balance] Add Scientist to Lab, Swimmer to Seabed to account for ME's
https://github.com/pagefaultgames/pokerogue/pull/6217
2025-08-08 00:19:29 +02:00 · 2025-08-06 04:21:20 +00:00 · 2025-08-05 19:57:51 -07:00 · 2025-08-05 16:35:58 -06:00 · 2025-08-05 00:05:04 -04:00 · 2025-08-05 00:04:55 -04:00
31 changed files with 643 additions and 303 deletions
--- a/src/@types/api/pokerogue-account-api.ts
+++ b/src/@types/api/pokerogue-account-api.ts
@ -15,3 +15,10 @@ export interface AccountRegisterRequest {
  username: string;
  password: string;
 }
+
+export interface AccountChangePwRequest {
+  password: string;
+}
+export interface AccountChangePwResponse {
+  success: boolean;
+}
--- a/src/data/balance/biomes.ts
+++ b/src/data/balance/biomes.ts
@ -1641,10 +1641,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: []
  },
  [BiomeId.PLAINS]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BREEDER, TrainerType.TWINS ],
@ -1652,10 +1649,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [ TrainerType.BLACK_BELT ],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.CILAN, TrainerType.CHILI, TrainerType.CRESS, TrainerType.CHEREN ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.CILAN, TrainerType.CHILI, TrainerType.CRESS, TrainerType.CHEREN ]
  },
  [BiomeId.GRASS]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BREEDER, TrainerType.SCHOOL_KID ],
@ -1663,10 +1657,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [ TrainerType.BLACK_BELT ],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.ERIKA ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.ERIKA ]
  },
  [BiomeId.TALL_GRASS]: {
    [BiomePoolTier.COMMON]: [],
@ -1674,10 +1665,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.GARDENIA, TrainerType.VIOLA, TrainerType.BRASSIUS ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.GARDENIA, TrainerType.VIOLA, TrainerType.BRASSIUS ]
  },
  [BiomeId.METROPOLIS]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BEAUTY, TrainerType.CLERK, TrainerType.CYCLIST, TrainerType.OFFICER, TrainerType.WAITER ],
@ -1685,10 +1673,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [ TrainerType.ARTIST, TrainerType.RICH_KID ],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.WHITNEY, TrainerType.NORMAN, TrainerType.IONO, TrainerType.LARRY ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.WHITNEY, TrainerType.NORMAN, TrainerType.IONO, TrainerType.LARRY ]
  },
  [BiomeId.FOREST]: {
    [BiomePoolTier.COMMON]: [ TrainerType.RANGER ],
@ -1696,10 +1681,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.BUGSY, TrainerType.BURGH, TrainerType.KATY ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.BUGSY, TrainerType.BURGH, TrainerType.KATY ]
  },
  [BiomeId.SEA]: {
    [BiomePoolTier.COMMON]: [ TrainerType.SAILOR, TrainerType.SWIMMER ],
@ -1707,10 +1689,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.MARLON ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.MARLON ]
  },
  [BiomeId.SWAMP]: {
    [BiomePoolTier.COMMON]: [ TrainerType.PARASOL_LADY ],
@ -1718,10 +1697,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [ TrainerType.BLACK_BELT ],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.JANINE, TrainerType.ROXIE ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.JANINE, TrainerType.ROXIE ]
  },
  [BiomeId.BEACH]: {
    [BiomePoolTier.COMMON]: [ TrainerType.FISHERMAN, TrainerType.SAILOR ],
@ -1729,10 +1705,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [ TrainerType.BLACK_BELT ],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.MISTY, TrainerType.KOFU ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.MISTY, TrainerType.KOFU ]
  },
  [BiomeId.LAKE]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BREEDER, TrainerType.FISHERMAN, TrainerType.PARASOL_LADY ],
@ -1740,21 +1713,15 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [ TrainerType.BLACK_BELT ],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.CRASHER_WAKE ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.CRASHER_WAKE ]
  },
  [BiomeId.SEABED]: {
-    [BiomePoolTier.COMMON]: [],
+    [BiomePoolTier.COMMON]: [ TrainerType.SWIMMER ],
    [BiomePoolTier.UNCOMMON]: [],
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.JUAN ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.JUAN ]
  },
  [BiomeId.MOUNTAIN]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BACKPACKER, TrainerType.BLACK_BELT, TrainerType.HIKER ],
@ -1762,10 +1729,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.FALKNER, TrainerType.WINONA, TrainerType.SKYLA ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.FALKNER, TrainerType.WINONA, TrainerType.SKYLA ]
  },
  [BiomeId.BADLANDS]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BACKPACKER, TrainerType.HIKER ],
@ -1773,10 +1737,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.CLAY, TrainerType.GRANT ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.CLAY, TrainerType.GRANT ]
  },
  [BiomeId.CAVE]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BACKPACKER, TrainerType.HIKER ],
@ -1784,10 +1745,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.BROCK, TrainerType.ROXANNE, TrainerType.ROARK ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.BROCK, TrainerType.ROXANNE, TrainerType.ROARK ]
  },
  [BiomeId.DESERT]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BACKPACKER, TrainerType.SCIENTIST ],
@ -1795,10 +1753,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.GORDIE ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.GORDIE ]
  },
  [BiomeId.ICE_CAVE]: {
    [BiomePoolTier.COMMON]: [ TrainerType.SNOW_WORKER ],
@ -1806,10 +1761,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.PRYCE, TrainerType.BRYCEN, TrainerType.WULFRIC, TrainerType.GRUSHA ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.PRYCE, TrainerType.BRYCEN, TrainerType.WULFRIC, TrainerType.GRUSHA ]
  },
  [BiomeId.MEADOW]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BEAUTY, TrainerType.MUSICIAN, TrainerType.PARASOL_LADY ],
@ -1817,10 +1769,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.LENORA, TrainerType.MILO ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.LENORA, TrainerType.MILO ]
  },
  [BiomeId.POWER_PLANT]: {
    [BiomePoolTier.COMMON]: [ TrainerType.GUITARIST, TrainerType.WORKER ],
@ -1828,10 +1777,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.VOLKNER, TrainerType.ELESA, TrainerType.CLEMONT ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.VOLKNER, TrainerType.ELESA, TrainerType.CLEMONT ]
  },
  [BiomeId.VOLCANO]: {
    [BiomePoolTier.COMMON]: [ TrainerType.FIREBREATHER ],
@ -1839,10 +1785,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.BLAINE, TrainerType.FLANNERY, TrainerType.KABU ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.BLAINE, TrainerType.FLANNERY, TrainerType.KABU ]
  },
  [BiomeId.GRAVEYARD]: {
    [BiomePoolTier.COMMON]: [ TrainerType.PSYCHIC ],
@ -1850,10 +1793,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.MORTY, TrainerType.ALLISTER, TrainerType.RYME ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.MORTY, TrainerType.ALLISTER, TrainerType.RYME ]
  },
  [BiomeId.DOJO]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BLACK_BELT ],
@ -1861,10 +1801,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.BRAWLY, TrainerType.MAYLENE, TrainerType.KORRINA, TrainerType.BEA ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.BRAWLY, TrainerType.MAYLENE, TrainerType.KORRINA, TrainerType.BEA ]
  },
  [BiomeId.FACTORY]: {
    [BiomePoolTier.COMMON]: [ TrainerType.WORKER ],
@ -1872,10 +1809,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.JASMINE, TrainerType.BYRON ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.JASMINE, TrainerType.BYRON ]
  },
  [BiomeId.RUINS]: {
    [BiomePoolTier.COMMON]: [ TrainerType.PSYCHIC, TrainerType.SCIENTIST ],
@ -1883,10 +1817,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.SABRINA, TrainerType.TATE, TrainerType.LIZA, TrainerType.TULIP ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.SABRINA, TrainerType.TATE, TrainerType.LIZA, TrainerType.TULIP ]
  },
  [BiomeId.WASTELAND]: {
    [BiomePoolTier.COMMON]: [ TrainerType.VETERAN ],
@ -1894,10 +1825,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.CLAIR, TrainerType.DRAYDEN, TrainerType.RAIHAN ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.CLAIR, TrainerType.DRAYDEN, TrainerType.RAIHAN ]
  },
  [BiomeId.ABYSS]: {
    [BiomePoolTier.COMMON]: [],
@ -1905,10 +1833,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.MARNIE ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.MARNIE ]
  },
  [BiomeId.SPACE]: {
    [BiomePoolTier.COMMON]: [],
@ -1916,10 +1841,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.OLYMPIA ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.OLYMPIA ]
  },
  [BiomeId.CONSTRUCTION_SITE]: {
    [BiomePoolTier.COMMON]: [ TrainerType.OFFICER, TrainerType.WORKER ],
@ -1927,10 +1849,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.LT_SURGE, TrainerType.CHUCK, TrainerType.WATTSON ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.LT_SURGE, TrainerType.CHUCK, TrainerType.WATTSON ]
  },
  [BiomeId.JUNGLE]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BACKPACKER, TrainerType.RANGER ],
@ -1938,10 +1857,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.RAMOS ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.RAMOS ]
  },
  [BiomeId.FAIRY_CAVE]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BEAUTY ],
@ -1949,10 +1865,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.VALERIE, TrainerType.OPAL, TrainerType.BEDE ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.VALERIE, TrainerType.OPAL, TrainerType.BEDE ]
  },
  [BiomeId.TEMPLE]: {
    [BiomePoolTier.COMMON]: [],
@ -1960,10 +1873,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.FANTINA ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.FANTINA ]
  },
  [BiomeId.SLUM]: {
    [BiomePoolTier.COMMON]: [ TrainerType.BIKER, TrainerType.OFFICER, TrainerType.ROUGHNECK ],
@ -1971,10 +1881,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.PIERS ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.PIERS ]
  },
  [BiomeId.SNOWY_FOREST]: {
    [BiomePoolTier.COMMON]: [ TrainerType.SNOW_WORKER ],
@ -1982,10 +1889,7 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.CANDICE, TrainerType.MELONY ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.CANDICE, TrainerType.MELONY ]
  },
  [BiomeId.ISLAND]: {
    [BiomePoolTier.COMMON]: [ TrainerType.RICH_KID ],
@ -1993,21 +1897,15 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.NESSA ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.NESSA ]
  },
  [BiomeId.LABORATORY]: {
-    [BiomePoolTier.COMMON]: [],
+    [BiomePoolTier.COMMON]: [ TrainerType.SCIENTIST ],
    [BiomePoolTier.UNCOMMON]: [],
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [ TrainerType.GIOVANNI ],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: [ TrainerType.GIOVANNI ]
  },
  [BiomeId.END]: {
    [BiomePoolTier.COMMON]: [],
@ -2015,13 +1913,9 @@ export const biomeTrainerPools: BiomeTrainerPools = {
    [BiomePoolTier.RARE]: [],
    [BiomePoolTier.SUPER_RARE]: [],
    [BiomePoolTier.ULTRA_RARE]: [],
-    [BiomePoolTier.BOSS]: [],
-    [BiomePoolTier.BOSS_RARE]: [],
-    [BiomePoolTier.BOSS_SUPER_RARE]: [],
-    [BiomePoolTier.BOSS_ULTRA_RARE]: []
+    [BiomePoolTier.BOSS]: []
  }
 };
-
 export function initBiomes() {
  const pokemonBiomes = [
    [ SpeciesId.BULBASAUR, PokemonType.GRASS, PokemonType.POISON, [
--- a/src/enums/ui-mode.ts
+++ b/src/enums/ui-mode.ts
@ -43,5 +43,6 @@ export enum UiMode {
  TEST_DIALOGUE,
  AUTO_COMPLETE,
  ADMIN,
-  MYSTERY_ENCOUNTER
+  MYSTERY_ENCOUNTER,
+  CHANGE_PASSWORD_FORM,
 }
--- a/src/field/arena.ts
+++ b/src/field/arena.ts
@ -145,7 +145,7 @@ export class Arena {
            ? BiomePoolTier.BOSS_SUPER_RARE
            : BiomePoolTier.BOSS_ULTRA_RARE;
    console.log(BiomePoolTier[tier]);
-    while (!this.pokemonPool[tier].length) {
+    while (!this.pokemonPool[tier]?.length) {
      console.log(`Downgraded rarity tier from ${BiomePoolTier[tier]} to ${BiomePoolTier[tier - 1]}`);
      tier--;
    }
--- a/src/plugins/api/pokerogue-account-api.ts
+++ b/src/plugins/api/pokerogue-account-api.ts
@ -1,6 +1,7 @@
 import { ApiBase } from "#api/api-base";
 import { SESSION_ID_COOKIE_NAME } from "#app/constants";
 import type {
+  AccountChangePwRequest,
  AccountInfoResponse,
  AccountLoginRequest,
  AccountLoginResponse,
@ -95,4 +96,19 @@ export class PokerogueAccountApi extends ApiBase {

    removeCookie(SESSION_ID_COOKIE_NAME); // we are always clearing the cookie.
  }
+
+  public async changePassword(changePwData: AccountChangePwRequest) {
+    try {
+      const response = await this.doPost("/account/changepw", changePwData, "form-urlencoded");
+      if (response.ok) {
+        return null;
+      }
+      console.warn("Change password failed!", response.status, response.statusText);
+      return response.text();
+    } catch (err) {
+      console.warn("Change password failed!", err);
+    }
+
+    return "Unknown error!";
+  }
 }
--- a/src/ui/change-password-form-ui-handler.ts
+++ b/src/ui/change-password-form-ui-handler.ts
@ -0,0 +1,124 @@
+import { globalScene } from "#app/global-scene";
+import { pokerogueApi } from "#app/plugins/api/pokerogue-api";
+import { UiMode } from "#enums/ui-mode";
+import type { InputFieldConfig } from "#ui/form-modal-ui-handler";
+import { FormModalUiHandler } from "#ui/form-modal-ui-handler";
+import type { ModalConfig } from "#ui/modal-ui-handler";
+import i18next from "i18next";
+
+export class ChangePasswordFormUiHandler extends FormModalUiHandler {
+  private readonly ERR_PASSWORD: string = "invalid password";
+  private readonly ERR_ACCOUNT_EXIST: string = "account doesn't exist";
+  private readonly ERR_PASSWORD_MISMATCH: string = "password doesn't match";
+
+  constructor(mode: UiMode | null = null) {
+    super(mode);
+  }
+
+  setup(): void {
+    super.setup();
+  }
+
+  override getModalTitle(_config?: ModalConfig): string {
+    return i18next.t("menu:changePassword");
+  }
+
+  override getWidth(_config?: ModalConfig): number {
+    return 160;
+  }
+
+  override getMargin(_config?: ModalConfig): [number, number, number, number] {
+    return [0, 0, 48, 0];
+  }
+
+  override getButtonLabels(_config?: ModalConfig): string[] {
+    return [i18next.t("settings:buttonSubmit"), i18next.t("menu:cancel")];
+  }
+
+  override getReadableErrorMessage(error: string): string {
+    const colonIndex = error?.indexOf(":");
+    if (colonIndex > 0) {
+      error = error.slice(0, colonIndex);
+    }
+    switch (error) {
+      case this.ERR_PASSWORD:
+        return i18next.t("menu:invalidRegisterPassword");
+      case this.ERR_ACCOUNT_EXIST:
+        return i18next.t("menu:accountNonExistent");
+      case this.ERR_PASSWORD_MISMATCH:
+        return i18next.t("menu:passwordNotMatchingConfirmPassword");
+    }
+
+    return super.getReadableErrorMessage(error);
+  }
+
+  override getInputFieldConfigs(): InputFieldConfig[] {
+    const inputFieldConfigs: InputFieldConfig[] = [];
+    inputFieldConfigs.push({
+      label: i18next.t("menu:password"),
+      isPassword: true,
+    });
+    inputFieldConfigs.push({
+      label: i18next.t("menu:confirmPassword"),
+      isPassword: true,
+    });
+    return inputFieldConfigs;
+  }
+
+  override show(args: [ModalConfig, ...any]): boolean {
+    if (super.show(args)) {
+      const config = args[0];
+      const originalSubmitAction = this.submitAction;
+      this.submitAction = () => {
+        if (globalScene.tweens.getTweensOf(this.modalContainer).length === 0) {
+          // Prevent overlapping overrides on action modification
+          this.submitAction = originalSubmitAction;
+          this.sanitizeInputs();
+          globalScene.ui.setMode(UiMode.LOADING, { buttonActions: [] });
+          const onFail = (error: string | null) => {
+            globalScene.ui.setMode(UiMode.CHANGE_PASSWORD_FORM, Object.assign(config, { errorMessage: error?.trim() }));
+            globalScene.ui.playError();
+          };
+          const [passwordInput, confirmPasswordInput] = this.inputs;
+          if (!passwordInput?.text) {
+            return onFail(this.getReadableErrorMessage("invalid password"));
+          }
+          if (passwordInput.text !== confirmPasswordInput.text) {
+            return onFail(this.ERR_PASSWORD_MISMATCH);
+          }
+
+          pokerogueApi.account.changePassword({ password: passwordInput.text }).then(error => {
+            if (!error && originalSubmitAction) {
+              globalScene.ui.playSelect();
+              originalSubmitAction();
+              // Only clear inputs if the action was successful
+              for (const input of this.inputs) {
+                input.setText("");
+              }
+            } else {
+              onFail(error);
+            }
+          });
+        }
+      };
+      // Upon pressing cancel, the inputs should be cleared
+      const originalCancelAction = this.cancelAction;
+      this.cancelAction = () => {
+        globalScene.ui.playSelect();
+        for (const input of this.inputs) {
+          input.setText("");
+        }
+        originalCancelAction?.();
+      };
+
+      return true;
+    }
+
+    return false;
+  }
+
+  override clear() {
+    super.clear();
+    this.setMouseCursorStyle("default"); //reset cursor
+  }
+}
--- a/src/ui/form-modal-ui-handler.ts
+++ b/src/ui/form-modal-ui-handler.ts
@ -19,6 +19,7 @@ export abstract class FormModalUiHandler extends ModalUiHandler {
  protected inputs: InputText[];
  protected errorMessage: Phaser.GameObjects.Text;
  protected submitAction: Function | null;
+  protected cancelAction: (() => void) | null;
  protected tween: Phaser.Tweens.Tween;
  protected formLabels: Phaser.GameObjects.Text[];

@ -126,22 +127,37 @@ export abstract class FormModalUiHandler extends ModalUiHandler {
    });
  }

-  show(args: any[]): boolean {
+  override show(args: any[]): boolean {
    if (super.show(args)) {
      this.inputContainers.map(ic => ic.setVisible(true));

      const config = args[0] as FormModalConfig;

      this.submitAction = config.buttonActions.length ? config.buttonActions[0] : null;
+      this.cancelAction = config.buttonActions[1] ?? null;

-      if (this.buttonBgs.length) {
-        this.buttonBgs[0].off("pointerdown");
-        this.buttonBgs[0].on("pointerdown", () => {
-          if (this.submitAction && globalScene.tweens.getTweensOf(this.modalContainer).length === 0) {
-            this.submitAction();
+      // #region: Override button pointerDown
+      // Override the pointerDown event for the buttonBgs to call the `submitAction` and `cancelAction`
+      // properties that we set above, allowing their behavior to change after this method terminates
+      // Some subclasses use this to add behavior to the submit and cancel action
+
+      this.buttonBgs[0].off("pointerdown");
+      this.buttonBgs[0].on("pointerdown", () => {
+        if (this.submitAction && globalScene.tweens.getTweensOf(this.modalContainer).length === 0) {
+          this.submitAction();
+        }
+      });
+      const cancelBg = this.buttonBgs[1];
+      if (cancelBg) {
+        cancelBg.off("pointerdown");
+        cancelBg.on("pointerdown", () => {
+          // The seemingly redundant cancelAction check is intentionally left in as a defensive programming measure
+          if (this.cancelAction && globalScene.tweens.getTweensOf(this.modalContainer).length === 0) {
+            this.cancelAction();
          }
        });
      }
+      //#endregion: Override pointerDown events

      this.modalContainer.y += 24;
      this.modalContainer.setAlpha(0);
--- a/src/ui/menu-ui-handler.ts
+++ b/src/ui/menu-ui-handler.ts
@ -311,6 +311,17 @@ export class MenuUiHandler extends MessageUiHandler {
        },
        keepOpen: true,
      },
+      {
+        // Note: i18n key is under `menu`, not `menuUiHandler` to avoid duplication
+        label: i18next.t("menu:changePassword"),
+        handler: () => {
+          ui.setOverlayMode(UiMode.CHANGE_PASSWORD_FORM, {
+            buttonActions: [() => ui.revertMode(), () => ui.revertMode()],
+          });
+          return true;
+        },
+        keepOpen: true,
+      },
      {
        label: i18next.t("menuUiHandler:consentPreferences"),
        handler: () => {
--- a/src/ui/modal-ui-handler.ts
+++ b/src/ui/modal-ui-handler.ts
@ -7,7 +7,7 @@ import { UiHandler } from "#ui/ui-handler";
 import { addWindow, WindowVariant } from "#ui/ui-theme";

 export interface ModalConfig {
-  buttonActions: Function[];
+  buttonActions: ((...args: any[]) => any)[];
 }

 export abstract class ModalUiHandler extends UiHandler {
--- a/src/ui/ui.ts
+++ b/src/ui/ui.ts
@ -13,6 +13,7 @@ import { BallUiHandler } from "#ui/ball-ui-handler";
 import { BattleMessageUiHandler } from "#ui/battle-message-ui-handler";
 import type { BgmBar } from "#ui/bgm-bar";
 import { GameChallengesUiHandler } from "#ui/challenges-select-ui-handler";
+import { ChangePasswordFormUiHandler } from "#ui/change-password-form-ui-handler";
 import { CommandUiHandler } from "#ui/command-ui-handler";
 import { ConfirmUiHandler } from "#ui/confirm-ui-handler";
 import { EggGachaUiHandler } from "#ui/egg-gacha-ui-handler";
@ -102,6 +103,7 @@ const noTransitionModes = [
  UiMode.ADMIN,
  UiMode.MYSTERY_ENCOUNTER,
  UiMode.RUN_INFO,
+  UiMode.CHANGE_PASSWORD_FORM,
 ];

 export class UI extends Phaser.GameObjects.Container {
@ -172,6 +174,7 @@ export class UI extends Phaser.GameObjects.Container {
      new AutoCompleteUiHandler(),
      new AdminUiHandler(),
      new MysteryEncounterUiHandler(),
+      new ChangePasswordFormUiHandler(),
    ];
  }

--- a/test/@types/test-helpers.ts
+++ b/test/@types/test-helpers.ts
@ -0,0 +1,27 @@
+import type { AtLeastOne, NonFunctionPropertiesRecursive as nonFunc } from "#types/type-helpers";
+
+/**
+ * Helper type to admit an object containing the given properties
+ * _and at least 1 other non-function property_.
+ * @example
+ * ```ts
+ * type foo = {
+ *   qux: 1 | 2 | 3,
+ *   bar: number,
+ *   baz: string
+ *   quux: () => void; // ignored!
+ * }
+ *
+ * type quxAndSomethingElse = OneOther<foo, "qux">
+ *
+ * const good1: quxAndSomethingElse = {qux: 1, bar: 3} // OK!
+ * const good2: quxAndSomethingElse = {qux: 2, baz: "4", bar: 12} // OK!
+ * const bad1: quxAndSomethingElse = {baz: "4", bar: 12} // Errors because `qux` is required
+ * const bad2: quxAndSomethingElse = {qux: 1} // Errors because at least 1 thing _other_ than `qux` is required
+ * ```
+ * @typeParam O - The object to source keys from
+ * @typeParam K - One or more of O's keys to render mandatory
+ */
+export type OneOther<O extends object, K extends keyof O> = AtLeastOne<Omit<nonFunc<O>, K>> & {
+  [key in K]: O[K];
+};
--- a/test/@types/vitest.d.ts
+++ b/test/@types/vitest.d.ts
@ -1,23 +1,32 @@
 import type { TerrainType } from "#app/data/terrain";
+import type { ArenaTag } from "#data/arena-tag";
 import type { AbilityId } from "#enums/ability-id";
+import type { ArenaTagType } from "#enums/arena-tag-type";
 import type { BattlerTagType } from "#enums/battler-tag-type";
 import type { MoveId } from "#enums/move-id";
 import type { PokemonType } from "#enums/pokemon-type";
 import type { BattleStat, EffectiveStat, Stat } from "#enums/stat";
 import type { StatusEffect } from "#enums/status-effect";
 import type { WeatherType } from "#enums/weather-type";
+import type { Arena } from "#field/arena";
 import type { Pokemon } from "#field/pokemon";
-import type { ToHaveEffectiveStatMatcherOptions } from "#test/test-utils/matchers/to-have-effective-stat";
+import type { toHaveEffectiveStatOptions } from "#test/test-utils/matchers/to-have-effective-stat";
 import type { expectedStatusType } from "#test/test-utils/matchers/to-have-status-effect";
 import type { toHaveTypesOptions } from "#test/test-utils/matchers/to-have-types";
 import type { TurnMove } from "#types/turn-move";
 import type { AtLeastOne } from "#types/type-helpers";
+import type { toDmgValue } from "utils/common";
 import type { expect } from "vitest";
+import type { PositionalTag } from "#data/positional-tags/positional-tag";
+import { PositionalTagType } from "#enums/positional-tag-type";
 import type Overrides from "#app/overrides";
+import type { ArenaTagSide } from "#enums/arena-tag-side";
 import type { PokemonMove } from "#moves/pokemon-move";
+import { toHaveArenaTagOptions } from "#test/test-utils/matchers/to-have-arena-tag";
+import { toHavePositionalTagOptions } from "#test/test-utils/matchers/to-have-positional-tag";

 declare module "vitest" {
-  interface Assertion {
+  interface Assertion<T> {
    /**
     * Check whether an array contains EXACTLY the given items (in any order).
     *
@ -27,45 +36,9 @@ declare module "vitest" {
     * @param expected - The expected contents of the array, in any order
     * @see {@linkcode expect.arrayContaining}
     */
-    toEqualArrayUnsorted<E>(expected: E[]): void;
+    toEqualArrayUnsorted(expected: T[]): void;

-    /**
-     * Check whether a {@linkcode Pokemon}'s current typing includes the given types.
-     *
-     * @param expected - The expected types (in any order)
-     * @param options - The options passed to the matcher
-     */
-    toHaveTypes(expected: [PokemonType, ...PokemonType[]], options?: toHaveTypesOptions): void;
-
-    /**
-     * Matcher to check the contents of a {@linkcode Pokemon}'s move history.
-     *
-     * @param expectedValue - The expected value; can be a {@linkcode MoveId} or a partially filled {@linkcode TurnMove}
-     * containing the desired properties to check
-     * @param index - The index of the move history entry to check, in order from most recent to least recent.
-     * Default `0` (last used move)
-     * @see {@linkcode Pokemon.getLastXMoves}
-     */
-    toHaveUsedMove(expected: MoveId | AtLeastOne<TurnMove>, index?: number): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon}'s effective stat is as expected
-     * (checked after all stat value modifications).
-     *
-     * @param stat - The {@linkcode EffectiveStat} to check
-     * @param expectedValue - The expected value of {@linkcode stat}
-     * @param options - (Optional) The {@linkcode ToHaveEffectiveStatMatcherOptions}
-     * @remarks
-     * If you want to check the stat **before** modifiers are applied, use {@linkcode Pokemon.getStat} instead.
-     */
-    toHaveEffectiveStat(stat: EffectiveStat, expectedValue: number, options?: ToHaveEffectiveStatMatcherOptions): void;
-
-    /**
-     * Check whether a {@linkcode Pokemon} has taken a specific amount of damage.
-     * @param expectedDamageTaken - The expected amount of damage taken
-     * @param roundDown - Whether to round down {@linkcode expectedDamageTaken} with {@linkcode toDmgValue}; default `true`
-     */
-    toHaveTakenDamage(expectedDamageTaken: number, roundDown?: boolean): void;
+    // #region Arena Matchers

    /**
     * Check whether the current {@linkcode WeatherType} is as expected.
@ -80,9 +53,63 @@ declare module "vitest" {
    toHaveTerrain(expectedTerrainType: TerrainType): void;

    /**
-     * Check whether a {@linkcode Pokemon} is at full HP.
+     * Check whether the current {@linkcode Arena} contains the given {@linkcode ArenaTag}.
+     * @param expectedTag - A partially-filled {@linkcode ArenaTag} containing the desired properties
     */
-    toHaveFullHp(): void;
+    toHaveArenaTag<A extends ArenaTagType>(expectedTag: toHaveArenaTagOptions<A>): void;
+    /**
+     * Check whether the current {@linkcode Arena} contains the given {@linkcode ArenaTag}.
+     * @param expectedType - The {@linkcode ArenaTagType} of the desired tag
+     * @param side - The {@linkcode ArenaTagSide | side of the field} the tag should affect, or
+     * {@linkcode ArenaTagSide.BOTH} to check both sides;
+     * default `ArenaTagSide.BOTH`
+     */
+    toHaveArenaTag(expectedType: ArenaTagType, side?: ArenaTagSide): void;
+
+    /**
+     * Check whether the current {@linkcode Arena} contains the given {@linkcode PositionalTag}.
+     * @param expectedTag - A partially-filled {@linkcode PositionalTag} containing the desired properties
+     */
+    toHavePositionalTag<P extends PositionalTagType>(expectedTag: toHavePositionalTagOptions<P>): void;
+    /**
+     * Check whether the current {@linkcode Arena} contains the given number of {@linkcode PositionalTag}s.
+     * @param expectedType - The {@linkcode PositionalTagType} of the desired tag
+     * @param count - The number of instances of {@linkcode expectedType} that should be active;
+     * defaults to `1` and must be within the range `[0, 4]`
+     */
+    toHavePositionalTag(expectedType: PositionalTagType, count?: number): void;
+
+    // #endregion Arena Matchers
+
+    // #region Pokemon Matchers
+
+    /**
+     * Check whether a {@linkcode Pokemon}'s current typing includes the given types.
+     * @param expectedTags - The expected {@linkcode PokemonType}s to check against; must have length `>0`
+     * @param options - The {@linkcode toHaveTypesOptions | options} passed to the matcher
+     */
+    toHaveTypes(expectedTags: PokemonType[], options?: toHaveTypesOptions): void;
+
+    /**
+     * Check whether a {@linkcode Pokemon} has used a move matching the given criteria.
+     * @param expectedMove - The {@linkcode MoveId} the Pokemon is expected to have used,
+     * or a partially filled {@linkcode TurnMove} containing the desired properties to check
+     * @param index - The index of the move history entry to check, in order from most recent to least recent.
+     * Default `0` (last used move)
+     * @see {@linkcode Pokemon.getLastXMoves}
+     */
+    toHaveUsedMove(expectedMove: MoveId | AtLeastOne<TurnMove>, index?: number): void;
+
+    /**
+     * Check whether a {@linkcode Pokemon}'s effective stat is as expected
+     * (checked after all stat value modifications).
+     * @param stat - The {@linkcode EffectiveStat} to check
+     * @param expectedValue - The expected value of {@linkcode stat}
+     * @param options - The {@linkcode toHaveEffectiveStatOptions | options} passed to the matcher
+     * @remarks
+     * If you want to check the stat **before** modifiers are applied, use {@linkcode Pokemon.getStat} instead.
+     */
+    toHaveEffectiveStat(stat: EffectiveStat, expectedValue: number, options?: toHaveEffectiveStatOptions): void;

    /**
     * Check whether a {@linkcode Pokemon} has a specific {@linkcode StatusEffect | non-volatile status effect}.
@ -106,7 +133,7 @@ declare module "vitest" {

    /**
     * Check whether a {@linkcode Pokemon} has applied a specific {@linkcode AbilityId}.
-     * @param expectedAbilityId - The expected {@linkcode AbilityId}
+     * @param expectedAbilityId - The expected {@linkcode AbilityId} to check for
     */
    toHaveAbilityApplied(expectedAbilityId: AbilityId): void;

@ -116,24 +143,36 @@ declare module "vitest" {
     */
    toHaveHp(expectedHp: number): void;

+    /**
+     * Check whether a {@linkcode Pokemon} has taken a specific amount of damage.
+     * @param expectedDamageTaken - The expected amount of damage taken
+     * @param roundDown - Whether to round down {@linkcode expectedDamageTaken} with {@linkcode toDmgValue}; default `true`
+     */
+    toHaveTakenDamage(expectedDamageTaken: number, roundDown?: boolean): void;
+
    /**
     * Check whether a {@linkcode Pokemon} is currently fainted (as determined by {@linkcode Pokemon.isFainted}).
     * @remarks
-     * When checking whether an enemy wild Pokemon is fainted, one must reference it in a variable _before_ the fainting effect occurs
-     * as otherwise the Pokemon will be GC'ed and rendered `undefined`.
+     * When checking whether an enemy wild Pokemon is fainted, one must store a reference to it in a variable _before_ the fainting effect occurs,
+     * as otherwise the Pokemon will be removed from the field and garbage collected.
     */
    toHaveFainted(): void;

+    /**
+     * Check whether a {@linkcode Pokemon} is at full HP.
+     */
+    toHaveFullHp(): void;
    /**
     * Check whether a {@linkcode Pokemon} has consumed the given amount of PP for one of its moves.
-     * @param expectedValue - The {@linkcode MoveId} of the {@linkcode PokemonMove} that should have consumed PP
+     * @param moveId - The {@linkcode MoveId} of the {@linkcode PokemonMove} that should have consumed PP
     * @param ppUsed - The numerical amount of PP that should have been consumed,
     * or `all` to indicate the move should be _out_ of PP
     * @remarks
-     * If the Pokemon's moveset has been set via {@linkcode Overrides.MOVESET_OVERRIDE}/{@linkcode Overrides.OPP_MOVESET_OVERRIDE},
-     * does not contain {@linkcode expectedMove}
-     * or contains the desired move more than once, this will fail the test.
+     * If the Pokemon's moveset has been set via {@linkcode Overrides.MOVESET_OVERRIDE}/{@linkcode Overrides.OPP_MOVESET_OVERRIDE}
+     * or does not contain exactly 1 copy of {@linkcode moveId}, this will fail the test.
     */
-    toHaveUsedPP(expectedMove: MoveId, ppUsed: number | "all"): void;
+    toHaveUsedPP(moveId: MoveId, ppUsed: number | "all"): void;
+
+    // #region Pokemon Matchers
  }
 }
--- a/test/matchers.setup.ts
+++ b/test/matchers.setup.ts
@ -1,10 +1,12 @@
 import { toEqualArrayUnsorted } from "#test/test-utils/matchers/to-equal-array-unsorted";
 import { toHaveAbilityApplied } from "#test/test-utils/matchers/to-have-ability-applied";
+import { toHaveArenaTag } from "#test/test-utils/matchers/to-have-arena-tag";
 import { toHaveBattlerTag } from "#test/test-utils/matchers/to-have-battler-tag";
 import { toHaveEffectiveStat } from "#test/test-utils/matchers/to-have-effective-stat";
 import { toHaveFainted } from "#test/test-utils/matchers/to-have-fainted";
 import { toHaveFullHp } from "#test/test-utils/matchers/to-have-full-hp";
 import { toHaveHp } from "#test/test-utils/matchers/to-have-hp";
+import { toHavePositionalTag } from "#test/test-utils/matchers/to-have-positional-tag";
 import { toHaveStatStage } from "#test/test-utils/matchers/to-have-stat-stage";
 import { toHaveStatusEffect } from "#test/test-utils/matchers/to-have-status-effect";
 import { toHaveTakenDamage } from "#test/test-utils/matchers/to-have-taken-damage";
@ -22,18 +24,20 @@ import { expect } from "vitest";

 expect.extend({
  toEqualArrayUnsorted,
+  toHaveWeather,
+  toHaveTerrain,
+  toHaveArenaTag,
+  toHavePositionalTag,
  toHaveTypes,
  toHaveUsedMove,
  toHaveEffectiveStat,
-  toHaveTakenDamage,
-  toHaveWeather,
-  toHaveTerrain,
-  toHaveFullHp,
  toHaveStatusEffect,
  toHaveStatStage,
  toHaveBattlerTag,
  toHaveAbilityApplied,
  toHaveHp,
+  toHaveTakenDamage,
+  toHaveFullHp,
  toHaveFainted,
  toHaveUsedPP,
 });
--- a/test/moves/wish.test.ts
+++ b/test/moves/wish.test.ts
@ -39,15 +39,6 @@ describe("Move - Wish", () => {
      .enemyLevel(100);
  });

-  /**
-   * Expect that wish is active with the specified number of attacks.
-   * @param numAttacks - The number of wish instances that should be queued; default `1`
-   */
-  function expectWishActive(numAttacks = 1) {
-    const wishes = game.scene.arena.positionalTagManager["tags"].filter(t => t.tagType === PositionalTagType.WISH);
-    expect(wishes).toHaveLength(numAttacks);
-  }
-
  it("should heal the Pokemon in the current slot for 50% of the user's maximum HP", async () => {
    await game.classicMode.startBattle([SpeciesId.ALOMOMOLA, SpeciesId.BLISSEY]);

@ -58,19 +49,19 @@ describe("Move - Wish", () => {
    game.move.use(MoveId.WISH);
    await game.toNextTurn();

-    expectWishActive();
+    expect(game).toHavePositionalTag(PositionalTagType.WISH);

    game.doSwitchPokemon(1);
    await game.toEndOfTurn();

-    expectWishActive(0);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH, 0);
    expect(game.textInterceptor.logs).toContain(
      i18next.t("arenaTag:wishTagOnAdd", {
        pokemonNameWithAffix: getPokemonNameWithAffix(alomomola),
      }),
    );
-    expect(alomomola.hp).toBe(1);
-    expect(blissey.hp).toBe(toDmgValue(alomomola.getMaxHp() / 2) + 1);
+    expect(alomomola).toHaveHp(1);
+    expect(blissey).toHaveHp(toDmgValue(alomomola.getMaxHp() / 2) + 1);
  });

  it("should work if the user has full HP, but not if it already has an active Wish", async () => {
@ -82,13 +73,13 @@ describe("Move - Wish", () => {
    game.move.use(MoveId.WISH);
    await game.toNextTurn();

-    expectWishActive();
+    expect(game).toHavePositionalTag(PositionalTagType.WISH);

    game.move.use(MoveId.WISH);
    await game.toEndOfTurn();

    expect(alomomola.hp).toBe(toDmgValue(alomomola.getMaxHp() / 2) + 1);
-    expect(alomomola.getLastXMoves()[0].result).toBe(MoveResult.FAIL);
+    expect(alomomola).toHaveUsedMove({ result: MoveResult.FAIL });
  });

  it("should function independently of Future Sight", async () => {
@ -103,7 +94,8 @@ describe("Move - Wish", () => {
    await game.setTurnOrder([BattlerIndex.ENEMY, BattlerIndex.PLAYER]);
    await game.toNextTurn();

-    expectWishActive(1);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH);
+    expect(game).toHavePositionalTag(PositionalTagType.DELAYED_ATTACK);
  });

  it("should work in double battles and trigger in order of creation", async () => {
@ -127,7 +119,7 @@ describe("Move - Wish", () => {
    await game.setTurnOrder(oldOrder.map(p => p.getBattlerIndex()));
    await game.toNextTurn();

-    expectWishActive(4);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH, 4);

    // Lower speed to change turn order
    alomomola.setStatStage(Stat.SPD, 6);
@ -141,7 +133,7 @@ describe("Move - Wish", () => {
    await game.phaseInterceptor.to("PositionalTagPhase");

    // all wishes have activated and added healing phases
-    expectWishActive(0);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH, 0);

    const healPhases = game.scene.phaseManager.phaseQueue.filter(p => p.is("PokemonHealPhase"));
    expect(healPhases).toHaveLength(4);
@ -165,14 +157,14 @@ describe("Move - Wish", () => {
    game.move.use(MoveId.WISH, BattlerIndex.PLAYER_2);
    await game.toNextTurn();

-    expectWishActive();
+    expect(game).toHavePositionalTag(PositionalTagType.WISH);

    game.move.use(MoveId.SPLASH, BattlerIndex.PLAYER);
    game.move.use(MoveId.MEMENTO, BattlerIndex.PLAYER_2, BattlerIndex.ENEMY_2);
    await game.toEndOfTurn();

    // Wish went away without doing anything
-    expectWishActive(0);
+    expect(game).toHavePositionalTag(PositionalTagType.WISH, 0);
    expect(game.textInterceptor.logs).not.toContain(
      i18next.t("arenaTag:wishTagOnAdd", {
        pokemonNameWithAffix: getPokemonNameWithAffix(blissey),
--- a/test/test-utils/matchers/to-equal-array-unsorted.ts
+++ b/test/test-utils/matchers/to-equal-array-unsorted.ts
@ -1,4 +1,5 @@
 import { getOnelineDiffStr } from "#test/test-utils/string-utils";
+import { receivedStr } from "#test/test-utils/test-utils";
 import type { MatcherState, SyncExpectationResult } from "@vitest/expect";

 /**
@ -14,22 +15,22 @@ export function toEqualArrayUnsorted(
 ): SyncExpectationResult {
  if (!Array.isArray(received)) {
    return {
-      pass: false,
-      message: () => `Expected an array, but got ${this.utils.stringify(received)}!`,
+      pass: this.isNot,
+      message: () => `Expected to receive an array, but got ${receivedStr(received)}!`,
    };
  }

  if (received.length !== expected.length) {
    return {
      pass: false,
-      message: () => `Expected to receive array of length ${received.length}, but got ${expected.length} instead!`,
-      actual: received,
+      message: () => `Expected to receive an array of length ${received.length}, but got ${expected.length} instead!`,
      expected,
+      actual: received,
    };
  }

-  const actualSorted = received.slice().sort();
-  const expectedSorted = expected.slice().sort();
+  const actualSorted = received.toSorted();
+  const expectedSorted = expected.toSorted();
  const pass = this.equals(actualSorted, expectedSorted, [...this.customTesters, this.utils.iterableEquality]);

  const actualStr = getOnelineDiffStr.call(this, actualSorted);
--- a/test/test-utils/matchers/to-have-ability-applied.ts
+++ b/test/test-utils/matchers/to-have-ability-applied.ts
@ -21,7 +21,7 @@ export function toHaveAbilityApplied(
 ): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to recieve a Pokemon, but got ${receivedStr(received)}!`,
    };
  }
--- a/test/test-utils/matchers/to-have-arena-tag.ts
+++ b/test/test-utils/matchers/to-have-arena-tag.ts
@ -0,0 +1,79 @@
+import type { ArenaTag, ArenaTagTypeMap } from "#data/arena-tag";
+import type { ArenaTagSide } from "#enums/arena-tag-side";
+import type { ArenaTagType } from "#enums/arena-tag-type";
+import type { OneOther } from "#test/@types/test-helpers";
+// biome-ignore lint/correctness/noUnusedImports: TSDoc
+import type { GameManager } from "#test/test-utils/game-manager";
+import { getOnelineDiffStr } from "#test/test-utils/string-utils";
+import { isGameManagerInstance, receivedStr } from "#test/test-utils/test-utils";
+import type { NonFunctionPropertiesRecursive } from "#types/type-helpers";
+import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
+
+// intersection required to preserve T for inferences
+export type toHaveArenaTagOptions<T extends ArenaTagType> = OneOther<ArenaTagTypeMap[T], "tagType" | "side"> & {
+  tagType: T;
+};
+
+/**
+ * Matcher to check if the {@linkcode Arena} has a given {@linkcode ArenaTag} active.
+ * @param received - The object to check. Should be the current {@linkcode GameManager}.
+ * @param expectedTag - The {@linkcode ArenaTagType} of the desired tag, or a partially-filled object
+ * containing the desired properties
+ * @param side - The {@linkcode ArenaTagSide | side of the field} the tag should affect, or
+ * {@linkcode ArenaTagSide.BOTH} to check both sides
+ * @returns The result of the matching
+ */
+export function toHaveArenaTag<T extends ArenaTagType>(
+  this: MatcherState,
+  received: unknown,
+  // simplified types used for brevity; full overloads are in `vitest.d.ts`
+  expectedTag: T | (Partial<NonFunctionPropertiesRecursive<ArenaTag>> & { tagType: T; side: ArenaTagSide }),
+  side?: ArenaTagSide,
+): SyncExpectationResult {
+  if (!isGameManagerInstance(received)) {
+    return {
+      pass: this.isNot,
+      message: () => `Expected to recieve a GameManager, but got ${receivedStr(received)}!`,
+    };
+  }
+
+  if (!received.scene?.arena) {
+    return {
+      pass: this.isNot,
+      message: () => `Expected GameManager.${received.scene ? "scene.arena" : "scene"} to be defined!`,
+    };
+  }
+
+  if (typeof expectedTag === "string") {
+    // Coerce lone `tagType`s into objects
+    // Bangs are ok as we enforce safety via overloads
+    expectedTag = { tagType: expectedTag, side: side! };
+  }
+
+  // We need to get all tags for the case of checking properties of a tag present on both sides of the arena
+  const tags = received.scene.arena.findTagsOnSide(t => t.tagType === expectedTag.tagType, expectedTag.side);
+  if (tags.length === 0) {
+    return {
+      pass: false,
+      message: () => `Expected the Arena to have a tag of type ${expectedTag.tagType}, but it didn't!`,
+      expected: expectedTag.tagType,
+      actual: received.scene.arena.tags.map(t => t.tagType),
+    };
+  }
+
+  // Pass if any of the matching tags meet our criteria
+  const pass = tags.some(tag =>
+    this.equals(tag, expectedTag, [...this.customTesters, this.utils.subsetEquality, this.utils.iterableEquality]),
+  );
+
+  const expectedStr = getOnelineDiffStr.call(this, expectedTag);
+  return {
+    pass,
+    message: () =>
+      pass
+        ? `Expected the Arena to NOT have a tag matching ${expectedStr}, but it did!`
+        : `Expected the Arena to have a tag matching ${expectedStr}, but it didn't!`,
+    expected: expectedTag,
+    actual: tags,
+  };
+}
--- a/test/test-utils/matchers/to-have-effective-stat.ts
+++ b/test/test-utils/matchers/to-have-effective-stat.ts
@ -6,7 +6,7 @@ import { getStatName } from "#test/test-utils/string-utils";
 import { isPokemonInstance, receivedStr } from "#test/test-utils/test-utils";
 import type { MatcherState, SyncExpectationResult } from "@vitest/expect";

-export interface ToHaveEffectiveStatMatcherOptions {
+export interface toHaveEffectiveStatOptions {
  /**
   * The target {@linkcode Pokemon}
   * @see {@linkcode Pokemon.getEffectiveStat}
@ -30,7 +30,7 @@ export interface ToHaveEffectiveStatMatcherOptions {
 * @param received - The object to check. Should be a {@linkcode Pokemon}
 * @param stat - The {@linkcode EffectiveStat} to check
 * @param expectedValue - The expected value of the {@linkcode stat}
- * @param options - The {@linkcode ToHaveEffectiveStatMatcherOptions}
+ * @param options - The {@linkcode toHaveEffectiveStatOptions}
 * @returns Whether the matcher passed
 */
 export function toHaveEffectiveStat(
@ -38,11 +38,11 @@ export function toHaveEffectiveStat(
  received: unknown,
  stat: EffectiveStat,
  expectedValue: number,
-  { enemy, move, isCritical = false }: ToHaveEffectiveStatMatcherOptions = {},
+  { enemy, move, isCritical = false }: toHaveEffectiveStatOptions = {},
 ): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
    };
  }
--- a/test/test-utils/matchers/to-have-fainted.ts
+++ b/test/test-utils/matchers/to-have-fainted.ts
@ -12,7 +12,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveFainted(this: MatcherState, received: unknown): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
    };
  }
--- a/test/test-utils/matchers/to-have-full-hp.ts
+++ b/test/test-utils/matchers/to-have-full-hp.ts
@ -12,7 +12,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveFullHp(this: MatcherState, received: unknown): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
    };
  }
--- a/test/test-utils/matchers/to-have-hp.ts
+++ b/test/test-utils/matchers/to-have-hp.ts
@ -13,7 +13,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveHp(this: MatcherState, received: unknown, expectedHp: number): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
    };
  }
--- a/test/test-utils/matchers/to-have-positional-tag.ts
+++ b/test/test-utils/matchers/to-have-positional-tag.ts
@ -0,0 +1,108 @@
+// biome-ignore-start lint/correctness/noUnusedImports: TSDoc
+import type { GameManager } from "#test/test-utils/game-manager";
+// biome-ignore-end lint/correctness/noUnusedImports: TSDoc
+
+import type { SerializedPositionalTag, serializedPosTagMap } from "#data/positional-tags/load-positional-tag";
+import type { PositionalTagType } from "#enums/positional-tag-type";
+import type { OneOther } from "#test/@types/test-helpers";
+import { getOnelineDiffStr } from "#test/test-utils/string-utils";
+import { isGameManagerInstance, receivedStr } from "#test/test-utils/test-utils";
+import { toTitleCase } from "#utils/strings";
+import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
+
+export type toHavePositionalTagOptions<P extends PositionalTagType> = OneOther<serializedPosTagMap[P], "tagType"> & {
+  tagType: P;
+};
+
+/**
+ * Matcher to check if the {@linkcode Arena} has a certain number of {@linkcode PositionalTag}s active.
+ * @param received - The object to check. Should be the current {@linkcode GameManager}
+ * @param expectedTag - The {@linkcode PositionalTagType} of the desired tag, or a partially-filled {@linkcode PositionalTag}
+ * containing the desired properties
+ * @param count - The number of tags that should be active; defaults to `1` and must be within the range `[0, 4]`
+ * @returns The result of the matching
+ */
+export function toHavePositionalTag<P extends PositionalTagType>(
+  this: MatcherState,
+  received: unknown,
+  // simplified types used for brevity; full overloads are in `vitest.d.ts`
+  expectedTag: P | (Partial<SerializedPositionalTag> & { tagType: P }),
+  count = 1,
+): SyncExpectationResult {
+  if (!isGameManagerInstance(received)) {
+    return {
+      pass: this.isNot,
+      message: () => `Expected to recieve a GameManager, but got ${receivedStr(received)}!`,
+    };
+  }
+
+  if (!received.scene?.arena?.positionalTagManager) {
+    return {
+      pass: this.isNot,
+      message: () =>
+        `Expected GameManager.${received.scene?.arena ? "scene.arena.positionalTagManager" : received.scene ? "scene.arena" : "scene"} to be defined!`,
+    };
+  }
+
+  // TODO: Increase limit if triple battles are added
+  if (count < 0 || count > 4) {
+    return {
+      pass: this.isNot,
+      message: () => `Expected count to be between 0 and 4, but got ${count} instead!`,
+    };
+  }
+
+  const allTags = received.scene.arena.positionalTagManager.tags;
+  const tagType = typeof expectedTag === "string" ? expectedTag : expectedTag.tagType;
+  const matchingTags = allTags.filter(t => t.tagType === tagType);
+
+  // If checking exclusively tag type, check solely the number of matching tags on field
+  if (typeof expectedTag === "string") {
+    const pass = matchingTags.length === count;
+    const expectedStr = getPosTagStr(expectedTag);
+
+    return {
+      pass,
+      message: () =>
+        pass
+          ? `Expected the Arena to NOT have ${count} ${expectedStr} active, but it did!`
+          : `Expected the Arena to have ${count} ${expectedStr} active, but got ${matchingTags.length} instead!`,
+      expected: expectedTag,
+      actual: allTags,
+    };
+  }
+
+  // Check for equality with the provided object
+  if (matchingTags.length === 0) {
+    return {
+      pass: false,
+      message: () => `Expected the Arena to have a tag of type ${expectedTag.tagType}, but it didn't!`,
+      expected: expectedTag.tagType,
+      actual: received.scene.arena.tags.map(t => t.tagType),
+    };
+  }
+
+  // Pass if any of the matching tags meet our criteria
+  const pass = matchingTags.some(tag =>
+    this.equals(tag, expectedTag, [...this.customTesters, this.utils.subsetEquality, this.utils.iterableEquality]),
+  );
+
+  const expectedStr = getOnelineDiffStr.call(this, expectedTag);
+  return {
+    pass,
+    message: () =>
+      pass
+        ? `Expected the Arena to NOT have a tag matching ${expectedStr}, but it did!`
+        : `Expected the Arena to have a tag matching ${expectedStr}, but it didn't!`,
+    expected: expectedTag,
+    actual: matchingTags,
+  };
+}
+
+function getPosTagStr(pType: PositionalTagType, count = 1): string {
+  let ret = toTitleCase(pType) + "Tag";
+  if (count > 1) {
+    ret += "s";
+  }
+  return ret;
+}
--- a/test/test-utils/matchers/to-have-stat-stage.ts
+++ b/test/test-utils/matchers/to-have-stat-stage.ts
@ -23,14 +23,14 @@ export function toHaveStatStage(
 ): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
    };
  }

  if (expectedStage < -6 || expectedStage > 6) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected ${expectedStage} to be within the range [-6, 6]!`,
    };
  }
--- a/test/test-utils/matchers/to-have-status-effect.ts
+++ b/test/test-utils/matchers/to-have-status-effect.ts
@ -28,7 +28,7 @@ export function toHaveStatusEffect(
 ): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
    };
  }
@ -37,10 +37,8 @@ export function toHaveStatusEffect(
  const actualEffect = received.status?.effect ?? StatusEffect.NONE;

  // Check exclusively effect equality first, coercing non-matching status effects to numbers.
-  if (actualEffect !== (expectedStatus as Exclude<typeof expectedStatus, StatusEffect>)?.effect) {
-    // This is actually 100% safe as `expectedStatus?.effect` will evaluate to `undefined` if a StatusEffect was passed,
-    // which will never match actualEffect by definition
-    expectedStatus = (expectedStatus as Exclude<typeof expectedStatus, StatusEffect>).effect;
+  if (typeof expectedStatus === "object" && actualEffect !== expectedStatus.effect) {
+    expectedStatus = expectedStatus.effect;
  }

  if (typeof expectedStatus === "number") {
--- a/test/test-utils/matchers/to-have-taken-damage.ts
+++ b/test/test-utils/matchers/to-have-taken-damage.ts
@ -24,7 +24,7 @@ export function toHaveTakenDamage(
 ): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
    };
  }
--- a/test/test-utils/matchers/to-have-terrain.ts
+++ b/test/test-utils/matchers/to-have-terrain.ts
@ -20,15 +20,15 @@ export function toHaveTerrain(
 ): SyncExpectationResult {
  if (!isGameManagerInstance(received)) {
    return {
-      pass: false,
-      message: () => `Expected GameManager, but got ${receivedStr(received)}!`,
+      pass: this.isNot,
+      message: () => `Expected to receive a GameManager, but got ${receivedStr(received)}!`,
    };
  }

  if (!received.scene?.arena) {
    return {
-      pass: false,
-      message: () => `Expected GameManager.${received.scene ? "scene" : "scene.arena"} to be defined!`,
+      pass: this.isNot,
+      message: () => `Expected GameManager.${received.scene ? "scene.arena" : "scene"} to be defined!`,
    };
  }

@ -41,8 +41,8 @@ export function toHaveTerrain(
    pass,
    message: () =>
      pass
-        ? `Expected Arena to NOT have ${expectedStr} active, but it did!`
-        : `Expected Arena to have ${expectedStr} active, but got ${actualStr} instead!`,
+        ? `Expected the Arena to NOT have ${expectedStr} active, but it did!`
+        : `Expected the Arena to have ${expectedStr} active, but got ${actualStr} instead!`,
    expected: expectedTerrainType,
    actual,
  };
--- a/test/test-utils/matchers/to-have-types.ts
+++ b/test/test-utils/matchers/to-have-types.ts
@ -7,10 +7,16 @@ import { isPokemonInstance, receivedStr } from "../test-utils";

 export interface toHaveTypesOptions {
  /**
-   * Whether to enforce exact matches (`true`) or superset matches (`false`).
-   * @defaultValue `true`
+   * Value dictating the strength of the enforced typing match.
+   *
+   * Possible values (in ascending order of strength) are:
+   * - `"ordered"`: Enforce that the {@linkcode Pokemon}'s types are identical **and in the same order**
+   * - `"unordered"`: Enforce that the {@linkcode Pokemon}'s types are identical **without checking order**
+   * - `"superset"`: Enforce that the {@linkcode Pokemon}'s types are **a superset of** the expected types
+   * (all must be present, but extras can be there)
+   * @defaultValue `"unordered"`
   */
-  exact?: boolean;
+  mode?: "ordered" | "unordered" | "superset";
  /**
   * Optional arguments to pass to {@linkcode Pokemon.getTypes}.
   */
@ -18,35 +24,46 @@ export interface toHaveTypesOptions {
 }

 /**
- * Matcher that checks if an array contains exactly the given items, disregarding order.
- * @param received - The object to check. Should be an array of one or more {@linkcode PokemonType}s.
- * @param options - The {@linkcode toHaveTypesOptions | options} for this matcher
+ * Matcher that checks if a {@linkcode Pokemon}'s typing is as expected.
+ * @param received - The object to check. Should be a {@linkcode Pokemon}
+ * @param expectedTypes - An array of one or more {@linkcode PokemonType}s to compare against.
+ * @param mode - The mode to perform the matching;
 * @returns The result of the matching
 */
 export function toHaveTypes(
  this: MatcherState,
  received: unknown,
-  expected: [PokemonType, ...PokemonType[]],
-  options: toHaveTypesOptions = {},
+  expectedTypes: [PokemonType, ...PokemonType[]],
+  { mode = "unordered", args = [] }: toHaveTypesOptions = {},
 ): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to recieve a Pokémon, but got ${receivedStr(received)}!`,
    };
  }

-  const actualTypes = received.getTypes(...(options.args ?? [])).sort();
-  const expectedTypes = expected.slice().sort();
+  // Return early if no types were passed in
+  if (expectedTypes.length === 0) {
+    return {
+      pass: this.isNot,
+      message: () => "Expected to receive a non-empty array of PokemonTypes!",
+    };
+  }
+
+  // Avoid sorting the types if strict ordering is desired
+  const actualSorted = mode === "ordered" ? received.getTypes(...args) : received.getTypes(...args).toSorted();
+  const expectedSorted = mode === "ordered" ? expectedTypes : expectedTypes.toSorted();

  // Exact matches do not care about subset equality
-  const matchers = options.exact
-    ? [...this.customTesters, this.utils.iterableEquality]
-    : [...this.customTesters, this.utils.subsetEquality, this.utils.iterableEquality];
-  const pass = this.equals(actualTypes, expectedTypes, matchers);
+  const matchers =
+    mode === "superset"
+      ? [...this.customTesters, this.utils.iterableEquality]
+      : [...this.customTesters, this.utils.subsetEquality, this.utils.iterableEquality];
+  const pass = this.equals(actualSorted, expectedSorted, matchers);

-  const actualStr = stringifyEnumArray(PokemonType, actualTypes);
-  const expectedStr = stringifyEnumArray(PokemonType, expectedTypes);
+  const actualStr = stringifyEnumArray(PokemonType, actualSorted);
+  const expectedStr = stringifyEnumArray(PokemonType, expectedSorted);
  const pkmName = getPokemonNameWithAffix(received);

  return {
@ -55,7 +72,7 @@ export function toHaveTypes(
      pass
        ? `Expected ${pkmName} to NOT have types ${expectedStr}, but it did!`
        : `Expected ${pkmName} to have types ${expectedStr}, but got ${actualStr} instead!`,
-    expected: expectedTypes,
-    actual: actualTypes,
+    expected: expectedSorted,
+    actual: actualSorted,
  };
 }
--- a/test/test-utils/matchers/to-have-used-move.ts
+++ b/test/test-utils/matchers/to-have-used-move.ts
@ -13,7 +13,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 /**
 * Matcher to check the contents of a {@linkcode Pokemon}'s move history.
 * @param received - The actual value received. Should be a {@linkcode Pokemon}
- * @param expectedValue - The {@linkcode MoveId} the Pokemon is expected to have used,
+ * @param expectedMove - The {@linkcode MoveId} the Pokemon is expected to have used,
 * or a partially filled {@linkcode TurnMove} containing the desired properties to check
 * @param index - The index of the move history entry to check, in order from most recent to least recent.
 * Default `0` (last used move)
@ -22,12 +22,12 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveUsedMove(
  this: MatcherState,
  received: unknown,
-  expectedResult: MoveId | AtLeastOne<TurnMove>,
+  expectedMove: MoveId | AtLeastOne<TurnMove>,
  index = 0,
 ): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
    };
  }
@ -37,34 +37,33 @@ export function toHaveUsedMove(

  if (move === undefined) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected ${pkmName} to have used ${index + 1} moves, but it didn't!`,
      actual: received.getLastXMoves(-1),
    };
  }

  // Coerce to a `TurnMove`
-  if (typeof expectedResult === "number") {
-    expectedResult = { move: expectedResult };
+  if (typeof expectedMove === "number") {
+    expectedMove = { move: expectedMove };
  }

  const moveIndexStr = index === 0 ? "last move" : `${getOrdinal(index)} most recent move`;

-  const pass = this.equals(move, expectedResult, [
+  const pass = this.equals(move, expectedMove, [
    ...this.customTesters,
    this.utils.subsetEquality,
    this.utils.iterableEquality,
  ]);

-  const expectedStr = getOnelineDiffStr.call(this, expectedResult);
+  const expectedStr = getOnelineDiffStr.call(this, expectedMove);
  return {
    pass,
    message: () =>
      pass
        ? `Expected ${pkmName}'s ${moveIndexStr} to NOT match ${expectedStr}, but it did!`
-        : // Replace newlines with spaces to preserve one-line ness
-          `Expected ${pkmName}'s ${moveIndexStr} to match ${expectedStr}, but it didn't!`,
-    expected: expectedResult,
+        : `Expected ${pkmName}'s ${moveIndexStr} to match ${expectedStr}, but it didn't!`,
+    expected: expectedMove,
    actual: move,
  };
 }
--- a/test/test-utils/matchers/to-have-used-pp.ts
+++ b/test/test-utils/matchers/to-have-used-pp.ts
@ -13,7 +13,7 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 /**
 * Matcher to check the amount of PP consumed by a {@linkcode Pokemon}.
 * @param received - The actual value received. Should be a {@linkcode Pokemon}
- * @param expectedValue - The {@linkcode MoveId} that should have consumed PP
+ * @param moveId - The {@linkcode MoveId} that should have consumed PP
 * @param ppUsed - The numerical amount of PP that should have been consumed,
 * or `all` to indicate the move should be _out_ of PP
 * @returns Whether the matcher passed
@ -23,12 +23,12 @@ import type { MatcherState, SyncExpectationResult } from "@vitest/expect";
 export function toHaveUsedPP(
  this: MatcherState,
  received: unknown,
-  expectedMove: MoveId,
+  moveId: MoveId,
  ppUsed: number | "all",
 ): SyncExpectationResult {
  if (!isPokemonInstance(received)) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () => `Expected to receive a Pokémon, but got ${receivedStr(received)}!`,
    };
  }
@ -36,22 +36,22 @@ export function toHaveUsedPP(
  const override = received.isPlayer() ? Overrides.MOVESET_OVERRIDE : Overrides.OPP_MOVESET_OVERRIDE;
  if (coerceArray(override).length > 0) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () =>
        `Cannot test for PP consumption with ${received.isPlayer() ? "player" : "enemy"} moveset overrides active!`,
    };
  }

  const pkmName = getPokemonNameWithAffix(received);
-  const moveStr = getEnumStr(MoveId, expectedMove);
+  const moveStr = getEnumStr(MoveId, moveId);

-  const movesetMoves = received.getMoveset().filter(pm => pm.moveId === expectedMove);
+  const movesetMoves = received.getMoveset().filter(pm => pm.moveId === moveId);
  if (movesetMoves.length !== 1) {
    return {
-      pass: false,
+      pass: this.isNot,
      message: () =>
        `Expected MoveId.${moveStr} to appear in ${pkmName}'s moveset exactly once, but got ${movesetMoves.length} times!`,
-      expected: expectedMove,
+      expected: moveId,
      actual: received.getMoveset(),
    };
  }
--- a/test/test-utils/matchers/to-have-weather.ts
+++ b/test/test-utils/matchers/to-have-weather.ts
@ -20,15 +20,15 @@ export function toHaveWeather(
 ): SyncExpectationResult {
  if (!isGameManagerInstance(received)) {
    return {
-      pass: false,
-      message: () => `Expected GameManager, but got ${receivedStr(received)}!`,
+      pass: this.isNot,
+      message: () => `Expected to receive a GameManager, but got ${receivedStr(received)}!`,
    };
  }

  if (!received.scene?.arena) {
    return {
-      pass: false,
-      message: () => `Expected GameManager.${received.scene ? "scene" : "scene.arena"} to be defined!`,
+      pass: this.isNot,
+      message: () => `Expected GameManager.${received.scene ? "scene.arena" : "scene"} to be defined!`,
    };
  }

@ -41,8 +41,8 @@ export function toHaveWeather(
    pass,
    message: () =>
      pass
-        ? `Expected Arena to NOT have ${expectedStr} weather active, but it did!`
-        : `Expected Arena to have ${expectedStr} weather active, but got ${actualStr} instead!`,
+        ? `Expected the Arena to NOT have ${expectedStr} weather active, but it did!`
+        : `Expected the Arena to have ${expectedStr} weather active, but got ${actualStr} instead!`,
    expected: expectedWeatherType,
    actual,
  };
--- a/test/test-utils/string-utils.ts
+++ b/test/test-utils/string-utils.ts
@ -34,10 +34,10 @@ interface getEnumStrOptions {
 * @returns The stringified representation of `val` as dictated by the options.
 * @example
 * ```ts
- * enum fakeEnum {
- *   ONE: 1,
- *   TWO: 2,
- *   THREE: 3,
+ * enum testEnum {
+ *   ONE = 1,
+ *   TWO = 2,
+ *   THREE = 3,
 * }
 * getEnumStr(fakeEnum, fakeEnum.ONE); // Output: "ONE (=1)"
 * getEnumStr(fakeEnum, fakeEnum.TWO, {casing: "Title", prefix: "fakeEnum.", suffix: "!!!"}); // Output: "fakeEnum.TWO!!! (=2)"
@ -174,10 +174,14 @@ export function getStatName(s: Stat): string {
 * Convert an object into a oneline diff to be shown in an error message.
 * @param obj - The object to return the oneline diff of
 * @returns The updated diff
+ * @example
+ * ```ts
+ * const diff = getOnelineDiffStr.call(this, obj)
+ * ```
 */
 export function getOnelineDiffStr(this: MatcherState, obj: unknown): string {
  return this.utils
    .stringify(obj, undefined, { maxLength: 35, indent: 0, printBasicPrototype: false })
    .replace(/\n/g, " ") // Replace newlines with spaces
-    .replace(/,(\s*)}$/g, "$1}");
+    .replace(/,(\s*)}$/g, "$1}"); // Trim trailing commas
 }
Author	SHA1	Message	Date
Bertie690	e3908adcca	Merge `6866248b41` into `bb86bdd2a6`	2025-08-06 04:21:20 +00:00
damocleas	bb86bdd2a6	[Balance] Add Scientist to Lab, Swimmer to Seabed to account for ME's https://github.com/pagefaultgames/pokerogue/pull/6217	2025-08-05 19:57:51 -07:00
Sirz Benjie	1633df75c4	[UI/UX] Add change password ui (#5938 ) * Add change password ui * Ensure input fields are cleared after submit or cancel * Play select sound on successful submission or cancel --------- Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com> Co-authored-by: Wlowscha <54003515+Wlowscha@users.noreply.github.com>	2025-08-05 16:35:58 -06:00
Bertie690	6866248b41	Update test/test-utils/matchers/to-have-positional-tag.ts Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com>	2025-08-05 00:05:04 -04:00
Bertie690	9298ff8282	Update test/test-utils/matchers/to-have-positional-tag.ts Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com>	2025-08-05 00:04:55 -04:00
Bertie690	7e7ca6b3fa	Update test/test-utils/matchers/to-have-positional-tag.ts Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com>	2025-08-05 00:04:39 -04:00
Bertie690	cd890025d1	Update test/@types/vitest.d.ts Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com>	2025-08-05 00:04:31 -04:00
Bertie690	71801fe298	Update test/test-utils/matchers/to-have-types.ts Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com>	2025-08-05 00:04:20 -04:00
Bertie690	e968063eaa	Added `toHavePositionalTag` matcher	2025-08-03 17:21:24 -04:00
Bertie690	b98ff5ae90	Moar fixups to strings	2025-08-03 17:12:59 -04:00
Bertie690	c89accc673	Shuffled a few funcs around	2025-08-03 16:26:39 -04:00
Bertie690	df8d1dc8c7	More semantic changes	2025-08-03 16:15:32 -04:00
Bertie690	9455030fbe	More improvements and minor fixes	2025-08-03 15:48:08 -04:00
Bertie690	dbea701d6d	Update test/test-utils/matchers/to-have-arena-tag.ts Co-authored-by: NightKev <34855794+DayKev@users.noreply.github.com>	2025-08-03 13:27:26 -04:00
Bertie690	641f5f5b97	Removed accidental test file addition	2025-08-03 11:16:01 -04:00
Bertie690	f5154179b3	Fixed imports and stufff	2025-08-03 11:12:19 -04:00
Bertie690	49825a6729	[Test] Added `toHaveArenaTagMatcher` + fixed prior matchers	2025-08-02 23:52:07 -04:00