Merge branch 'beta' into wild-ghost-goo

.dependency-cruiser.cjs

@@ -1,6 +1,17 @@
 /** @type {import('dependency-cruiser').IConfiguration} */
 module.exports = {
   forbidden: [
+    {
+      name: "only-type-imports",
+      severity: "error",
+      comment: "Files in enums and @types may only use type imports.",
+      from: {
+        path: ["(^|/)src/@types", "(^|/)src/enums"],
+      },
+      to: {
+        dependencyTypesNot: ["type-only"],
+      },
+    },
     {
       name: "no-circular-at-runtime",
       severity: "warn",
@@ -31,6 +42,8 @@ module.exports = {
           "[.]d[.]ts$", // TypeScript declaration files
           "(^|/)tsconfig[.]json$", // TypeScript config
           "(^|/)(?:babel|webpack)[.]config[.](?:js|cjs|mjs|ts|cts|mts|json)$", // other configs
+          // anything in src/@types
+          "(^|/)src/@types/",
         ],
       },
       to: {},

.github/test-filters.yml

@@ -1,7 +1,8 @@
 all:
-  - "src/**"
+  # Negations syntax from https://github.com/dorny/paths-filter/issues/184#issuecomment-2786521554
-  - "test/**"
+  - "src/**/!(*.{md,py,sh,gitkeep,gitignore})"
-  - "public/**"
+  - "test/**/!(*.{md,py,sh,gitkeep,gitignore})"
+  - "public/**/!(*.{md,py,sh,gitkeep,gitignore})"
   # Workflows that can impact tests
   - ".github/workflows/test*.yml"
   - ".github/test-filters.yml"
@@ -12,8 +13,3 @@ all:
   - "tsconfig*.json" # tsconfig.json tweaking can impact compilation
   - "global.d.ts"
   - ".env*"
-  # Blanket negations for files that cannot impact tests
-  - "!**/*.py" # No .py files
-  - "!**/*.sh" # No .sh files
-  - "!**/*.md" # No .md files
-  - "!**/.git*" # .gitkeep and family

.github/workflows/test-shard-template.yml

@@ -19,19 +19,20 @@ on:
 
 jobs:
   test:
-    name: Shard ${{ inputs.shard }} of ${{ inputs.totalShards }}
+    # We can't use dynmically named jobs until https://github.com/orgs/community/discussions/13261 is implemented
+    name: Shard
     runs-on: ubuntu-latest
     if: ${{ !inputs.skip }}
     steps:
       - name: Check out Git repository
         uses: actions/checkout@v4.2.2
         with:
-          submodules: 'recursive'
+          submodules: "recursive"
       - name: Set up Node.js
         uses: actions/setup-node@v4
         with:
-          node-version-file: '.nvmrc'
+          node-version-file: ".nvmrc"
-          cache: 'npm'
+          cache: "npm"
       - name: Install Node.js dependencies
         run: npm ci
       - name: Run tests

.github/workflows/tests.yml

@@ -25,6 +25,7 @@ jobs:
       - name: checkout
         uses: actions/checkout@v4
       - uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36
+        id: filter
         with:
           filters: .github/test-filters.yml
 
@@ -33,10 +34,10 @@ jobs:
     needs: check-path-change-filter
     strategy:
       matrix:
-        shard: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+        shard: [1, 2, 3, 4, 5]
     uses: ./.github/workflows/test-shard-template.yml
     with:
       project: main
       shard: ${{ matrix.shard }}
-      totalShards: 10
+      totalShards: 5
-      skip: ${{ needs.check-path-change-filter.outputs.all == 'false'}}
+      skip: ${{ needs.check-path-change-filter.outputs.all != 'true'}}

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pokemon-rogue-battle",
-  "version": "1.9.4",
+  "version": "1.9.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pokemon-rogue-battle",
-      "version": "1.9.4",
+      "version": "1.9.5",
       "hasInstallScript": true,
       "dependencies": {
         "@material/material-color-utilities": "^0.2.7",

package.json

@@ -1,7 +1,7 @@
 {
   "name": "pokemon-rogue-battle",
   "private": true,
-  "version": "1.9.4",
+  "version": "1.9.5",
   "type": "module",
   "scripts": {
     "start": "vite",

public/images/statuses_ca.json

@@ -1,7 +1,7 @@
 {
 	"textures": [
 		{
-			"image": "statuses_ca_ES.png",
+			"image": "statuses_ca.png",
 			"format": "RGBA8888",
 			"size": {
 				"w": 22,

public/images/statuses_da.json

@@ -0,0 +1,188 @@
+{
+	"textures": [
+		{
+			"image": "statuses_da.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 22,
+				"h": 64
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "pokerus",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 22,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 22,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 22,
+						"h": 8
+					}
+				},
+				{
+					"filename": "burn",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 8,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "faint",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 16,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "freeze",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 24,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "paralysis",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 32,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "poison",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 40,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "sleep",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 48,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "toxic",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 56,
+						"w": 20,
+						"h": 8
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:37686e85605d17b806f22d43081c1139:70535ffee63ba61b3397d8470c2c8982:e6649238c018d3630e55681417c698ca$"
+	}
+}

public/images/statuses_ro.json

@@ -0,0 +1,188 @@
+{
+	"textures": [
+		{
+			"image": "statuses_ro.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 22,
+				"h": 64
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "pokerus",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 22,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 22,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 22,
+						"h": 8
+					}
+				},
+				{
+					"filename": "burn",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 8,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "faint",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 16,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "freeze",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 24,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "paralysis",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 32,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "poison",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 40,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "sleep",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 48,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "toxic",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 56,
+						"w": 20,
+						"h": 8
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:37686e85605d17b806f22d43081c1139:70535ffee63ba61b3397d8470c2c8982:e6649238c018d3630e55681417c698ca$"
+	}
+}

public/images/statuses_ru.json

@@ -0,0 +1,188 @@
+{
+	"textures": [
+		{
+			"image": "statuses_ru.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 22,
+				"h": 64
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "pokerus",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 22,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 22,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 22,
+						"h": 8
+					}
+				},
+				{
+					"filename": "burn",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 8,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "faint",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 16,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "freeze",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 24,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "paralysis",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 32,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "poison",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 40,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "sleep",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 48,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "toxic",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 56,
+						"w": 20,
+						"h": 8
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:37686e85605d17b806f22d43081c1139:70535ffee63ba61b3397d8470c2c8982:e6649238c018d3630e55681417c698ca$"
+	}
+}

public/images/statuses_tr.json

@@ -0,0 +1,188 @@
+{
+	"textures": [
+		{
+			"image": "statuses_tr.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 22,
+				"h": 64
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "pokerus",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 22,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 22,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 22,
+						"h": 8
+					}
+				},
+				{
+					"filename": "burn",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 8,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "faint",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 16,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "freeze",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 24,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "paralysis",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 32,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "poison",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 40,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "sleep",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 48,
+						"w": 20,
+						"h": 8
+					}
+				},
+				{
+					"filename": "toxic",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 20,
+						"h": 8
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 20,
+						"h": 8
+					},
+					"frame": {
+						"x": 0,
+						"y": 56,
+						"w": 20,
+						"h": 8
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:37686e85605d17b806f22d43081c1139:70535ffee63ba61b3397d8470c2c8982:e6649238c018d3630e55681417c698ca$"
+	}
+}

public/images/types_ca.json

@@ -1,7 +1,7 @@
 {
 	"textures": [
 		{
-			"image": "types_ca-ES.png",
+			"image": "types_ca.png",
 			"format": "RGBA8888",
 			"size": {
 				"w": 32,

public/images/types_da.json

@@ -0,0 +1,440 @@
+{
+	"textures": [
+		{
+			"image": "types_da.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 32,
+				"h": 280
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "unknown",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "bug",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 14,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "dark",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 28,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "dragon",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 42,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "electric",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 56,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fairy",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 70,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fighting",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 84,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fire",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 98,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "flying",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 112,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ghost",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 126,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "grass",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 140,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ground",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 154,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ice",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 168,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "normal",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 182,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "poison",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 196,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "psychic",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 210,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "rock",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 224,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "steel",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 238,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "water",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 252,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "stellar",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 266,
+						"w": 32,
+						"h": 14
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:f14cf47d9a8f1d40c8e03aa6ba00fff3:6fc4227b57a95d429a1faad4280f7ec8:5961efbfbf4c56b8745347e7a663a32f$"
+	}
+}

public/images/types_ro.json

@@ -0,0 +1,440 @@
+{
+	"textures": [
+		{
+			"image": "types_ro.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 32,
+				"h": 280
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "unknown",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "bug",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 14,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "dark",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 28,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "dragon",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 42,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "electric",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 56,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fairy",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 70,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fighting",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 84,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fire",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 98,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "flying",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 112,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ghost",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 126,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "grass",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 140,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ground",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 154,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ice",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 168,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "normal",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 182,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "poison",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 196,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "psychic",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 210,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "rock",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 224,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "steel",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 238,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "water",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 252,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "stellar",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 266,
+						"w": 32,
+						"h": 14
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:f14cf47d9a8f1d40c8e03aa6ba00fff3:6fc4227b57a95d429a1faad4280f7ec8:5961efbfbf4c56b8745347e7a663a32f$"
+	}
+}

public/images/types_ru.json

@@ -0,0 +1,440 @@
+{
+	"textures": [
+		{
+			"image": "types_ru.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 32,
+				"h": 280
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "unknown",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "bug",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 14,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "dark",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 28,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "dragon",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 42,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "electric",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 56,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fairy",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 70,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fighting",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 84,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fire",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 98,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "flying",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 112,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ghost",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 126,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "grass",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 140,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ground",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 154,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ice",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 168,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "normal",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 182,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "poison",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 196,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "psychic",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 210,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "rock",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 224,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "steel",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 238,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "water",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 252,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "stellar",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 266,
+						"w": 32,
+						"h": 14
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:f14cf47d9a8f1d40c8e03aa6ba00fff3:6fc4227b57a95d429a1faad4280f7ec8:5961efbfbf4c56b8745347e7a663a32f$"
+	}
+}

public/images/types_tr.json

@@ -0,0 +1,440 @@
+{
+	"textures": [
+		{
+			"image": "types_tr.png",
+			"format": "RGBA8888",
+			"size": {
+				"w": 32,
+				"h": 280
+			},
+			"scale": 1,
+			"frames": [
+				{
+					"filename": "unknown",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "bug",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 14,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "dark",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 28,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "dragon",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 42,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "electric",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 56,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fairy",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 70,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fighting",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 84,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "fire",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 98,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "flying",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 112,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ghost",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 126,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "grass",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 140,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ground",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 154,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "ice",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 168,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "normal",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 182,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "poison",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 196,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "psychic",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 210,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "rock",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 224,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "steel",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 238,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "water",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 252,
+						"w": 32,
+						"h": 14
+					}
+				},
+				{
+					"filename": "stellar",
+					"rotated": false,
+					"trimmed": false,
+					"sourceSize": {
+						"w": 32,
+						"h": 14
+					},
+					"spriteSourceSize": {
+						"x": 0,
+						"y": 0,
+						"w": 32,
+						"h": 14
+					},
+					"frame": {
+						"x": 0,
+						"y": 266,
+						"w": 32,
+						"h": 14
+					}
+				}
+			]
+		}
+	],
+	"meta": {
+		"app": "https://www.codeandweb.com/texturepacker",
+		"version": "3.0",
+		"smartupdate": "$TexturePacker:SmartUpdate:f14cf47d9a8f1d40c8e03aa6ba00fff3:6fc4227b57a95d429a1faad4280f7ec8:5961efbfbf4c56b8745347e7a663a32f$"
+	}
+}

public/locales

@@ -1 +1 @@
-Subproject commit e9ccbadb6eaa3b797f3dec919745befda2ec74bd
+Subproject commit 4dab23d6a78b6cf32db43c9953e3c2000f448007

src/battle-scene.ts

@@ -129,12 +129,12 @@ import { ArenaFlyout } from "#app/ui/arena-flyout";
 import { EaseType } from "#enums/ease-type";
 import { BattleSpec } from "#enums/battle-spec";
 import { BattleStyle } from "#enums/battle-style";
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
 import type { ExpNotification } from "#enums/exp-notification";
 import { MoneyFormat } from "#enums/money-format";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { PlayerGender } from "#enums/player-gender";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { UiTheme } from "#enums/ui-theme";
 import { TimedEventManager } from "#app/timed-event-manager";
 import type { PokemonAnimType } from "#enums/pokemon-anim-type";
@@ -707,14 +707,14 @@ export default class BattleScene extends SceneBase {
 
     ui.setup();
 
-    const defaultMoves = [Moves.TACKLE, Moves.TAIL_WHIP, Moves.FOCUS_ENERGY, Moves.STRUGGLE];
+    const defaultMoves = [MoveId.TACKLE, MoveId.TAIL_WHIP, MoveId.FOCUS_ENERGY, MoveId.STRUGGLE];
 
     Promise.all([
       Promise.all(loadPokemonAssets),
       initCommonAnims().then(() => loadCommonAnimAssets(true)),
-      Promise.all([Moves.TACKLE, Moves.TAIL_WHIP, Moves.FOCUS_ENERGY, Moves.STRUGGLE].map(m => initMoveAnim(m))).then(
+      Promise.all(
-        () => loadMoveAnimAssets(defaultMoves, true),
+        [MoveId.TACKLE, MoveId.TAIL_WHIP, MoveId.FOCUS_ENERGY, MoveId.STRUGGLE].map(m => initMoveAnim(m)),
-      ),
+      ).then(() => loadMoveAnimAssets(defaultMoves, true)),
       this.initStarterColors(),
     ]).then(() => {
       this.pushPhase(new LoginPhase());
@@ -1225,7 +1225,7 @@ export default class BattleScene extends SceneBase {
 
     [this.luckLabelText, this.luckText].map(t => t.setVisible(false));
 
-    this.newArena(Overrides.STARTING_BIOME_OVERRIDE || Biome.TOWN);
+    this.newArena(Overrides.STARTING_BIOME_OVERRIDE || BiomeId.TOWN);
 
     this.field.setVisible(true);
 
@@ -1501,7 +1501,7 @@ export default class BattleScene extends SceneBase {
           pokemon.resetTera();
           applyPostBattleInitAbAttrs(PostBattleInitAbAttr, pokemon);
           if (
-            pokemon.hasSpecies(Species.TERAPAGOS) ||
+            pokemon.hasSpecies(SpeciesId.TERAPAGOS) ||
             (this.gameMode.isClassic && this.currentBattle.waveIndex > 180 && this.currentBattle.waveIndex <= 190)
           ) {
             this.arena.playerTerasUsed = 0;
@@ -1532,8 +1532,8 @@ export default class BattleScene extends SceneBase {
     return this.currentBattle;
   }
 
-  newArena(biome: Biome, playerFaints?: number): Arena {
+  newArena(biome: BiomeId, playerFaints?: number): Arena {
-    this.arena = new Arena(biome, Biome[biome].toLowerCase(), playerFaints);
+    this.arena = new Arena(biome, BiomeId[biome].toLowerCase(), playerFaints);
     this.eventTarget.dispatchEvent(new NewArenaEvent());
 
     this.arenaBg.pipelineData = {
@@ -1599,7 +1599,7 @@ export default class BattleScene extends SceneBase {
       !isNullOrUndefined(this.currentBattle.trainer) &&
       this.currentBattle.trainer.config.hasSpecialtyType()
     ) {
-      if (species.speciesId === Species.WORMADAM) {
+      if (species.speciesId === SpeciesId.WORMADAM) {
         switch (this.currentBattle.trainer.config.specialtyType) {
           case PokemonType.GROUND:
             return 1; // Sandy Cloak
@@ -1609,7 +1609,7 @@ export default class BattleScene extends SceneBase {
             return 0; // Plant Cloak
         }
       }
-      if (species.speciesId === Species.ROTOM) {
+      if (species.speciesId === SpeciesId.ROTOM) {
         switch (this.currentBattle.trainer.config.specialtyType) {
           case PokemonType.FLYING:
             return 4; // Fan Rotom
@@ -1625,7 +1625,7 @@ export default class BattleScene extends SceneBase {
             return 3; // Frost Rotom
         }
       }
-      if (species.speciesId === Species.ORICORIO) {
+      if (species.speciesId === SpeciesId.ORICORIO) {
         switch (this.currentBattle.trainer.config.specialtyType) {
           case PokemonType.GHOST:
             return 3; // Sensu Style
@@ -1637,7 +1637,7 @@ export default class BattleScene extends SceneBase {
             return 2; // Pa'u Style
         }
       }
-      if (species.speciesId === Species.PALDEA_TAUROS) {
+      if (species.speciesId === SpeciesId.PALDEA_TAUROS) {
         switch (this.currentBattle.trainer.config.specialtyType) {
           case PokemonType.FIRE:
             return 1; // Blaze Breed
@@ -1645,45 +1645,45 @@ export default class BattleScene extends SceneBase {
             return 2; // Aqua Breed
         }
       }
-      if (species.speciesId === Species.SILVALLY || species.speciesId === Species.ARCEUS) {
+      if (species.speciesId === SpeciesId.SILVALLY || species.speciesId === SpeciesId.ARCEUS) {
         // Would probably never happen, but might as well
         return this.currentBattle.trainer.config.specialtyType;
       }
     }
 
     switch (species.speciesId) {
-      case Species.UNOWN:
+      case SpeciesId.UNOWN:
-      case Species.SHELLOS:
+      case SpeciesId.SHELLOS:
-      case Species.GASTRODON:
+      case SpeciesId.GASTRODON:
-      case Species.BASCULIN:
+      case SpeciesId.BASCULIN:
-      case Species.DEERLING:
+      case SpeciesId.DEERLING:
-      case Species.SAWSBUCK:
+      case SpeciesId.SAWSBUCK:
-      case Species.SCATTERBUG:
+      case SpeciesId.SCATTERBUG:
-      case Species.SPEWPA:
+      case SpeciesId.SPEWPA:
-      case Species.VIVILLON:
+      case SpeciesId.VIVILLON:
-      case Species.FLABEBE:
+      case SpeciesId.FLABEBE:
-      case Species.FLOETTE:
+      case SpeciesId.FLOETTE:
-      case Species.FLORGES:
+      case SpeciesId.FLORGES:
-      case Species.FURFROU:
+      case SpeciesId.FURFROU:
-      case Species.PUMPKABOO:
+      case SpeciesId.PUMPKABOO:
-      case Species.GOURGEIST:
+      case SpeciesId.GOURGEIST:
-      case Species.ORICORIO:
+      case SpeciesId.ORICORIO:
-      case Species.MAGEARNA:
+      case SpeciesId.MAGEARNA:
-      case Species.SINISTEA:
+      case SpeciesId.SINISTEA:
-      case Species.POLTEAGEIST:
+      case SpeciesId.POLTEAGEIST:
-      case Species.ZARUDE:
+      case SpeciesId.ZARUDE:
-      case Species.SQUAWKABILLY:
+      case SpeciesId.SQUAWKABILLY:
-      case Species.TATSUGIRI:
+      case SpeciesId.TATSUGIRI:
-      case Species.POLTCHAGEIST:
+      case SpeciesId.POLTCHAGEIST:
-      case Species.SINISTCHA:
+      case SpeciesId.SINISTCHA:
-      case Species.PALDEA_TAUROS:
+      case SpeciesId.PALDEA_TAUROS:
         return randSeedInt(species.forms.length);
-      case Species.PIKACHU:
+      case SpeciesId.PIKACHU:
         if (this.currentBattle?.battleType === BattleType.TRAINER && this.currentBattle?.waveIndex < 30) {
           return 0; // Ban Cosplay and Partner Pika from Trainers before wave 30
         }
         return randSeedInt(8);
-      case Species.EEVEE:
+      case SpeciesId.EEVEE:
         if (
           this.currentBattle?.battleType === BattleType.TRAINER &&
           this.currentBattle?.waveIndex < 30 &&
@@ -1692,27 +1692,27 @@ export default class BattleScene extends SceneBase {
           return 0; // No Partner Eevee for Wave 12 Preschoolers
         }
         return randSeedInt(2);
-      case Species.FROAKIE:
+      case SpeciesId.FROAKIE:
-      case Species.FROGADIER:
+      case SpeciesId.FROGADIER:
-      case Species.GRENINJA:
+      case SpeciesId.GRENINJA:
         if (this.currentBattle?.battleType === BattleType.TRAINER && !isEggPhase) {
           return 0; // Don't give trainers Battle Bond Greninja, Froakie or Frogadier
         }
         return randSeedInt(2);
-      case Species.URSHIFU:
+      case SpeciesId.URSHIFU:
         return randSeedInt(2);
-      case Species.ZYGARDE:
+      case SpeciesId.ZYGARDE:
         return randSeedInt(4);
-      case Species.MINIOR:
+      case SpeciesId.MINIOR:
         return randSeedInt(7);
-      case Species.ALCREMIE:
+      case SpeciesId.ALCREMIE:
         return randSeedInt(9);
-      case Species.MEOWSTIC:
+      case SpeciesId.MEOWSTIC:
-      case Species.INDEEDEE:
+      case SpeciesId.INDEEDEE:
-      case Species.BASCULEGION:
+      case SpeciesId.BASCULEGION:
-      case Species.OINKOLOGNE:
+      case SpeciesId.OINKOLOGNE:
         return gender === Gender.FEMALE ? 1 : 0;
-      case Species.TOXTRICITY: {
+      case SpeciesId.TOXTRICITY: {
         const lowkeyNatures = [
           Nature.LONELY,
           Nature.BOLD,
@@ -1732,7 +1732,7 @@ export default class BattleScene extends SceneBase {
         }
         return 0;
       }
-      case Species.GIMMIGHOUL:
+      case SpeciesId.GIMMIGHOUL:
         // Chest form can only be found in Mysterious Chest Encounter, if this is a game mode with MEs
         if (this.gameMode.hasMysteryEncounters && !isEggPhase) {
           return 1; // Wandering form
@@ -1742,10 +1742,10 @@ export default class BattleScene extends SceneBase {
 
     if (ignoreArena) {
       switch (species.speciesId) {
-        case Species.BURMY:
+        case SpeciesId.BURMY:
-        case Species.WORMADAM:
+        case SpeciesId.WORMADAM:
-        case Species.ROTOM:
+        case SpeciesId.ROTOM:
-        case Species.LYCANROC:
+        case SpeciesId.LYCANROC:
           return randSeedInt(species.forms.length);
       }
       return 0;
@@ -2176,10 +2176,10 @@ export default class BattleScene extends SceneBase {
     return filteredSpecies[randSeedInt(filteredSpecies.length)];
   }
 
-  generateRandomBiome(waveIndex: number): Biome {
+  generateRandomBiome(waveIndex: number): BiomeId {
     const relWave = waveIndex % 250;
-    const biomes = getEnumValues(Biome).filter(b => b !== Biome.TOWN && b !== Biome.END);
+    const biomes = getEnumValues(BiomeId).filter(b => b !== BiomeId.TOWN && b !== BiomeId.END);
-    const maxDepth = biomeDepths[Biome.END][0] - 2;
+    const maxDepth = biomeDepths[BiomeId.END][0] - 2;
     const depthWeights = new Array(maxDepth + 1)
       .fill(null)
       .map((_, i: number) => ((1 - Math.min(Math.abs(i / (maxDepth - 1) - relWave / 250) + 0.25, 1)) / 0.75) * 250);
@@ -3479,7 +3479,7 @@ export default class BattleScene extends SceneBase {
         fc => fc.findTrigger(formChangeTriggerType) && fc.canChange(pokemon),
       );
       let matchingFormChange: SpeciesFormChange | null;
-      if (pokemon.species.speciesId === Species.NECROZMA && matchingFormChangeOpts.length > 1) {
+      if (pokemon.species.speciesId === SpeciesId.NECROZMA && matchingFormChangeOpts.length > 1) {
         // Ultra Necrozma is changing its form back, so we need to figure out into which form it devolves.
         const formChangeItemModifiers = (
           this.findModifiers(

src/battle.ts

@@ -19,10 +19,10 @@ import type { EnemyPokemon, PlayerPokemon, TurnMove } from "#app/field/pokemon";
 import type Pokemon from "#app/field/pokemon";
 import { ArenaTagType } from "#enums/arena-tag-type";
 import { BattleSpec } from "#enums/battle-spec";
-import type { Moves } from "#enums/moves";
+import type { MoveId } from "#enums/move-id";
 import { PlayerGender } from "#enums/player-gender";
 import { MusicPreference } from "#app/system/settings/settings";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { TrainerType } from "#enums/trainer-type";
 import i18next from "#app/plugins/i18n";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
@@ -78,7 +78,7 @@ export default class Battle {
   public battleScore = 0;
   public postBattleLoot: PokemonHeldItemModifier[] = [];
   public escapeAttempts = 0;
-  public lastMove: Moves;
+  public lastMove: MoveId;
   public battleSeed: string = randomString(16, true);
   private battleSeedState: string | null = null;
   public moneyScattered = 0;
@@ -264,14 +264,14 @@ export default class Battle {
       if (pokemon.species.legendary || pokemon.species.subLegendary || pokemon.species.mythical) {
         if (globalScene.musicPreference === MusicPreference.GENFIVE) {
           switch (pokemon.species.speciesId) {
-            case Species.REGIROCK:
+            case SpeciesId.REGIROCK:
-            case Species.REGICE:
+            case SpeciesId.REGICE:
-            case Species.REGISTEEL:
+            case SpeciesId.REGISTEEL:
-            case Species.REGIGIGAS:
+            case SpeciesId.REGIGIGAS:
-            case Species.REGIDRAGO:
+            case SpeciesId.REGIDRAGO:
-            case Species.REGIELEKI:
+            case SpeciesId.REGIELEKI:
               return "battle_legendary_regis_g5";
-            case Species.KYUREM:
+            case SpeciesId.KYUREM:
               return "battle_legendary_kyurem";
             default:
               if (pokemon.species.legendary) {
@@ -282,80 +282,80 @@ export default class Battle {
         }
         if (globalScene.musicPreference === MusicPreference.ALLGENS) {
           switch (pokemon.species.speciesId) {
-            case Species.ARTICUNO:
+            case SpeciesId.ARTICUNO:
-            case Species.ZAPDOS:
+            case SpeciesId.ZAPDOS:
-            case Species.MOLTRES:
+            case SpeciesId.MOLTRES:
-            case Species.MEWTWO:
+            case SpeciesId.MEWTWO:
-            case Species.MEW:
+            case SpeciesId.MEW:
               return "battle_legendary_kanto";
-            case Species.RAIKOU:
+            case SpeciesId.RAIKOU:
               return "battle_legendary_raikou";
-            case Species.ENTEI:
+            case SpeciesId.ENTEI:
               return "battle_legendary_entei";
-            case Species.SUICUNE:
+            case SpeciesId.SUICUNE:
               return "battle_legendary_suicune";
-            case Species.LUGIA:
+            case SpeciesId.LUGIA:
               return "battle_legendary_lugia";
-            case Species.HO_OH:
+            case SpeciesId.HO_OH:
               return "battle_legendary_ho_oh";
-            case Species.REGIROCK:
+            case SpeciesId.REGIROCK:
-            case Species.REGICE:
+            case SpeciesId.REGICE:
-            case Species.REGISTEEL:
+            case SpeciesId.REGISTEEL:
-            case Species.REGIGIGAS:
+            case SpeciesId.REGIGIGAS:
-            case Species.REGIDRAGO:
+            case SpeciesId.REGIDRAGO:
-            case Species.REGIELEKI:
+            case SpeciesId.REGIELEKI:
               return "battle_legendary_regis_g6";
-            case Species.GROUDON:
+            case SpeciesId.GROUDON:
-            case Species.KYOGRE:
+            case SpeciesId.KYOGRE:
               return "battle_legendary_gro_kyo";
-            case Species.RAYQUAZA:
+            case SpeciesId.RAYQUAZA:
               return "battle_legendary_rayquaza";
-            case Species.DEOXYS:
+            case SpeciesId.DEOXYS:
               return "battle_legendary_deoxys";
-            case Species.UXIE:
+            case SpeciesId.UXIE:
-            case Species.MESPRIT:
+            case SpeciesId.MESPRIT:
-            case Species.AZELF:
+            case SpeciesId.AZELF:
               return "battle_legendary_lake_trio";
-            case Species.HEATRAN:
+            case SpeciesId.HEATRAN:
-            case Species.CRESSELIA:
+            case SpeciesId.CRESSELIA:
-            case Species.DARKRAI:
+            case SpeciesId.DARKRAI:
-            case Species.SHAYMIN:
+            case SpeciesId.SHAYMIN:
               return "battle_legendary_sinnoh";
-            case Species.DIALGA:
+            case SpeciesId.DIALGA:
-            case Species.PALKIA:
+            case SpeciesId.PALKIA:
               if (pokemon.species.getFormSpriteKey(pokemon.formIndex) === SpeciesFormKey.ORIGIN) {
                 return "battle_legendary_origin_forme";
               }
               return "battle_legendary_dia_pal";
-            case Species.GIRATINA:
+            case SpeciesId.GIRATINA:
               return "battle_legendary_giratina";
-            case Species.ARCEUS:
+            case SpeciesId.ARCEUS:
               return "battle_legendary_arceus";
-            case Species.COBALION:
+            case SpeciesId.COBALION:
-            case Species.TERRAKION:
+            case SpeciesId.TERRAKION:
-            case Species.VIRIZION:
+            case SpeciesId.VIRIZION:
-            case Species.KELDEO:
+            case SpeciesId.KELDEO:
-            case Species.TORNADUS:
+            case SpeciesId.TORNADUS:
-            case Species.LANDORUS:
+            case SpeciesId.LANDORUS:
-            case Species.THUNDURUS:
+            case SpeciesId.THUNDURUS:
-            case Species.MELOETTA:
+            case SpeciesId.MELOETTA:
-            case Species.GENESECT:
+            case SpeciesId.GENESECT:
               return "battle_legendary_unova";
-            case Species.KYUREM:
+            case SpeciesId.KYUREM:
               return "battle_legendary_kyurem";
-            case Species.XERNEAS:
+            case SpeciesId.XERNEAS:
-            case Species.YVELTAL:
+            case SpeciesId.YVELTAL:
-            case Species.ZYGARDE:
+            case SpeciesId.ZYGARDE:
               return "battle_legendary_xern_yvel";
-            case Species.TAPU_KOKO:
+            case SpeciesId.TAPU_KOKO:
-            case Species.TAPU_LELE:
+            case SpeciesId.TAPU_LELE:
-            case Species.TAPU_BULU:
+            case SpeciesId.TAPU_BULU:
-            case Species.TAPU_FINI:
+            case SpeciesId.TAPU_FINI:
               return "battle_legendary_tapu";
-            case Species.SOLGALEO:
+            case SpeciesId.SOLGALEO:
-            case Species.LUNALA:
+            case SpeciesId.LUNALA:
               return "battle_legendary_sol_lun";
-            case Species.NECROZMA:
+            case SpeciesId.NECROZMA:
               switch (pokemon.getFormKey()) {
                 case "dusk-mane":
                 case "dawn-wings":
@@ -365,50 +365,50 @@ export default class Battle {
                 default:
                   return "battle_legendary_sol_lun";
               }
-            case Species.NIHILEGO:
+            case SpeciesId.NIHILEGO:
-            case Species.PHEROMOSA:
+            case SpeciesId.PHEROMOSA:
-            case Species.BUZZWOLE:
+            case SpeciesId.BUZZWOLE:
-            case Species.XURKITREE:
+            case SpeciesId.XURKITREE:
-            case Species.CELESTEELA:
+            case SpeciesId.CELESTEELA:
-            case Species.KARTANA:
+            case SpeciesId.KARTANA:
-            case Species.GUZZLORD:
+            case SpeciesId.GUZZLORD:
-            case Species.POIPOLE:
+            case SpeciesId.POIPOLE:
-            case Species.NAGANADEL:
+            case SpeciesId.NAGANADEL:
-            case Species.STAKATAKA:
+            case SpeciesId.STAKATAKA:
-            case Species.BLACEPHALON:
+            case SpeciesId.BLACEPHALON:
               return "battle_legendary_ub";
-            case Species.ZACIAN:
+            case SpeciesId.ZACIAN:
-            case Species.ZAMAZENTA:
+            case SpeciesId.ZAMAZENTA:
               return "battle_legendary_zac_zam";
-            case Species.GLASTRIER:
+            case SpeciesId.GLASTRIER:
-            case Species.SPECTRIER:
+            case SpeciesId.SPECTRIER:
               return "battle_legendary_glas_spec";
-            case Species.CALYREX:
+            case SpeciesId.CALYREX:
               if (pokemon.getFormKey() === "ice" || pokemon.getFormKey() === "shadow") {
                 return "battle_legendary_riders";
               }
               return "battle_legendary_calyrex";
-            case Species.GALAR_ARTICUNO:
+            case SpeciesId.GALAR_ARTICUNO:
-            case Species.GALAR_ZAPDOS:
+            case SpeciesId.GALAR_ZAPDOS:
-            case Species.GALAR_MOLTRES:
+            case SpeciesId.GALAR_MOLTRES:
               return "battle_legendary_birds_galar";
-            case Species.WO_CHIEN:
+            case SpeciesId.WO_CHIEN:
-            case Species.CHIEN_PAO:
+            case SpeciesId.CHIEN_PAO:
-            case Species.TING_LU:
+            case SpeciesId.TING_LU:
-            case Species.CHI_YU:
+            case SpeciesId.CHI_YU:
               return "battle_legendary_ruinous";
-            case Species.KORAIDON:
+            case SpeciesId.KORAIDON:
-            case Species.MIRAIDON:
+            case SpeciesId.MIRAIDON:
               return "battle_legendary_kor_mir";
-            case Species.OKIDOGI:
+            case SpeciesId.OKIDOGI:
-            case Species.MUNKIDORI:
+            case SpeciesId.MUNKIDORI:
-            case Species.FEZANDIPITI:
+            case SpeciesId.FEZANDIPITI:
               return "battle_legendary_loyal_three";
-            case Species.OGERPON:
+            case SpeciesId.OGERPON:
               return "battle_legendary_ogerpon";
-            case Species.TERAPAGOS:
+            case SpeciesId.TERAPAGOS:
               return "battle_legendary_terapagos";
-            case Species.PECHARUNT:
+            case SpeciesId.PECHARUNT:
               return "battle_legendary_pecharunt";
             default:
               if (pokemon.species.legendary) {

src/data/abilities/ability-class.ts

@@ -1,4 +1,4 @@
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 import type { AbAttrCondition } from "#app/@types/ability-types";
 import type { AbAttr } from "#app/data/abilities/ab-attrs/ab-attr";
 import i18next from "i18next";
@@ -6,7 +6,7 @@ import type { Localizable } from "#app/interfaces/locales";
 import type { Constructor } from "#app/utils/common";
 
 export class Ability implements Localizable {
-  public id: Abilities;
+  public id: AbilityId;
 
   private nameAppend: string;
   public name: string;
@@ -20,7 +20,7 @@ export class Ability implements Localizable {
   public attrs: AbAttr[];
   public conditions: AbAttrCondition[];
 
-  constructor(id: Abilities, generation: number) {
+  constructor(id: AbilityId, generation: number) {
     this.id = id;
 
     this.nameAppend = "";
@@ -39,7 +39,7 @@ export class Ability implements Localizable {
     return this.isCopiable && this.isReplaceable;
   }
   localize(): void {
-    const i18nKey = Abilities[this.id]
+    const i18nKey = AbilityId[this.id]
       .split("_")
       .filter(f => f)
       .map((f, i) => (i ? `${f[0]}${f.slice(1).toLowerCase()}` : f.toLowerCase()))

src/data/arena-tag.ts

@@ -22,10 +22,10 @@ import {
 import { Stat } from "#enums/stat";
 import { CommonAnim, CommonBattleAnim } from "#app/data/battle-anims";
 import i18next from "i18next";
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 import { ArenaTagType } from "#enums/arena-tag-type";
 import { BattlerTagType } from "#enums/battler-tag-type";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { MoveEffectPhase } from "#app/phases/move-effect-phase";
 import { PokemonHealPhase } from "#app/phases/pokemon-heal-phase";
 import { StatStageChangePhase } from "#app/phases/stat-stage-change-phase";
@@ -41,7 +41,7 @@ export abstract class ArenaTag {
   constructor(
     public tagType: ArenaTagType,
     public turnCount: number,
-    public sourceMove?: Moves,
+    public sourceMove?: MoveId,
     public sourceId?: number,
     public side: ArenaTagSide = ArenaTagSide.BOTH,
   ) {}
@@ -116,7 +116,7 @@ export abstract class ArenaTag {
  */
 export class MistTag extends ArenaTag {
   constructor(turnCount: number, sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.MIST, turnCount, Moves.MIST, sourceId, side);
+    super(ArenaTagType.MIST, turnCount, MoveId.MIST, sourceId, side);
   }
 
   onAdd(arena: Arena, quiet = false): void {
@@ -188,7 +188,7 @@ export class WeakenMoveScreenTag extends ArenaTag {
   constructor(
     tagType: ArenaTagType,
     turnCount: number,
-    sourceMove: Moves,
+    sourceMove: MoveId,
     sourceId: number,
     side: ArenaTagSide,
     weakenedCategories: MoveCategory[],
@@ -230,11 +230,11 @@ export class WeakenMoveScreenTag extends ArenaTag {
 
 /**
  * Reduces the damage of physical moves.
- * Used by {@linkcode Moves.REFLECT}
+ * Used by {@linkcode MoveId.REFLECT}
  */
 class ReflectTag extends WeakenMoveScreenTag {
   constructor(turnCount: number, sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.REFLECT, turnCount, Moves.REFLECT, sourceId, side, [MoveCategory.PHYSICAL]);
+    super(ArenaTagType.REFLECT, turnCount, MoveId.REFLECT, sourceId, side, [MoveCategory.PHYSICAL]);
   }
 
   onAdd(_arena: Arena, quiet = false): void {
@@ -250,11 +250,11 @@ class ReflectTag extends WeakenMoveScreenTag {
 
 /**
  * Reduces the damage of special moves.
- * Used by {@linkcode Moves.LIGHT_SCREEN}
+ * Used by {@linkcode MoveId.LIGHT_SCREEN}
  */
 class LightScreenTag extends WeakenMoveScreenTag {
   constructor(turnCount: number, sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.LIGHT_SCREEN, turnCount, Moves.LIGHT_SCREEN, sourceId, side, [MoveCategory.SPECIAL]);
+    super(ArenaTagType.LIGHT_SCREEN, turnCount, MoveId.LIGHT_SCREEN, sourceId, side, [MoveCategory.SPECIAL]);
   }
 
   onAdd(_arena: Arena, quiet = false): void {
@@ -270,11 +270,11 @@ class LightScreenTag extends WeakenMoveScreenTag {
 
 /**
  * Reduces the damage of physical and special moves.
- * Used by {@linkcode Moves.AURORA_VEIL}
+ * Used by {@linkcode MoveId.AURORA_VEIL}
  */
 class AuroraVeilTag extends WeakenMoveScreenTag {
   constructor(turnCount: number, sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.AURORA_VEIL, turnCount, Moves.AURORA_VEIL, sourceId, side, [
+    super(ArenaTagType.AURORA_VEIL, turnCount, MoveId.AURORA_VEIL, sourceId, side, [
       MoveCategory.SPECIAL,
       MoveCategory.PHYSICAL,
     ]);
@@ -291,7 +291,7 @@ class AuroraVeilTag extends WeakenMoveScreenTag {
   }
 }
 
-type ProtectConditionFunc = (arena: Arena, moveId: Moves) => boolean;
+type ProtectConditionFunc = (arena: Arena, moveId: MoveId) => boolean;
 
 /**
  * Class to implement conditional team protection
@@ -305,7 +305,7 @@ export class ConditionalProtectTag extends ArenaTag {
 
   constructor(
     tagType: ArenaTagType,
-    sourceMove: Moves,
+    sourceMove: MoveId,
     sourceId: number,
     side: ArenaTagSide,
     condition: ProtectConditionFunc,
@@ -337,7 +337,7 @@ export class ConditionalProtectTag extends ArenaTag {
    * @param isProtected a {@linkcode BooleanHolder} used to flag if the move is protected against
    * @param _attacker the attacking {@linkcode Pokemon}
    * @param defender the defending {@linkcode Pokemon}
-   * @param moveId the {@linkcode Moves | identifier} for the move being used
+   * @param moveId the {@linkcode MoveId | identifier} for the move being used
    * @param ignoresProtectBypass a {@linkcode BooleanHolder} used to flag if a protection effect supercedes effects that ignore protection
    * @returns `true` if this tag protected against the attack; `false` otherwise
    */
@@ -347,7 +347,7 @@ export class ConditionalProtectTag extends ArenaTag {
     isProtected: BooleanHolder,
     _attacker: Pokemon,
     defender: Pokemon,
-    moveId: Moves,
+    moveId: MoveId,
     ignoresProtectBypass: BooleanHolder,
   ): boolean {
     if ((this.side === ArenaTagSide.PLAYER) === defender.isPlayer() && this.protectConditionFunc(arena, moveId)) {
@@ -375,7 +375,7 @@ export class ConditionalProtectTag extends ArenaTag {
  * Condition function for {@link https://bulbapedia.bulbagarden.net/wiki/Quick_Guard_(move) Quick Guard's}
  * protection effect.
  * @param _arena {@linkcode Arena} The arena containing the protection effect
- * @param moveId {@linkcode Moves} The move to check against this condition
+ * @param moveId {@linkcode MoveId} The move to check against this condition
  * @returns `true` if the incoming move's priority is greater than 0.
  *   This includes moves with modified priorities from abilities (e.g. Prankster)
  */
@@ -398,7 +398,7 @@ const QuickGuardConditionFunc: ProtectConditionFunc = (_arena, moveId) => {
  */
 class QuickGuardTag extends ConditionalProtectTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.QUICK_GUARD, Moves.QUICK_GUARD, sourceId, side, QuickGuardConditionFunc);
+    super(ArenaTagType.QUICK_GUARD, MoveId.QUICK_GUARD, sourceId, side, QuickGuardConditionFunc);
   }
 }
 
@@ -406,7 +406,7 @@ class QuickGuardTag extends ConditionalProtectTag {
  * Condition function for {@link https://bulbapedia.bulbagarden.net/wiki/Wide_Guard_(move) Wide Guard's}
  * protection effect.
  * @param _arena {@linkcode Arena} The arena containing the protection effect
- * @param moveId {@linkcode Moves} The move to check against this condition
+ * @param moveId {@linkcode MoveId} The move to check against this condition
  * @returns `true` if the incoming move is multi-targeted (even if it's only used against one Pokemon).
  */
 const WideGuardConditionFunc: ProtectConditionFunc = (_arena, moveId): boolean => {
@@ -429,7 +429,7 @@ const WideGuardConditionFunc: ProtectConditionFunc = (_arena, moveId): boolean =
  */
 class WideGuardTag extends ConditionalProtectTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.WIDE_GUARD, Moves.WIDE_GUARD, sourceId, side, WideGuardConditionFunc);
+    super(ArenaTagType.WIDE_GUARD, MoveId.WIDE_GUARD, sourceId, side, WideGuardConditionFunc);
   }
 }
 
@@ -437,7 +437,7 @@ class WideGuardTag extends ConditionalProtectTag {
  * Condition function for {@link https://bulbapedia.bulbagarden.net/wiki/Mat_Block_(move) Mat Block's}
  * protection effect.
  * @param _arena {@linkcode Arena} The arena containing the protection effect.
- * @param moveId {@linkcode Moves} The move to check against this condition.
+ * @param moveId {@linkcode MoveId} The move to check against this condition.
  * @returns `true` if the incoming move is not a Status move.
  */
 const MatBlockConditionFunc: ProtectConditionFunc = (_arena, moveId): boolean => {
@@ -451,7 +451,7 @@ const MatBlockConditionFunc: ProtectConditionFunc = (_arena, moveId): boolean =>
  */
 class MatBlockTag extends ConditionalProtectTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.MAT_BLOCK, Moves.MAT_BLOCK, sourceId, side, MatBlockConditionFunc);
+    super(ArenaTagType.MAT_BLOCK, MoveId.MAT_BLOCK, sourceId, side, MatBlockConditionFunc);
   }
 
   onAdd(_arena: Arena) {
@@ -474,7 +474,7 @@ class MatBlockTag extends ConditionalProtectTag {
  * Condition function for {@link https://bulbapedia.bulbagarden.net/wiki/Crafty_Shield_(move) Crafty Shield's}
  * protection effect.
  * @param _arena {@linkcode Arena} The arena containing the protection effect
- * @param moveId {@linkcode Moves} The move to check against this condition
+ * @param moveId {@linkcode MoveId} The move to check against this condition
  * @returns `true` if the incoming move is a Status move, is not a hazard, and does not target all
  * Pokemon or sides of the field.
  */
@@ -495,7 +495,7 @@ const CraftyShieldConditionFunc: ProtectConditionFunc = (_arena, moveId) => {
  */
 class CraftyShieldTag extends ConditionalProtectTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.CRAFTY_SHIELD, Moves.CRAFTY_SHIELD, sourceId, side, CraftyShieldConditionFunc, true);
+    super(ArenaTagType.CRAFTY_SHIELD, MoveId.CRAFTY_SHIELD, sourceId, side, CraftyShieldConditionFunc, true);
   }
 }
 
@@ -507,11 +507,11 @@ export class NoCritTag extends ArenaTag {
   /**
    * Constructor method for the NoCritTag class
    * @param turnCount `number` the number of turns this effect lasts
-   * @param sourceMove {@linkcode Moves} the move that created this effect
+   * @param sourceMove {@linkcode MoveId} the move that created this effect
    * @param sourceId `number` the ID of the {@linkcode Pokemon} that created this effect
    * @param side {@linkcode ArenaTagSide} the side to which this effect belongs
    */
-  constructor(turnCount: number, sourceMove: Moves, sourceId: number, side: ArenaTagSide) {
+  constructor(turnCount: number, sourceMove: MoveId, sourceId: number, side: ArenaTagSide) {
     super(ArenaTagType.NO_CRIT, turnCount, sourceMove, sourceId, side);
   }
 
@@ -546,7 +546,7 @@ class WishTag extends ArenaTag {
   private healHp: number;
 
   constructor(turnCount: number, sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.WISH, turnCount, Moves.WISH, sourceId, side);
+    super(ArenaTagType.WISH, turnCount, MoveId.WISH, sourceId, side);
   }
 
   onAdd(_arena: Arena): void {
@@ -588,7 +588,7 @@ export class WeakenMoveTypeTag extends ArenaTag {
    * @param sourceMove - The move that created the tag.
    * @param sourceId - The ID of the source of the tag.
    */
-  constructor(tagType: ArenaTagType, turnCount: number, type: PokemonType, sourceMove: Moves, sourceId: number) {
+  constructor(tagType: ArenaTagType, turnCount: number, type: PokemonType, sourceMove: MoveId, sourceId: number) {
     super(tagType, turnCount, sourceMove, sourceId);
 
     this.weakenedType = type;
@@ -617,7 +617,7 @@ export class WeakenMoveTypeTag extends ArenaTag {
  */
 class MudSportTag extends WeakenMoveTypeTag {
   constructor(turnCount: number, sourceId: number) {
-    super(ArenaTagType.MUD_SPORT, turnCount, PokemonType.ELECTRIC, Moves.MUD_SPORT, sourceId);
+    super(ArenaTagType.MUD_SPORT, turnCount, PokemonType.ELECTRIC, MoveId.MUD_SPORT, sourceId);
   }
 
   onAdd(_arena: Arena): void {
@@ -635,7 +635,7 @@ class MudSportTag extends WeakenMoveTypeTag {
  */
 class WaterSportTag extends WeakenMoveTypeTag {
   constructor(turnCount: number, sourceId: number) {
-    super(ArenaTagType.WATER_SPORT, turnCount, PokemonType.FIRE, Moves.WATER_SPORT, sourceId);
+    super(ArenaTagType.WATER_SPORT, turnCount, PokemonType.FIRE, MoveId.WATER_SPORT, sourceId);
   }
 
   onAdd(_arena: Arena): void {
@@ -653,7 +653,7 @@ class WaterSportTag extends WeakenMoveTypeTag {
  * Converts Normal-type moves to Electric type for the rest of the turn.
  */
 export class IonDelugeTag extends ArenaTag {
-  constructor(sourceMove?: Moves) {
+  constructor(sourceMove?: MoveId) {
     super(ArenaTagType.ION_DELUGE, 1, sourceMove);
   }
 
@@ -696,7 +696,7 @@ export class ArenaTrapTag extends ArenaTag {
    * @param side - The side (player or enemy) the tag affects.
    * @param maxLayers - The maximum amount of layers this tag can have.
    */
-  constructor(tagType: ArenaTagType, sourceMove: Moves, sourceId: number, side: ArenaTagSide, maxLayers: number) {
+  constructor(tagType: ArenaTagType, sourceMove: MoveId, sourceId: number, side: ArenaTagSide, maxLayers: number) {
     super(tagType, 0, sourceMove, sourceId, side);
 
     this.layers = 1;
@@ -750,7 +750,7 @@ export class ArenaTrapTag extends ArenaTag {
  */
 class SpikesTag extends ArenaTrapTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.SPIKES, Moves.SPIKES, sourceId, side, 3);
+    super(ArenaTagType.SPIKES, MoveId.SPIKES, sourceId, side, 3);
   }
 
   onAdd(arena: Arena, quiet = false): void {
@@ -802,7 +802,7 @@ class ToxicSpikesTag extends ArenaTrapTag {
   private neutralized: boolean;
 
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.TOXIC_SPIKES, Moves.TOXIC_SPIKES, sourceId, side, 2);
+    super(ArenaTagType.TOXIC_SPIKES, MoveId.TOXIC_SPIKES, sourceId, side, 2);
     this.neutralized = false;
   }
 
@@ -867,7 +867,7 @@ class ToxicSpikesTag extends ArenaTrapTag {
 }
 
 /**
- * Arena Tag class for delayed attacks, such as {@linkcode Moves.FUTURE_SIGHT} or {@linkcode Moves.DOOM_DESIRE}.
+ * Arena Tag class for delayed attacks, such as {@linkcode MoveId.FUTURE_SIGHT} or {@linkcode MoveId.DOOM_DESIRE}.
  * Delays the attack's effect by a set amount of turns, usually 3 (including the turn the move is used),
  * and deals damage after the turn count is reached.
  */
@@ -876,7 +876,7 @@ export class DelayedAttackTag extends ArenaTag {
 
   constructor(
     tagType: ArenaTagType,
-    sourceMove: Moves | undefined,
+    sourceMove: MoveId | undefined,
     sourceId: number,
     targetIndex: BattlerIndex,
     side: ArenaTagSide = ArenaTagSide.BOTH,
@@ -909,7 +909,7 @@ export class DelayedAttackTag extends ArenaTag {
  */
 class StealthRockTag extends ArenaTrapTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.STEALTH_ROCK, Moves.STEALTH_ROCK, sourceId, side, 1);
+    super(ArenaTagType.STEALTH_ROCK, MoveId.STEALTH_ROCK, sourceId, side, 1);
   }
 
   onAdd(arena: Arena, quiet = false): void {
@@ -994,7 +994,7 @@ class StealthRockTag extends ArenaTrapTag {
  */
 class StickyWebTag extends ArenaTrapTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.STICKY_WEB, Moves.STICKY_WEB, sourceId, side, 1);
+    super(ArenaTagType.STICKY_WEB, MoveId.STICKY_WEB, sourceId, side, 1);
   }
 
   onAdd(arena: Arena, quiet = false): void {
@@ -1055,7 +1055,7 @@ class StickyWebTag extends ArenaTrapTag {
  */
 export class TrickRoomTag extends ArenaTag {
   constructor(turnCount: number, sourceId: number) {
-    super(ArenaTagType.TRICK_ROOM, turnCount, Moves.TRICK_ROOM, sourceId);
+    super(ArenaTagType.TRICK_ROOM, turnCount, MoveId.TRICK_ROOM, sourceId);
   }
 
   /**
@@ -1090,11 +1090,11 @@ export class TrickRoomTag extends ArenaTag {
 /**
  * Arena Tag class for {@link https://bulbapedia.bulbagarden.net/wiki/Gravity_(move) Gravity}.
  * Grounds all Pokémon on the field, including Flying-types and those with
- * {@linkcode Abilities.LEVITATE} for the duration of the arena tag, usually 5 turns.
+ * {@linkcode AbilityId.LEVITATE} for the duration of the arena tag, usually 5 turns.
  */
 export class GravityTag extends ArenaTag {
   constructor(turnCount: number) {
-    super(ArenaTagType.GRAVITY, turnCount, Moves.GRAVITY);
+    super(ArenaTagType.GRAVITY, turnCount, MoveId.GRAVITY);
   }
 
   onAdd(_arena: Arena): void {
@@ -1122,7 +1122,7 @@ export class GravityTag extends ArenaTag {
  */
 class TailwindTag extends ArenaTag {
   constructor(turnCount: number, sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.TAILWIND, turnCount, Moves.TAILWIND, sourceId, side);
+    super(ArenaTagType.TAILWIND, turnCount, MoveId.TAILWIND, sourceId, side);
   }
 
   onAdd(_arena: Arena, quiet = false): void {
@@ -1139,7 +1139,7 @@ class TailwindTag extends ArenaTag {
 
     for (const pokemon of party) {
       // Apply the CHARGED tag to party members with the WIND_POWER ability
-      if (pokemon.hasAbility(Abilities.WIND_POWER) && !pokemon.getTag(BattlerTagType.CHARGED)) {
+      if (pokemon.hasAbility(AbilityId.WIND_POWER) && !pokemon.getTag(BattlerTagType.CHARGED)) {
         pokemon.addTag(BattlerTagType.CHARGED);
         globalScene.queueMessage(
           i18next.t("abilityTriggers:windPowerCharged", {
@@ -1150,7 +1150,7 @@ class TailwindTag extends ArenaTag {
       }
       // Raise attack by one stage if party member has WIND_RIDER ability
       // TODO: Ability displays should be handled by the ability
-      if (pokemon.hasAbility(Abilities.WIND_RIDER)) {
+      if (pokemon.hasAbility(AbilityId.WIND_RIDER)) {
         globalScene.queueAbilityDisplay(pokemon, false, true);
         globalScene.unshiftPhase(new StatStageChangePhase(pokemon.getBattlerIndex(), true, [Stat.ATK], 1, true));
         globalScene.queueAbilityDisplay(pokemon, false, false);
@@ -1171,11 +1171,11 @@ class TailwindTag extends ArenaTag {
 
 /**
  * Arena Tag class for {@link https://bulbapedia.bulbagarden.net/wiki/Happy_Hour_(move) Happy Hour}.
- * Doubles the prize money from trainers and money moves like {@linkcode Moves.PAY_DAY} and {@linkcode Moves.MAKE_IT_RAIN}.
+ * Doubles the prize money from trainers and money moves like {@linkcode MoveId.PAY_DAY} and {@linkcode MoveId.MAKE_IT_RAIN}.
  */
 class HappyHourTag extends ArenaTag {
   constructor(turnCount: number, sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.HAPPY_HOUR, turnCount, Moves.HAPPY_HOUR, sourceId, side);
+    super(ArenaTagType.HAPPY_HOUR, turnCount, MoveId.HAPPY_HOUR, sourceId, side);
   }
 
   onAdd(_arena: Arena): void {
@@ -1189,7 +1189,7 @@ class HappyHourTag extends ArenaTag {
 
 class SafeguardTag extends ArenaTag {
   constructor(turnCount: number, sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.SAFEGUARD, turnCount, Moves.SAFEGUARD, sourceId, side);
+    super(ArenaTagType.SAFEGUARD, turnCount, MoveId.SAFEGUARD, sourceId, side);
   }
 
   onAdd(_arena: Arena): void {
@@ -1221,7 +1221,7 @@ class NoneTag extends ArenaTag {
  */
 class ImprisonTag extends ArenaTrapTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.IMPRISON, Moves.IMPRISON, sourceId, side, 1);
+    super(ArenaTagType.IMPRISON, MoveId.IMPRISON, sourceId, side, 1);
   }
 
   /**
@@ -1234,7 +1234,7 @@ class ImprisonTag extends ArenaTrapTag {
       const party = this.getAffectedPokemon();
       party?.forEach((p: Pokemon) => {
         if (p.isAllowedInBattle()) {
-          p.addTag(BattlerTagType.IMPRISON, 1, Moves.IMPRISON, this.sourceId);
+          p.addTag(BattlerTagType.IMPRISON, 1, MoveId.IMPRISON, this.sourceId);
         }
       });
       globalScene.queueMessage(
@@ -1263,7 +1263,7 @@ class ImprisonTag extends ArenaTrapTag {
   override activateTrap(pokemon: Pokemon): boolean {
     const source = this.getSourcePokemon();
     if (source?.isActive(true) && pokemon.isAllowedInBattle()) {
-      pokemon.addTag(BattlerTagType.IMPRISON, 1, Moves.IMPRISON, this.sourceId);
+      pokemon.addTag(BattlerTagType.IMPRISON, 1, MoveId.IMPRISON, this.sourceId);
     }
     return true;
   }
@@ -1289,7 +1289,7 @@ class ImprisonTag extends ArenaTrapTag {
  */
 class FireGrassPledgeTag extends ArenaTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.FIRE_GRASS_PLEDGE, 4, Moves.FIRE_PLEDGE, sourceId, side);
+    super(ArenaTagType.FIRE_GRASS_PLEDGE, 4, MoveId.FIRE_PLEDGE, sourceId, side);
   }
 
   override onAdd(_arena: Arena): void {
@@ -1334,7 +1334,7 @@ class FireGrassPledgeTag extends ArenaTag {
  */
 class WaterFirePledgeTag extends ArenaTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.WATER_FIRE_PLEDGE, 4, Moves.WATER_PLEDGE, sourceId, side);
+    super(ArenaTagType.WATER_FIRE_PLEDGE, 4, MoveId.WATER_PLEDGE, sourceId, side);
   }
 
   override onAdd(_arena: Arena): void {
@@ -1368,7 +1368,7 @@ class WaterFirePledgeTag extends ArenaTag {
  */
 class GrassWaterPledgeTag extends ArenaTag {
   constructor(sourceId: number, side: ArenaTagSide) {
-    super(ArenaTagType.GRASS_WATER_PLEDGE, 4, Moves.GRASS_PLEDGE, sourceId, side);
+    super(ArenaTagType.GRASS_WATER_PLEDGE, 4, MoveId.GRASS_PLEDGE, sourceId, side);
   }
 
   override onAdd(_arena: Arena): void {
@@ -1390,7 +1390,7 @@ class GrassWaterPledgeTag extends ArenaTag {
  */
 export class FairyLockTag extends ArenaTag {
   constructor(turnCount: number, sourceId: number) {
-    super(ArenaTagType.FAIRY_LOCK, turnCount, Moves.FAIRY_LOCK, sourceId);
+    super(ArenaTagType.FAIRY_LOCK, turnCount, MoveId.FAIRY_LOCK, sourceId);
   }
 
   onAdd(_arena: Arena): void {
@@ -1485,7 +1485,7 @@ export class SuppressAbilitiesTag extends ArenaTag {
 export function getArenaTag(
   tagType: ArenaTagType,
   turnCount: number,
-  sourceMove: Moves | undefined,
+  sourceMove: MoveId | undefined,
   sourceId: number,
   targetIndex?: BattlerIndex,
   side: ArenaTagSide = ArenaTagSide.BOTH,

src/data/balance/signature-species.ts

@@ -1,7 +1,7 @@
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 
 export type SignatureSpecies = {
-  [key in string]: (Species | Species[])[];
+  [key in string]: (SpeciesId | SpeciesId[])[];
 };
 
 /**
@@ -18,87 +18,87 @@ export type SignatureSpecies = {
  */
 export const signatureSpecies: SignatureSpecies = new Proxy({
   // Gym Leaders- Kanto
-  BROCK: [Species.ONIX, Species.GEODUDE, [Species.OMANYTE, Species.KABUTO], Species.AERODACTYL],
+  BROCK: [SpeciesId.ONIX, SpeciesId.GEODUDE, [SpeciesId.OMANYTE, SpeciesId.KABUTO], SpeciesId.AERODACTYL],
-  MISTY: [Species.STARYU, Species.PSYDUCK, Species.WOOPER, Species.LAPRAS],
+  MISTY: [SpeciesId.STARYU, SpeciesId.PSYDUCK, SpeciesId.WOOPER, SpeciesId.LAPRAS],
-  LT_SURGE: [Species.PICHU, Species.VOLTORB, Species.ELEKID, Species.JOLTEON],
+  LT_SURGE: [SpeciesId.PICHU, SpeciesId.VOLTORB, SpeciesId.ELEKID, SpeciesId.JOLTEON],
-  ERIKA: [Species.ODDISH, Species.BELLSPROUT, Species.TANGELA, Species.HOPPIP],
+  ERIKA: [SpeciesId.ODDISH, SpeciesId.BELLSPROUT, SpeciesId.TANGELA, SpeciesId.HOPPIP],
-  JANINE: [Species.VENONAT, Species.SPINARAK, Species.ZUBAT, Species.KOFFING],
+  JANINE: [SpeciesId.VENONAT, SpeciesId.SPINARAK, SpeciesId.ZUBAT, SpeciesId.KOFFING],
-  SABRINA: [Species.ABRA, Species.MR_MIME, Species.SMOOCHUM, Species.ESPEON],
+  SABRINA: [SpeciesId.ABRA, SpeciesId.MR_MIME, SpeciesId.SMOOCHUM, SpeciesId.ESPEON],
-  BLAINE: [Species.GROWLITHE, Species.PONYTA, Species.MAGBY, Species.VULPIX],
+  BLAINE: [SpeciesId.GROWLITHE, SpeciesId.PONYTA, SpeciesId.MAGBY, SpeciesId.VULPIX],
-  GIOVANNI: [Species.RHYHORN, Species.MEOWTH, [Species.NIDORAN_F, Species.NIDORAN_M], Species.DIGLETT], // Tera Ground Meowth
+  GIOVANNI: [SpeciesId.RHYHORN, SpeciesId.MEOWTH, [SpeciesId.NIDORAN_F, SpeciesId.NIDORAN_M], SpeciesId.DIGLETT], // Tera Ground Meowth
   // Gym Leaders- Johto
-  FALKNER: [Species.PIDGEY, Species.HOOTHOOT, Species.NATU, Species.MURKROW],
+  FALKNER: [SpeciesId.PIDGEY, SpeciesId.HOOTHOOT, SpeciesId.NATU, SpeciesId.MURKROW],
-  BUGSY: [Species.SCYTHER, Species.SHUCKLE, Species.YANMA, [Species.PINSIR, Species.HERACROSS]],
+  BUGSY: [SpeciesId.SCYTHER, SpeciesId.SHUCKLE, SpeciesId.YANMA, [SpeciesId.PINSIR, SpeciesId.HERACROSS]],
-  WHITNEY: [Species.MILTANK, Species.AIPOM, Species.IGGLYBUFF, [Species.GIRAFARIG, Species.STANTLER]],
+  WHITNEY: [SpeciesId.MILTANK, SpeciesId.AIPOM, SpeciesId.IGGLYBUFF, [SpeciesId.GIRAFARIG, SpeciesId.STANTLER]],
-  MORTY: [Species.GASTLY, Species.MISDREAVUS, Species.DUSKULL, Species.SABLEYE],
+  MORTY: [SpeciesId.GASTLY, SpeciesId.MISDREAVUS, SpeciesId.DUSKULL, SpeciesId.SABLEYE],
-  CHUCK: [Species.POLIWRATH, Species.MANKEY, Species.TYROGUE, Species.MACHOP],
+  CHUCK: [SpeciesId.POLIWRATH, SpeciesId.MANKEY, SpeciesId.TYROGUE, SpeciesId.MACHOP],
-  JASMINE: [Species.STEELIX, Species.MAGNEMITE, Species.PINECO, Species.SKARMORY],
+  JASMINE: [SpeciesId.STEELIX, SpeciesId.MAGNEMITE, SpeciesId.PINECO, SpeciesId.SKARMORY],
-  PRYCE: [Species.SWINUB, Species.SEEL, Species.SHELLDER, Species.SNEASEL],
+  PRYCE: [SpeciesId.SWINUB, SpeciesId.SEEL, SpeciesId.SHELLDER, SpeciesId.SNEASEL],
-  CLAIR: [Species.HORSEA, Species.DRATINI, Species.MAGIKARP, Species.DRUDDIGON], // Tera Dragon Magikarp
+  CLAIR: [SpeciesId.HORSEA, SpeciesId.DRATINI, SpeciesId.MAGIKARP, SpeciesId.DRUDDIGON], // Tera Dragon Magikarp
   // Gym Leaders- Hoenn
-  ROXANNE: [Species.NOSEPASS, Species.GEODUDE, [Species.LILEEP, Species.ANORITH], Species.ARON],
+  ROXANNE: [SpeciesId.NOSEPASS, SpeciesId.GEODUDE, [SpeciesId.LILEEP, SpeciesId.ANORITH], SpeciesId.ARON],
-  BRAWLY: [Species.MAKUHITA, Species.MACHOP, Species.MEDITITE, Species.SHROOMISH],
+  BRAWLY: [SpeciesId.MAKUHITA, SpeciesId.MACHOP, SpeciesId.MEDITITE, SpeciesId.SHROOMISH],
-  WATTSON: [Species.ELECTRIKE, Species.VOLTORB, Species.MAGNEMITE, [Species.PLUSLE, Species.MINUN]],
+  WATTSON: [SpeciesId.ELECTRIKE, SpeciesId.VOLTORB, SpeciesId.MAGNEMITE, [SpeciesId.PLUSLE, SpeciesId.MINUN]],
-  FLANNERY: [Species.TORKOAL, Species.SLUGMA, Species.NUMEL, Species.HOUNDOUR],
+  FLANNERY: [SpeciesId.TORKOAL, SpeciesId.SLUGMA, SpeciesId.NUMEL, SpeciesId.HOUNDOUR],
-  NORMAN: [Species.SLAKOTH, Species.KECLEON, Species.WHISMUR, Species.ZANGOOSE],
+  NORMAN: [SpeciesId.SLAKOTH, SpeciesId.KECLEON, SpeciesId.WHISMUR, SpeciesId.ZANGOOSE],
-  WINONA: [Species.SWABLU, Species.WINGULL, Species.TROPIUS, Species.SKARMORY],
+  WINONA: [SpeciesId.SWABLU, SpeciesId.WINGULL, SpeciesId.TROPIUS, SpeciesId.SKARMORY],
-  TATE: [Species.SOLROCK, Species.NATU, Species.CHINGLING, Species.GALLADE],
+  TATE: [SpeciesId.SOLROCK, SpeciesId.NATU, SpeciesId.CHINGLING, SpeciesId.GALLADE],
-  LIZA: [Species.LUNATONE, Species.BALTOY, Species.SPOINK, Species.GARDEVOIR],
+  LIZA: [SpeciesId.LUNATONE, SpeciesId.BALTOY, SpeciesId.SPOINK, SpeciesId.GARDEVOIR],
-  JUAN: [Species.HORSEA, Species.SPHEAL, Species.BARBOACH, Species.CORPHISH],
+  JUAN: [SpeciesId.HORSEA, SpeciesId.SPHEAL, SpeciesId.BARBOACH, SpeciesId.CORPHISH],
   // Gym Leaders- Sinnoh
-  ROARK: [Species.CRANIDOS, Species.GEODUDE, Species.NOSEPASS, Species.LARVITAR],
+  ROARK: [SpeciesId.CRANIDOS, SpeciesId.GEODUDE, SpeciesId.NOSEPASS, SpeciesId.LARVITAR],
-  GARDENIA: [Species.BUDEW, Species.CHERUBI, Species.TURTWIG, Species.LEAFEON],
+  GARDENIA: [SpeciesId.BUDEW, SpeciesId.CHERUBI, SpeciesId.TURTWIG, SpeciesId.LEAFEON],
-  MAYLENE: [Species.RIOLU, Species.MEDITITE, Species.CHIMCHAR, Species.CROAGUNK],
+  MAYLENE: [SpeciesId.RIOLU, SpeciesId.MEDITITE, SpeciesId.CHIMCHAR, SpeciesId.CROAGUNK],
-  CRASHER_WAKE: [Species.BUIZEL, Species.WOOPER, Species.PIPLUP, Species.MAGIKARP],
+  CRASHER_WAKE: [SpeciesId.BUIZEL, SpeciesId.WOOPER, SpeciesId.PIPLUP, SpeciesId.MAGIKARP],
-  FANTINA: [Species.MISDREAVUS, Species.DRIFLOON, Species.DUSKULL, Species.SPIRITOMB],
+  FANTINA: [SpeciesId.MISDREAVUS, SpeciesId.DRIFLOON, SpeciesId.DUSKULL, SpeciesId.SPIRITOMB],
-  BYRON: [Species.SHIELDON, Species.BRONZOR, Species.ARON, Species.SKARMORY],
+  BYRON: [SpeciesId.SHIELDON, SpeciesId.BRONZOR, SpeciesId.ARON, SpeciesId.SKARMORY],
-  CANDICE: [Species.FROSLASS, Species.SNOVER, Species.SNEASEL, Species.GLACEON],
+  CANDICE: [SpeciesId.FROSLASS, SpeciesId.SNOVER, SpeciesId.SNEASEL, SpeciesId.GLACEON],
-  VOLKNER: [Species.ELEKID, Species.SHINX, Species.CHINCHOU, Species.ROTOM],
+  VOLKNER: [SpeciesId.ELEKID, SpeciesId.SHINX, SpeciesId.CHINCHOU, SpeciesId.ROTOM],
   // Gym Leaders- Unova
-  CILAN: [Species.PANSAGE, Species.SNIVY, Species.MARACTUS, Species.FERROSEED],
+  CILAN: [SpeciesId.PANSAGE, SpeciesId.SNIVY, SpeciesId.MARACTUS, SpeciesId.FERROSEED],
-  CHILI: [Species.PANSEAR, Species.TEPIG, Species.HEATMOR, Species.DARUMAKA],
+  CHILI: [SpeciesId.PANSEAR, SpeciesId.TEPIG, SpeciesId.HEATMOR, SpeciesId.DARUMAKA],
-  CRESS: [Species.PANPOUR, Species.OSHAWOTT, Species.BASCULIN, Species.TYMPOLE],
+  CRESS: [SpeciesId.PANPOUR, SpeciesId.OSHAWOTT, SpeciesId.BASCULIN, SpeciesId.TYMPOLE],
-  CHEREN: [Species.LILLIPUP, Species.MINCCINO, Species.PIDOVE, Species.BOUFFALANT],
+  CHEREN: [SpeciesId.LILLIPUP, SpeciesId.MINCCINO, SpeciesId.PIDOVE, SpeciesId.BOUFFALANT],
-  LENORA: [Species.PATRAT, Species.DEERLING, Species.AUDINO, Species.BRAVIARY],
+  LENORA: [SpeciesId.PATRAT, SpeciesId.DEERLING, SpeciesId.AUDINO, SpeciesId.BRAVIARY],
-  ROXIE: [Species.VENIPEDE, Species.KOFFING, Species.TRUBBISH, Species.TOXEL],
+  ROXIE: [SpeciesId.VENIPEDE, SpeciesId.KOFFING, SpeciesId.TRUBBISH, SpeciesId.TOXEL],
-  BURGH: [Species.SEWADDLE, Species.DWEBBLE, [Species.KARRABLAST, Species.SHELMET], Species.DURANT],
+  BURGH: [SpeciesId.SEWADDLE, SpeciesId.DWEBBLE, [SpeciesId.KARRABLAST, SpeciesId.SHELMET], SpeciesId.DURANT],
-  ELESA: [Species.BLITZLE, Species.EMOLGA, Species.JOLTIK, Species.TYNAMO],
+  ELESA: [SpeciesId.BLITZLE, SpeciesId.EMOLGA, SpeciesId.JOLTIK, SpeciesId.TYNAMO],
-  CLAY: [Species.DRILBUR, Species.SANDILE, Species.TYMPOLE, Species.GOLETT],
+  CLAY: [SpeciesId.DRILBUR, SpeciesId.SANDILE, SpeciesId.TYMPOLE, SpeciesId.GOLETT],
-  SKYLA: [Species.DUCKLETT, Species.WOOBAT, [Species.RUFFLET, Species.VULLABY], Species.ARCHEN],
+  SKYLA: [SpeciesId.DUCKLETT, SpeciesId.WOOBAT, [SpeciesId.RUFFLET, SpeciesId.VULLABY], SpeciesId.ARCHEN],
-  BRYCEN: [Species.CRYOGONAL, Species.VANILLITE, Species.CUBCHOO, Species.GALAR_DARUMAKA],
+  BRYCEN: [SpeciesId.CRYOGONAL, SpeciesId.VANILLITE, SpeciesId.CUBCHOO, SpeciesId.GALAR_DARUMAKA],
-  DRAYDEN: [Species.AXEW, Species.DRUDDIGON, Species.TRAPINCH, Species.DEINO],
+  DRAYDEN: [SpeciesId.AXEW, SpeciesId.DRUDDIGON, SpeciesId.TRAPINCH, SpeciesId.DEINO],
-  MARLON: [Species.FRILLISH, Species.TIRTOUGA, Species.WAILMER, Species.MANTYKE],
+  MARLON: [SpeciesId.FRILLISH, SpeciesId.TIRTOUGA, SpeciesId.WAILMER, SpeciesId.MANTYKE],
   // Gym Leaders- Kalos
-  VIOLA: [Species.SCATTERBUG, Species.SURSKIT, Species.CUTIEFLY, Species.BLIPBUG],
+  VIOLA: [SpeciesId.SCATTERBUG, SpeciesId.SURSKIT, SpeciesId.CUTIEFLY, SpeciesId.BLIPBUG],
-  GRANT: [Species.TYRUNT, Species.AMAURA, Species.BINACLE, Species.DWEBBLE],
+  GRANT: [SpeciesId.TYRUNT, SpeciesId.AMAURA, SpeciesId.BINACLE, SpeciesId.DWEBBLE],
-  KORRINA: [Species.RIOLU, Species.MIENFOO, Species.HAWLUCHA, Species.PANCHAM],
+  KORRINA: [SpeciesId.RIOLU, SpeciesId.MIENFOO, SpeciesId.HAWLUCHA, SpeciesId.PANCHAM],
-  RAMOS: [Species.SKIDDO, Species.HOPPIP, Species.BELLSPROUT, [Species.PHANTUMP, Species.PUMPKABOO]],
+  RAMOS: [SpeciesId.SKIDDO, SpeciesId.HOPPIP, SpeciesId.BELLSPROUT, [SpeciesId.PHANTUMP, SpeciesId.PUMPKABOO]],
-  CLEMONT: [Species.HELIOPTILE, Species.MAGNEMITE, Species.DEDENNE, Species.ROTOM],
+  CLEMONT: [SpeciesId.HELIOPTILE, SpeciesId.MAGNEMITE, SpeciesId.DEDENNE, SpeciesId.ROTOM],
-  VALERIE: [Species.SYLVEON, Species.MAWILE, Species.MR_MIME, [Species.SPRITZEE, Species.SWIRLIX]],
+  VALERIE: [SpeciesId.SYLVEON, SpeciesId.MAWILE, SpeciesId.MR_MIME, [SpeciesId.SPRITZEE, SpeciesId.SWIRLIX]],
-  OLYMPIA: [Species.ESPURR, Species.SIGILYPH, Species.INKAY, Species.SLOWKING],
+  OLYMPIA: [SpeciesId.ESPURR, SpeciesId.SIGILYPH, SpeciesId.INKAY, SpeciesId.SLOWKING],
-  WULFRIC: [Species.BERGMITE, Species.SNOVER, Species.CRYOGONAL, Species.SWINUB],
+  WULFRIC: [SpeciesId.BERGMITE, SpeciesId.SNOVER, SpeciesId.CRYOGONAL, SpeciesId.SWINUB],
   // Gym Leaders- Galar
-  MILO: [Species.GOSSIFLEUR, Species.SEEDOT, Species.APPLIN, Species.LOTAD],
+  MILO: [SpeciesId.GOSSIFLEUR, SpeciesId.SEEDOT, SpeciesId.APPLIN, SpeciesId.LOTAD],
-  NESSA: [Species.CHEWTLE, Species.WIMPOD, Species.ARROKUDA, Species.MAREANIE],
+  NESSA: [SpeciesId.CHEWTLE, SpeciesId.WIMPOD, SpeciesId.ARROKUDA, SpeciesId.MAREANIE],
-  KABU: [Species.SIZZLIPEDE, Species.VULPIX, Species.GROWLITHE, Species.TORKOAL],
+  KABU: [SpeciesId.SIZZLIPEDE, SpeciesId.VULPIX, SpeciesId.GROWLITHE, SpeciesId.TORKOAL],
-  BEA: [Species.MACHOP, Species.GALAR_FARFETCHD, Species.CLOBBOPUS, Species.FALINKS],
+  BEA: [SpeciesId.MACHOP, SpeciesId.GALAR_FARFETCHD, SpeciesId.CLOBBOPUS, SpeciesId.FALINKS],
-  ALLISTER: [Species.GASTLY, Species.GALAR_YAMASK, Species.GALAR_CORSOLA, Species.SINISTEA],
+  ALLISTER: [SpeciesId.GASTLY, SpeciesId.GALAR_YAMASK, SpeciesId.GALAR_CORSOLA, SpeciesId.SINISTEA],
-  OPAL: [Species.MILCERY, Species.GALAR_WEEZING, Species.TOGEPI, Species.MAWILE],
+  OPAL: [SpeciesId.MILCERY, SpeciesId.GALAR_WEEZING, SpeciesId.TOGEPI, SpeciesId.MAWILE],
-  BEDE: [Species.HATENNA, Species.GALAR_PONYTA, Species.GARDEVOIR, Species.SYLVEON],
+  BEDE: [SpeciesId.HATENNA, SpeciesId.GALAR_PONYTA, SpeciesId.GARDEVOIR, SpeciesId.SYLVEON],
-  GORDIE: [Species.ROLYCOLY, [Species.SHUCKLE, Species.BINACLE], Species.STONJOURNER, Species.LARVITAR],
+  GORDIE: [SpeciesId.ROLYCOLY, [SpeciesId.SHUCKLE, SpeciesId.BINACLE], SpeciesId.STONJOURNER, SpeciesId.LARVITAR],
-  MELONY: [Species.LAPRAS, Species.SNOM, Species.EISCUE, [Species.GALAR_MR_MIME, Species.GALAR_DARUMAKA]],
+  MELONY: [SpeciesId.LAPRAS, SpeciesId.SNOM, SpeciesId.EISCUE, [SpeciesId.GALAR_MR_MIME, SpeciesId.GALAR_DARUMAKA]],
-  PIERS: [Species.GALAR_ZIGZAGOON, Species.SCRAGGY, Species.TOXEL, Species.INKAY], // Tera Dark Toxel
+  PIERS: [SpeciesId.GALAR_ZIGZAGOON, SpeciesId.SCRAGGY, SpeciesId.TOXEL, SpeciesId.INKAY], // Tera Dark Toxel
-  MARNIE: [Species.IMPIDIMP, Species.MORPEKO, Species.PURRLOIN, Species.CROAGUNK], // Tera Dark Croagunk
+  MARNIE: [SpeciesId.IMPIDIMP, SpeciesId.MORPEKO, SpeciesId.PURRLOIN, SpeciesId.CROAGUNK], // Tera Dark Croagunk
-  RAIHAN: [Species.DURALUDON, Species.TRAPINCH, Species.GOOMY, Species.TURTONATOR],
+  RAIHAN: [SpeciesId.DURALUDON, SpeciesId.TRAPINCH, SpeciesId.GOOMY, SpeciesId.TURTONATOR],
   // Gym Leaders- Paldea; First slot is Tera
-  KATY: [Species.TEDDIURSA, Species.NYMBLE, Species.TAROUNTULA, Species.RELLOR], // Tera Bug Teddiursa
+  KATY: [SpeciesId.TEDDIURSA, SpeciesId.NYMBLE, SpeciesId.TAROUNTULA, SpeciesId.RELLOR], // Tera Bug Teddiursa
-  BRASSIUS: [Species.BONSLY, Species.SMOLIV, Species.BRAMBLIN, Species.SUNKERN], // Tera Grass Bonsly
+  BRASSIUS: [SpeciesId.BONSLY, SpeciesId.SMOLIV, SpeciesId.BRAMBLIN, SpeciesId.SUNKERN], // Tera Grass Bonsly
-  IONO: [Species.MISDREAVUS, Species.TADBULB, Species.WATTREL, Species.MAGNEMITE], // Tera Ghost Misdreavus
+  IONO: [SpeciesId.MISDREAVUS, SpeciesId.TADBULB, SpeciesId.WATTREL, SpeciesId.MAGNEMITE], // Tera Ghost Misdreavus
-  KOFU: [Species.CRABRAWLER, Species.VELUZA, Species.WIGLETT, Species.WINGULL], // Tera Water Crabrawler
+  KOFU: [SpeciesId.CRABRAWLER, SpeciesId.VELUZA, SpeciesId.WIGLETT, SpeciesId.WINGULL], // Tera Water Crabrawler
-  LARRY: [Species.STARLY, Species.DUNSPARCE, Species.LECHONK, Species.KOMALA], // Tera Normal Starly
+  LARRY: [SpeciesId.STARLY, SpeciesId.DUNSPARCE, SpeciesId.LECHONK, SpeciesId.KOMALA], // Tera Normal Starly
-  RYME: [Species.TOXEL, Species.GREAVARD, Species.SHUPPET, Species.MIMIKYU], // Tera Ghost Toxel
+  RYME: [SpeciesId.TOXEL, SpeciesId.GREAVARD, SpeciesId.SHUPPET, SpeciesId.MIMIKYU], // Tera Ghost Toxel
-  TULIP: [Species.FLABEBE, Species.FLITTLE, Species.RALTS, Species.GIRAFARIG], // Tera Psychic Flabebe
+  TULIP: [SpeciesId.FLABEBE, SpeciesId.FLITTLE, SpeciesId.RALTS, SpeciesId.GIRAFARIG], // Tera Psychic Flabebe
-  GRUSHA: [Species.SWABLU, Species.CETODDLE, Species.SNOM, Species.CUBCHOO], // Tera Ice Swablu
+  GRUSHA: [SpeciesId.SWABLU, SpeciesId.CETODDLE, SpeciesId.SNOM, SpeciesId.CUBCHOO], // Tera Ice Swablu
 }, {
   get(target, prop: string) {
     return target[prop as keyof SignatureSpecies] ?? [];

src/data/balance/special-species-groups.ts

@@ -1,29 +1,29 @@
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 
 /**
  * A list of all {@link https://bulbapedia.bulbagarden.net/wiki/Paradox_Pok%C3%A9mon | Paradox Pokemon}, NOT including the legendaries Miraidon and Koraidon.
  */
 export const NON_LEGEND_PARADOX_POKEMON = [
-  Species.GREAT_TUSK,
+  SpeciesId.GREAT_TUSK,
-  Species.SCREAM_TAIL,
+  SpeciesId.SCREAM_TAIL,
-  Species.BRUTE_BONNET,
+  SpeciesId.BRUTE_BONNET,
-  Species.FLUTTER_MANE,
+  SpeciesId.FLUTTER_MANE,
-  Species.SLITHER_WING,
+  SpeciesId.SLITHER_WING,
-  Species.SANDY_SHOCKS,
+  SpeciesId.SANDY_SHOCKS,
-  Species.ROARING_MOON,
+  SpeciesId.ROARING_MOON,
-  Species.WALKING_WAKE,
+  SpeciesId.WALKING_WAKE,
-  Species.GOUGING_FIRE,
+  SpeciesId.GOUGING_FIRE,
-  Species.RAGING_BOLT,
+  SpeciesId.RAGING_BOLT,
-  Species.IRON_TREADS,
+  SpeciesId.IRON_TREADS,
-  Species.IRON_BUNDLE,
+  SpeciesId.IRON_BUNDLE,
-  Species.IRON_HANDS,
+  SpeciesId.IRON_HANDS,
-  Species.IRON_JUGULIS,
+  SpeciesId.IRON_JUGULIS,
-  Species.IRON_MOTH,
+  SpeciesId.IRON_MOTH,
-  Species.IRON_THORNS,
+  SpeciesId.IRON_THORNS,
-  Species.IRON_VALIANT,
+  SpeciesId.IRON_VALIANT,
-  Species.IRON_LEAVES,
+  SpeciesId.IRON_LEAVES,
-  Species.IRON_BOULDER,
+  SpeciesId.IRON_BOULDER,
-  Species.IRON_CROWN,
+  SpeciesId.IRON_CROWN,
 ];
 
 /**
@@ -32,15 +32,15 @@ export const NON_LEGEND_PARADOX_POKEMON = [
  * Note that all of these Ultra Beasts are still considered Sub-Legendary.
  */
 export const NON_LEGEND_ULTRA_BEASTS = [
-  Species.NIHILEGO,
+  SpeciesId.NIHILEGO,
-  Species.BUZZWOLE,
+  SpeciesId.BUZZWOLE,
-  Species.PHEROMOSA,
+  SpeciesId.PHEROMOSA,
-  Species.XURKITREE,
+  SpeciesId.XURKITREE,
-  Species.CELESTEELA,
+  SpeciesId.CELESTEELA,
-  Species.KARTANA,
+  SpeciesId.KARTANA,
-  Species.GUZZLORD,
+  SpeciesId.GUZZLORD,
-  Species.POIPOLE,
+  SpeciesId.POIPOLE,
-  Species.NAGANADEL,
+  SpeciesId.NAGANADEL,
-  Species.STAKATAKA,
+  SpeciesId.STAKATAKA,
-  Species.BLACEPHALON,
+  SpeciesId.BLACEPHALON,
 ];

src/data/battle-anims.ts

@@ -5,7 +5,7 @@ import { MoveFlags } from "#enums/MoveFlags";
 import type Pokemon from "../field/pokemon";
 import { type nil, getFrameMs, getEnumKeys, getEnumValues, animationFileName } from "../utils/common";
 import type { BattlerIndex } from "../battle";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { SubstituteTag } from "./battler-tags";
 import { isNullOrUndefined } from "../utils/common";
 import Phaser from "phaser";
@@ -498,7 +498,7 @@ class AnimTimedAddBgEvent extends AnimTimedBgEvent {
   }
 }
 
-export const moveAnims = new Map<Moves, AnimConfig | [AnimConfig, AnimConfig] | null>();
+export const moveAnims = new Map<MoveId, AnimConfig | [AnimConfig, AnimConfig] | null>();
 export const chargeAnims = new Map<ChargeAnim, AnimConfig | [AnimConfig, AnimConfig] | null>();
 export const commonAnims = new Map<CommonAnim, AnimConfig>();
 export const encounterAnims = new Map<EncounterAnim, AnimConfig>();
@@ -521,7 +521,7 @@ export function initCommonAnims(): Promise<void> {
   });
 }
 
-export function initMoveAnim(move: Moves): Promise<void> {
+export function initMoveAnim(move: MoveId): Promise<void> {
   return new Promise(resolve => {
     if (moveAnims.has(move)) {
       if (moveAnims.get(move) !== null) {
@@ -544,12 +544,12 @@ export function initMoveAnim(move: Moves): Promise<void> {
       moveAnims.set(move, null);
       const defaultMoveAnim =
         allMoves[move] instanceof AttackMove
-          ? Moves.TACKLE
+          ? MoveId.TACKLE
           : allMoves[move] instanceof SelfStatusMove
-            ? Moves.FOCUS_ENERGY
+            ? MoveId.FOCUS_ENERGY
-            : Moves.TAIL_WHIP;
+            : MoveId.TAIL_WHIP;
 
-      const fetchAnimAndResolve = (move: Moves) => {
+      const fetchAnimAndResolve = (move: MoveId) => {
         globalScene
           .cachedFetch(`./battle-anims/${animationFileName(move)}.json`)
           .then(response => {
@@ -594,7 +594,7 @@ export function initMoveAnim(move: Moves): Promise<void> {
  * @param move the move to populate an animation for
  * @param defaultMoveAnim the move to use as the default animation
  */
-function useDefaultAnim(move: Moves, defaultMoveAnim: Moves) {
+function useDefaultAnim(move: MoveId, defaultMoveAnim: MoveId) {
   populateMoveAnim(move, moveAnims.get(defaultMoveAnim));
 }
 
@@ -606,7 +606,7 @@ function useDefaultAnim(move: Moves, defaultMoveAnim: Moves) {
  *
  * @remarks use {@linkcode useDefaultAnim} to use a default animation
  */
-function logMissingMoveAnim(move: Moves, ...optionalParams: any[]) {
+function logMissingMoveAnim(move: MoveId, ...optionalParams: any[]) {
   const moveName = animationFileName(move);
   console.warn(`Could not load animation file for move '${moveName}'`, ...optionalParams);
 }
@@ -664,7 +664,7 @@ export function initMoveChargeAnim(chargeAnim: ChargeAnim): Promise<void> {
   });
 }
 
-function populateMoveAnim(move: Moves, animSource: any): void {
+function populateMoveAnim(move: MoveId, animSource: any): void {
   const moveAnim = new AnimConfig(animSource);
   if (moveAnims.get(move) === null) {
     moveAnims.set(move, moveAnim);
@@ -697,7 +697,7 @@ export async function loadEncounterAnimAssets(startLoad?: boolean): Promise<void
   await loadAnimAssets(Array.from(encounterAnims.values()), startLoad);
 }
 
-export function loadMoveAnimAssets(moveIds: Moves[], startLoad?: boolean): Promise<void> {
+export function loadMoveAnimAssets(moveIds: MoveId[], startLoad?: boolean): Promise<void> {
   return new Promise(resolve => {
     const moveAnimations = moveIds.flatMap(m => moveAnims.get(m) as AnimConfig);
     for (const moveId of moveIds) {
@@ -1425,9 +1425,9 @@ export class CommonBattleAnim extends BattleAnim {
 }
 
 export class MoveAnim extends BattleAnim {
-  public move: Moves;
+  public move: MoveId;
 
-  constructor(move: Moves, user: Pokemon, target: BattlerIndex, playOnEmptyField = false) {
+  constructor(move: MoveId, user: Pokemon, target: BattlerIndex, playOnEmptyField = false) {
     // Set target to the user pokemon if no target is found to avoid crashes
     super(user, globalScene.getField()[target] ?? user, playOnEmptyField);
 
@@ -1456,7 +1456,7 @@ export class MoveAnim extends BattleAnim {
 export class MoveChargeAnim extends MoveAnim {
   private chargeAnim: ChargeAnim;
 
-  constructor(chargeAnim: ChargeAnim, move: Moves, user: Pokemon) {
+  constructor(chargeAnim: ChargeAnim, move: MoveId, user: Pokemon) {
     super(move, user, 0);
 
     this.chargeAnim = chargeAnim;
@@ -1502,8 +1502,8 @@ export async function populateAnims() {
   const chargeAnimIds = getEnumValues(ChargeAnim) as ChargeAnim[];
   const commonNamePattern = /name: (?:Common:)?(Opp )?(.*)/;
   const moveNameToId = {};
-  for (const move of getEnumValues(Moves).slice(1)) {
+  for (const move of getEnumValues(MoveId).slice(1)) {
-    const moveName = Moves[move].toUpperCase().replace(/\_/g, "");
+    const moveName = MoveId[move].toUpperCase().replace(/\_/g, "");
     moveNameToId[moveName] = move;
   }
 

src/data/challenge.ts

@@ -15,10 +15,10 @@ import { BattleType } from "#enums/battle-type";
 import Trainer, { TrainerVariant } from "#app/field/trainer";
 import { PokemonType } from "#enums/pokemon-type";
 import { Challenges } from "#enums/challenges";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { TrainerType } from "#enums/trainer-type";
 import { Nature } from "#enums/nature";
-import type { Moves } from "#enums/moves";
+import type { MoveId } from "#enums/move-id";
 import { TypeColor, TypeShadow } from "#enums/color";
 import { ModifierTier } from "#app/modifier/modifier-tier";
 import { globalScene } from "#app/global-scene";
@@ -305,11 +305,11 @@ export abstract class Challenge {
 
   /**
    * An apply function for STARTER_COST challenges. Derived classes should alter this.
-   * @param _species {@link Species} The pokemon to change the cost of.
+   * @param _species {@link SpeciesId} The pokemon to change the cost of.
    * @param _cost {@link NumberHolder} The cost of the starter.
    * @returns {@link boolean} Whether this function did anything.
    */
-  applyStarterCost(_species: Species, _cost: NumberHolder): boolean {
+  applyStarterCost(_species: SpeciesId, _cost: NumberHolder): boolean {
     return false;
   }
 
@@ -395,11 +395,11 @@ export abstract class Challenge {
    * An apply function for MOVE_ACCESS. Derived classes should alter this.
    * @param _pokemon {@link Pokemon} What pokemon would learn the move.
    * @param _moveSource {@link MoveSourceType} What source the pokemon would get the move from.
-   * @param _move {@link Moves} The move in question.
+   * @param _move {@link MoveId} The move in question.
    * @param _level {@link NumberHolder} The level threshold for access.
    * @returns {@link boolean} Whether this function did anything.
    */
-  applyMoveAccessLevel(_pokemon: Pokemon, _moveSource: MoveSourceType, _move: Moves, _level: NumberHolder): boolean {
+  applyMoveAccessLevel(_pokemon: Pokemon, _moveSource: MoveSourceType, _move: MoveId, _level: NumberHolder): boolean {
     return false;
   }
 
@@ -407,11 +407,11 @@ export abstract class Challenge {
    * An apply function for MOVE_WEIGHT. Derived classes should alter this.
    * @param _pokemon {@link Pokemon} What pokemon would learn the move.
    * @param _moveSource {@link MoveSourceType} What source the pokemon would get the move from.
-   * @param _move {@link Moves} The move in question.
+   * @param _move {@link MoveId} The move in question.
    * @param _weight {@link NumberHolder} The base weight of the move
    * @returns {@link boolean} Whether this function did anything.
    */
-  applyMoveWeight(_pokemon: Pokemon, _moveSource: MoveSourceType, _move: Moves, _level: NumberHolder): boolean {
+  applyMoveWeight(_pokemon: Pokemon, _moveSource: MoveSourceType, _move: MoveId, _level: NumberHolder): boolean {
     return false;
   }
 
@@ -696,7 +696,7 @@ export class SingleGenerationChallenge extends Challenge {
 
 interface monotypeOverride {
   /** The species to override */
-  species: Species;
+  species: SpeciesId;
   /** The type to count as */
   type: PokemonType;
   /** If part of a fusion, should we check the fused species instead of the base species? */
@@ -708,7 +708,7 @@ interface monotypeOverride {
  */
 export class SingleTypeChallenge extends Challenge {
   private static TYPE_OVERRIDES: monotypeOverride[] = [
-    { species: Species.CASTFORM, type: PokemonType.NORMAL, fusion: false },
+    { species: SpeciesId.CASTFORM, type: PokemonType.NORMAL, fusion: false },
   ];
   // TODO: Find a solution for all Pokemon with this ssui issue, including Basculin and Burmy
 
@@ -804,7 +804,7 @@ export class FreshStartChallenge extends Challenge {
     return false;
   }
 
-  applyStarterCost(species: Species, cost: NumberHolder): boolean {
+  applyStarterCost(species: SpeciesId, cost: NumberHolder): boolean {
     if (defaultStarterSpecies.includes(species)) {
       cost.value = speciesStarterCosts[species];
       return true;
@@ -992,13 +992,13 @@ export function applyChallenges(challengeType: ChallengeType.STARTER_POINTS, poi
 /**
  * Apply all challenges that modify the cost of a starter.
  * @param challengeType {@link ChallengeType} ChallengeType.STARTER_COST
- * @param species {@link Species} The pokemon to change the cost of.
+ * @param species {@link SpeciesId} The pokemon to change the cost of.
  * @param points {@link NumberHolder} The cost of the pokemon.
  * @returns True if any challenge was successfully applied.
  */
 export function applyChallenges(
   challengeType: ChallengeType.STARTER_COST,
-  species: Species,
+  species: SpeciesId,
   cost: NumberHolder,
 ): boolean;
 /**
@@ -1090,7 +1090,7 @@ export function applyChallenges(challengeType: ChallengeType.GAME_MODE_MODIFY):
  * @param challengeType {@link ChallengeType} ChallengeType.MOVE_ACCESS
  * @param pokemon {@link Pokemon} What pokemon would learn the move.
  * @param moveSource {@link MoveSourceType} What source the pokemon would get the move from.
- * @param move {@link Moves} The move in question.
+ * @param move {@link MoveId} The move in question.
  * @param level {@link NumberHolder} The level threshold for access.
  * @returns True if any challenge was successfully applied.
  */
@@ -1098,7 +1098,7 @@ export function applyChallenges(
   challengeType: ChallengeType.MOVE_ACCESS,
   pokemon: Pokemon,
   moveSource: MoveSourceType,
-  move: Moves,
+  move: MoveId,
   level: NumberHolder,
 ): boolean;
 /**
@@ -1106,7 +1106,7 @@ export function applyChallenges(
  * @param challengeType {@link ChallengeType} ChallengeType.MOVE_WEIGHT
  * @param pokemon {@link Pokemon} What pokemon would learn the move.
  * @param moveSource {@link MoveSourceType} What source the pokemon would get the move from.
- * @param move {@link Moves} The move in question.
+ * @param move {@link MoveId} The move in question.
  * @param weight {@link NumberHolder} The weight of the move.
  * @returns True if any challenge was successfully applied.
  */
@@ -1114,7 +1114,7 @@ export function applyChallenges(
   challengeType: ChallengeType.MOVE_WEIGHT,
   pokemon: Pokemon,
   moveSource: MoveSourceType,
-  move: Moves,
+  move: MoveId,
   weight: NumberHolder,
 ): boolean;
 

src/data/custom-pokemon-data.ts

@@ -1,4 +1,4 @@
-import type { Abilities } from "#enums/abilities";
+import type { AbilityId } from "#enums/ability-id";
 import type { PokemonType } from "#enums/pokemon-type";
 import type { Nature } from "#enums/nature";
 
@@ -12,8 +12,8 @@ export class CustomPokemonData {
    * The scale at which to render this Pokemon's sprite.
    */
   public spriteScale = -1;
-  public ability: Abilities | -1;
+  public ability: AbilityId | -1;
-  public passive: Abilities | -1;
+  public passive: AbilityId | -1;
   public nature: Nature | -1;
   public types: PokemonType[];
   /** Deprecated but needed for session save migration */

src/data/daily-run.ts

@@ -1,5 +1,5 @@
 import { PartyMemberStrength } from "#enums/party-member-strength";
-import type { Species } from "#enums/species";
+import type { SpeciesId } from "#enums/species-id";
 import { globalScene } from "#app/global-scene";
 import { PlayerPokemon } from "#app/field/pokemon";
 import type { Starter } from "#app/ui/starter-select-ui-handler";
@@ -8,7 +8,7 @@ import type { PokemonSpeciesForm } from "#app/data/pokemon-species";
 import PokemonSpecies, { getPokemonSpecies, getPokemonSpeciesForm } from "#app/data/pokemon-species";
 import { speciesStarterCosts } from "#app/data/balance/starters";
 import { pokerogueApi } from "#app/plugins/api/pokerogue-api";
-import { Biome } from "#app/enums/biome";
+import { BiomeId } from "#enums/biome-id";
 
 export interface DailyRunConfig {
   seed: number;
@@ -34,7 +34,7 @@ export function getDailyRunStarters(seed: string): Starter[] {
         for (let s = 0; s < 3; s++) {
           const offset = 6 + s * 6;
           const starterSpeciesForm = getPokemonSpeciesForm(
-            Number.parseInt(seed.slice(offset, offset + 4)) as Species,
+            Number.parseInt(seed.slice(offset, offset + 4)) as SpeciesId,
             Number.parseInt(seed.slice(offset + 4, offset + 6)),
           );
           starters.push(getDailyRunStarter(starterSpeciesForm, startingLevel));
@@ -50,7 +50,7 @@ export function getDailyRunStarters(seed: string): Starter[] {
       for (let c = 0; c < starterCosts.length; c++) {
         const cost = starterCosts[c];
         const costSpecies = Object.keys(speciesStarterCosts)
-          .map(s => Number.parseInt(s) as Species)
+          .map(s => Number.parseInt(s) as SpeciesId)
           .filter(s => speciesStarterCosts[s] === cost);
         const randPkmSpecies = getPokemonSpecies(randSeedItem(costSpecies));
         const starterSpecies = getPokemonSpecies(
@@ -102,48 +102,48 @@ interface BiomeWeights {
 // Town and End are set to 0 however
 // And some other biomes were balanced +1/-1 based on average size of the total daily.
 const dailyBiomeWeights: BiomeWeights = {
-  [Biome.CAVE]: 3,
+  [BiomeId.CAVE]: 3,
-  [Biome.LAKE]: 3,
+  [BiomeId.LAKE]: 3,
-  [Biome.PLAINS]: 3,
+  [BiomeId.PLAINS]: 3,
-  [Biome.SNOWY_FOREST]: 3,
+  [BiomeId.SNOWY_FOREST]: 3,
-  [Biome.SWAMP]: 3, // 2 -> 3
+  [BiomeId.SWAMP]: 3, // 2 -> 3
-  [Biome.TALL_GRASS]: 3, // 2 -> 3
+  [BiomeId.TALL_GRASS]: 3, // 2 -> 3
 
-  [Biome.ABYSS]: 2, // 3 -> 2
+  [BiomeId.ABYSS]: 2, // 3 -> 2
-  [Biome.RUINS]: 2,
+  [BiomeId.RUINS]: 2,
-  [Biome.BADLANDS]: 2,
+  [BiomeId.BADLANDS]: 2,
-  [Biome.BEACH]: 2,
+  [BiomeId.BEACH]: 2,
-  [Biome.CONSTRUCTION_SITE]: 2,
+  [BiomeId.CONSTRUCTION_SITE]: 2,
-  [Biome.DESERT]: 2,
+  [BiomeId.DESERT]: 2,
-  [Biome.DOJO]: 2, // 3 -> 2
+  [BiomeId.DOJO]: 2, // 3 -> 2
-  [Biome.FACTORY]: 2,
+  [BiomeId.FACTORY]: 2,
-  [Biome.FAIRY_CAVE]: 2,
+  [BiomeId.FAIRY_CAVE]: 2,
-  [Biome.FOREST]: 2,
+  [BiomeId.FOREST]: 2,
-  [Biome.GRASS]: 2, // 1 -> 2
+  [BiomeId.GRASS]: 2, // 1 -> 2
-  [Biome.MEADOW]: 2,
+  [BiomeId.MEADOW]: 2,
-  [Biome.MOUNTAIN]: 2, // 3 -> 2
+  [BiomeId.MOUNTAIN]: 2, // 3 -> 2
-  [Biome.SEA]: 2,
+  [BiomeId.SEA]: 2,
-  [Biome.SEABED]: 2,
+  [BiomeId.SEABED]: 2,
-  [Biome.SLUM]: 2,
+  [BiomeId.SLUM]: 2,
-  [Biome.TEMPLE]: 2, // 3 -> 2
+  [BiomeId.TEMPLE]: 2, // 3 -> 2
-  [Biome.VOLCANO]: 2,
+  [BiomeId.VOLCANO]: 2,
 
-  [Biome.GRAVEYARD]: 1,
+  [BiomeId.GRAVEYARD]: 1,
-  [Biome.ICE_CAVE]: 1,
+  [BiomeId.ICE_CAVE]: 1,
-  [Biome.ISLAND]: 1,
+  [BiomeId.ISLAND]: 1,
-  [Biome.JUNGLE]: 1,
+  [BiomeId.JUNGLE]: 1,
-  [Biome.LABORATORY]: 1,
+  [BiomeId.LABORATORY]: 1,
-  [Biome.METROPOLIS]: 1,
+  [BiomeId.METROPOLIS]: 1,
-  [Biome.POWER_PLANT]: 1,
+  [BiomeId.POWER_PLANT]: 1,
-  [Biome.SPACE]: 1,
+  [BiomeId.SPACE]: 1,
-  [Biome.WASTELAND]: 1,
+  [BiomeId.WASTELAND]: 1,
 
-  [Biome.TOWN]: 0,
+  [BiomeId.TOWN]: 0,
-  [Biome.END]: 0,
+  [BiomeId.END]: 0,
 };
 
-export function getDailyStartingBiome(): Biome {
+export function getDailyStartingBiome(): BiomeId {
-  const biomes = getEnumValues(Biome).filter(b => b !== Biome.TOWN && b !== Biome.END);
+  const biomes = getEnumValues(BiomeId).filter(b => b !== BiomeId.TOWN && b !== BiomeId.END);
 
   let totalWeight = 0;
   const biomeThresholds: number[] = [];

src/data/egg.ts

@@ -10,7 +10,7 @@ import { pokemonPrevolutions } from "#app/data/balance/pokemon-evolutions";
 import type { PlayerPokemon } from "#app/field/pokemon";
 import i18next from "i18next";
 import { EggTier } from "#enums/egg-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { EggSourceType } from "#enums/egg-source-types";
 import {
   MANAPHY_EGG_MANAPHY_RATE,
@@ -67,7 +67,7 @@ export interface IEggOptions {
   /** Sets how many waves it will take till this egg hatches. */
   hatchWaves?: number;
   /** Sets the exact species that will hatch from this egg. */
-  species?: Species;
+  species?: SpeciesId;
   /** Defines if the hatched pokemon will be a shiny. */
   isShiny?: boolean;
   /** Defines the variant of the pokemon that will hatch from this egg. If no `variantTier` is given the normal variant rates will apply. */
@@ -94,7 +94,7 @@ export class Egg {
   private _hatchWaves: number;
   private _timestamp: number;
 
-  private _species: Species;
+  private _species: SpeciesId;
   private _isShiny: boolean;
   private _variantTier: VariantTier;
   private _eggMoveIndex: number;
@@ -134,7 +134,7 @@ export class Egg {
     return this._timestamp;
   }
 
-  get species(): Species {
+  get species(): SpeciesId {
     return this._species;
   }
 
@@ -221,8 +221,8 @@ export class Egg {
 
   public isManaphyEgg(): boolean {
     return (
-      this._species === Species.PHIONE ||
+      this._species === SpeciesId.PHIONE ||
-      this._species === Species.MANAPHY ||
+      this._species === SpeciesId.MANAPHY ||
       (this._tier === EggTier.COMMON && !(this._id % 204) && !this._species)
     );
   }
@@ -247,8 +247,10 @@ export class Egg {
 
       let pokemonSpecies = getPokemonSpecies(this._species);
       // Special condition to have Phione eggs also have a chance of generating Manaphy
-      if (this._species === Species.PHIONE && this._sourceType === EggSourceType.SAME_SPECIES_EGG) {
+      if (this._species === SpeciesId.PHIONE && this._sourceType === EggSourceType.SAME_SPECIES_EGG) {
-        pokemonSpecies = getPokemonSpecies(randSeedInt(MANAPHY_EGG_MANAPHY_RATE) ? Species.PHIONE : Species.MANAPHY);
+        pokemonSpecies = getPokemonSpecies(
+          randSeedInt(MANAPHY_EGG_MANAPHY_RATE) ? SpeciesId.PHIONE : SpeciesId.MANAPHY,
+        );
       }
 
       // Sets the hidden ability if a hidden ability exists and
@@ -371,7 +373,7 @@ export class Egg {
   }
 
   private getEggTierDefaultHatchWaves(eggTier?: EggTier): number {
-    if (this._species === Species.PHIONE || this._species === Species.MANAPHY) {
+    if (this._species === SpeciesId.PHIONE || this._species === SpeciesId.MANAPHY) {
       return HATCH_WAVES_MANAPHY_EGG;
     }
 
@@ -399,7 +401,7 @@ export class Egg {
           : EggTier.LEGENDARY;
   }
 
-  private rollSpecies(): Species | null {
+  private rollSpecies(): SpeciesId | null {
     if (!globalScene) {
       return null;
     }
@@ -415,7 +417,7 @@ export class Egg {
        * check pass when Utils.randSeedInt(8) = 0, we can tell them apart during tests.
        */
       const rand = randSeedInt(MANAPHY_EGG_MANAPHY_RATE) !== 1;
-      return rand ? Species.PHIONE : Species.MANAPHY;
+      return rand ? SpeciesId.PHIONE : SpeciesId.MANAPHY;
     }
     if (this.tier === EggTier.LEGENDARY && this._sourceType === EggSourceType.GACHA_LEGENDARY) {
       if (!randSeedInt(2)) {
@@ -445,11 +447,11 @@ export class Egg {
         break;
     }
 
-    const ignoredSpecies = [Species.PHIONE, Species.MANAPHY, Species.ETERNATUS];
+    const ignoredSpecies = [SpeciesId.PHIONE, SpeciesId.MANAPHY, SpeciesId.ETERNATUS];
 
     let speciesPool = Object.keys(speciesEggTiers)
       .filter(s => speciesEggTiers[s] === this.tier)
-      .map(s => Number.parseInt(s) as Species)
+      .map(s => Number.parseInt(s) as SpeciesId)
       .filter(
         s =>
           !pokemonPrevolutions.hasOwnProperty(s) &&
@@ -496,7 +498,7 @@ export class Egg {
       totalWeight += weight;
     }
 
-    let species: Species;
+    let species: SpeciesId;
 
     const rand = randSeedInt(totalWeight);
     for (let s = 0; s < speciesWeights.length; s++) {
@@ -606,17 +608,17 @@ export class Egg {
   ////
 }
 
-export function getValidLegendaryGachaSpecies(): Species[] {
+export function getValidLegendaryGachaSpecies(): SpeciesId[] {
   return Object.entries(speciesEggTiers)
     .filter(s => s[1] === EggTier.LEGENDARY)
     .map(s => Number.parseInt(s[0]))
-    .filter(s => getPokemonSpecies(s).isObtainable() && s !== Species.ETERNATUS);
+    .filter(s => getPokemonSpecies(s).isObtainable() && s !== SpeciesId.ETERNATUS);
 }
 
-export function getLegendaryGachaSpeciesForTimestamp(timestamp: number): Species {
+export function getLegendaryGachaSpeciesForTimestamp(timestamp: number): SpeciesId {
   const legendarySpecies = getValidLegendaryGachaSpecies();
 
-  let ret: Species;
+  let ret: SpeciesId;
 
   // 86400000 is the number of miliseconds in one day
   const timeDate = new Date(timestamp);

src/data/moves/invalid-moves.ts

@@ -1,257 +1,257 @@
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 
-/** Set of moves that cannot be called by {@linkcode Moves.METRONOME Metronome} */
+/** Set of moves that cannot be called by {@linkcode MoveId.METRONOME Metronome} */
-export const invalidMetronomeMoves: ReadonlySet<Moves> = new Set([
+export const invalidMetronomeMoves: ReadonlySet<MoveId> = new Set([
-  Moves.AFTER_YOU,
+  MoveId.AFTER_YOU,
-  Moves.ASSIST,
+  MoveId.ASSIST,
-  Moves.BANEFUL_BUNKER,
+  MoveId.BANEFUL_BUNKER,
-  Moves.BEAK_BLAST,
+  MoveId.BEAK_BLAST,
-  Moves.BELCH,
+  MoveId.BELCH,
-  Moves.BESTOW,
+  MoveId.BESTOW,
-  Moves.COMEUPPANCE,
+  MoveId.COMEUPPANCE,
-  Moves.COPYCAT,
+  MoveId.COPYCAT,
-  Moves.COUNTER,
+  MoveId.COUNTER,
-  Moves.CRAFTY_SHIELD,
+  MoveId.CRAFTY_SHIELD,
-  Moves.DESTINY_BOND,
+  MoveId.DESTINY_BOND,
-  Moves.DETECT,
+  MoveId.DETECT,
-  Moves.ENDURE,
+  MoveId.ENDURE,
-  Moves.FEINT,
+  MoveId.FEINT,
-  Moves.FOCUS_PUNCH,
+  MoveId.FOCUS_PUNCH,
-  Moves.FOLLOW_ME,
+  MoveId.FOLLOW_ME,
-  Moves.HELPING_HAND,
+  MoveId.HELPING_HAND,
-  Moves.INSTRUCT,
+  MoveId.INSTRUCT,
-  Moves.KINGS_SHIELD,
+  MoveId.KINGS_SHIELD,
-  Moves.MAT_BLOCK,
+  MoveId.MAT_BLOCK,
-  Moves.ME_FIRST,
+  MoveId.ME_FIRST,
-  Moves.METRONOME,
+  MoveId.METRONOME,
-  Moves.MIMIC,
+  MoveId.MIMIC,
-  Moves.MIRROR_COAT,
+  MoveId.MIRROR_COAT,
-  Moves.MIRROR_MOVE,
+  MoveId.MIRROR_MOVE,
-  Moves.OBSTRUCT,
+  MoveId.OBSTRUCT,
-  Moves.PROTECT,
+  MoveId.PROTECT,
-  Moves.QUASH,
+  MoveId.QUASH,
-  Moves.QUICK_GUARD,
+  MoveId.QUICK_GUARD,
-  Moves.RAGE_POWDER,
+  MoveId.RAGE_POWDER,
-  Moves.REVIVAL_BLESSING,
+  MoveId.REVIVAL_BLESSING,
-  Moves.SHELL_TRAP,
+  MoveId.SHELL_TRAP,
-  Moves.SILK_TRAP,
+  MoveId.SILK_TRAP,
-  Moves.SKETCH,
+  MoveId.SKETCH,
-  Moves.SLEEP_TALK,
+  MoveId.SLEEP_TALK,
-  Moves.SNATCH,
+  MoveId.SNATCH,
-  Moves.SNORE,
+  MoveId.SNORE,
-  Moves.SPIKY_SHIELD,
+  MoveId.SPIKY_SHIELD,
-  Moves.SPOTLIGHT,
+  MoveId.SPOTLIGHT,
-  Moves.STRUGGLE,
+  MoveId.STRUGGLE,
-  Moves.TRANSFORM,
+  MoveId.TRANSFORM,
-  Moves.WIDE_GUARD,
+  MoveId.WIDE_GUARD,
 ]);
 
-/** Set of moves that cannot be called by {@linkcode Moves.ASSIST Assist} */
+/** Set of moves that cannot be called by {@linkcode MoveId.ASSIST Assist} */
-export const invalidAssistMoves: ReadonlySet<Moves> = new Set([
+export const invalidAssistMoves: ReadonlySet<MoveId> = new Set([
-  Moves.ASSIST,
+  MoveId.ASSIST,
-  Moves.BANEFUL_BUNKER,
+  MoveId.BANEFUL_BUNKER,
-  Moves.BEAK_BLAST,
+  MoveId.BEAK_BLAST,
-  Moves.BELCH,
+  MoveId.BELCH,
-  Moves.BESTOW,
+  MoveId.BESTOW,
-  Moves.BOUNCE,
+  MoveId.BOUNCE,
-  Moves.CELEBRATE,
+  MoveId.CELEBRATE,
-  Moves.CHATTER,
+  MoveId.CHATTER,
-  Moves.CIRCLE_THROW,
+  MoveId.CIRCLE_THROW,
-  Moves.COPYCAT,
+  MoveId.COPYCAT,
-  Moves.COUNTER,
+  MoveId.COUNTER,
-  Moves.DESTINY_BOND,
+  MoveId.DESTINY_BOND,
-  Moves.DETECT,
+  MoveId.DETECT,
-  Moves.DIG,
+  MoveId.DIG,
-  Moves.DIVE,
+  MoveId.DIVE,
-  Moves.DRAGON_TAIL,
+  MoveId.DRAGON_TAIL,
-  Moves.ENDURE,
+  MoveId.ENDURE,
-  Moves.FEINT,
+  MoveId.FEINT,
-  Moves.FLY,
+  MoveId.FLY,
-  Moves.FOCUS_PUNCH,
+  MoveId.FOCUS_PUNCH,
-  Moves.FOLLOW_ME,
+  MoveId.FOLLOW_ME,
-  Moves.HELPING_HAND,
+  MoveId.HELPING_HAND,
-  Moves.HOLD_HANDS,
+  MoveId.HOLD_HANDS,
-  Moves.KINGS_SHIELD,
+  MoveId.KINGS_SHIELD,
-  Moves.MAT_BLOCK,
+  MoveId.MAT_BLOCK,
-  Moves.ME_FIRST,
+  MoveId.ME_FIRST,
-  Moves.METRONOME,
+  MoveId.METRONOME,
-  Moves.MIMIC,
+  MoveId.MIMIC,
-  Moves.MIRROR_COAT,
+  MoveId.MIRROR_COAT,
-  Moves.MIRROR_MOVE,
+  MoveId.MIRROR_MOVE,
-  Moves.NATURE_POWER,
+  MoveId.NATURE_POWER,
-  Moves.PHANTOM_FORCE,
+  MoveId.PHANTOM_FORCE,
-  Moves.PROTECT,
+  MoveId.PROTECT,
-  Moves.RAGE_POWDER,
+  MoveId.RAGE_POWDER,
-  Moves.ROAR,
+  MoveId.ROAR,
-  Moves.SHADOW_FORCE,
+  MoveId.SHADOW_FORCE,
-  Moves.SHELL_TRAP,
+  MoveId.SHELL_TRAP,
-  Moves.SKETCH,
+  MoveId.SKETCH,
-  Moves.SKY_DROP,
+  MoveId.SKY_DROP,
-  Moves.SLEEP_TALK,
+  MoveId.SLEEP_TALK,
-  Moves.SNATCH,
+  MoveId.SNATCH,
-  Moves.SPIKY_SHIELD,
+  MoveId.SPIKY_SHIELD,
-  Moves.SPOTLIGHT,
+  MoveId.SPOTLIGHT,
-  Moves.STRUGGLE,
+  MoveId.STRUGGLE,
-  Moves.SWITCHEROO,
+  MoveId.SWITCHEROO,
-  Moves.TRANSFORM,
+  MoveId.TRANSFORM,
-  Moves.TRICK,
+  MoveId.TRICK,
-  Moves.WHIRLWIND,
+  MoveId.WHIRLWIND,
 ]);
 
-/** Set of moves that cannot be called by {@linkcode Moves.SLEEP_TALK Sleep Talk} */
+/** Set of moves that cannot be called by {@linkcode MoveId.SLEEP_TALK Sleep Talk} */
-export const invalidSleepTalkMoves: ReadonlySet<Moves> = new Set([
+export const invalidSleepTalkMoves: ReadonlySet<MoveId> = new Set([
-  Moves.ASSIST,
+  MoveId.ASSIST,
-  Moves.BELCH,
+  MoveId.BELCH,
-  Moves.BEAK_BLAST,
+  MoveId.BEAK_BLAST,
-  Moves.BIDE,
+  MoveId.BIDE,
-  Moves.BOUNCE,
+  MoveId.BOUNCE,
-  Moves.COPYCAT,
+  MoveId.COPYCAT,
-  Moves.DIG,
+  MoveId.DIG,
-  Moves.DIVE,
+  MoveId.DIVE,
-  Moves.FREEZE_SHOCK,
+  MoveId.FREEZE_SHOCK,
-  Moves.FLY,
+  MoveId.FLY,
-  Moves.FOCUS_PUNCH,
+  MoveId.FOCUS_PUNCH,
-  Moves.GEOMANCY,
+  MoveId.GEOMANCY,
-  Moves.ICE_BURN,
+  MoveId.ICE_BURN,
-  Moves.ME_FIRST,
+  MoveId.ME_FIRST,
-  Moves.METRONOME,
+  MoveId.METRONOME,
-  Moves.MIRROR_MOVE,
+  MoveId.MIRROR_MOVE,
-  Moves.MIMIC,
+  MoveId.MIMIC,
-  Moves.PHANTOM_FORCE,
+  MoveId.PHANTOM_FORCE,
-  Moves.RAZOR_WIND,
+  MoveId.RAZOR_WIND,
-  Moves.SHADOW_FORCE,
+  MoveId.SHADOW_FORCE,
-  Moves.SHELL_TRAP,
+  MoveId.SHELL_TRAP,
-  Moves.SKETCH,
+  MoveId.SKETCH,
-  Moves.SKULL_BASH,
+  MoveId.SKULL_BASH,
-  Moves.SKY_ATTACK,
+  MoveId.SKY_ATTACK,
-  Moves.SKY_DROP,
+  MoveId.SKY_DROP,
-  Moves.SLEEP_TALK,
+  MoveId.SLEEP_TALK,
-  Moves.SOLAR_BLADE,
+  MoveId.SOLAR_BLADE,
-  Moves.SOLAR_BEAM,
+  MoveId.SOLAR_BEAM,
-  Moves.STRUGGLE,
+  MoveId.STRUGGLE,
-  Moves.UPROAR,
+  MoveId.UPROAR,
 ]);
 
-/** Set of moves that cannot be copied by {@linkcode Moves.COPYCAT Copycat} */
+/** Set of moves that cannot be copied by {@linkcode MoveId.COPYCAT Copycat} */
-export const invalidCopycatMoves: ReadonlySet<Moves> = new Set([
+export const invalidCopycatMoves: ReadonlySet<MoveId> = new Set([
-  Moves.ASSIST,
+  MoveId.ASSIST,
-  Moves.BANEFUL_BUNKER,
+  MoveId.BANEFUL_BUNKER,
-  Moves.BEAK_BLAST,
+  MoveId.BEAK_BLAST,
-  Moves.BESTOW,
+  MoveId.BESTOW,
-  Moves.CELEBRATE,
+  MoveId.CELEBRATE,
-  Moves.CHATTER,
+  MoveId.CHATTER,
-  Moves.CIRCLE_THROW,
+  MoveId.CIRCLE_THROW,
-  Moves.COPYCAT,
+  MoveId.COPYCAT,
-  Moves.COUNTER,
+  MoveId.COUNTER,
-  Moves.DESTINY_BOND,
+  MoveId.DESTINY_BOND,
-  Moves.DETECT,
+  MoveId.DETECT,
-  Moves.DRAGON_TAIL,
+  MoveId.DRAGON_TAIL,
-  Moves.ENDURE,
+  MoveId.ENDURE,
-  Moves.FEINT,
+  MoveId.FEINT,
-  Moves.FOCUS_PUNCH,
+  MoveId.FOCUS_PUNCH,
-  Moves.FOLLOW_ME,
+  MoveId.FOLLOW_ME,
-  Moves.HELPING_HAND,
+  MoveId.HELPING_HAND,
-  Moves.HOLD_HANDS,
+  MoveId.HOLD_HANDS,
-  Moves.KINGS_SHIELD,
+  MoveId.KINGS_SHIELD,
-  Moves.MAT_BLOCK,
+  MoveId.MAT_BLOCK,
-  Moves.ME_FIRST,
+  MoveId.ME_FIRST,
-  Moves.METRONOME,
+  MoveId.METRONOME,
-  Moves.MIMIC,
+  MoveId.MIMIC,
-  Moves.MIRROR_COAT,
+  MoveId.MIRROR_COAT,
-  Moves.MIRROR_MOVE,
+  MoveId.MIRROR_MOVE,
-  Moves.PROTECT,
+  MoveId.PROTECT,
-  Moves.RAGE_POWDER,
+  MoveId.RAGE_POWDER,
-  Moves.ROAR,
+  MoveId.ROAR,
-  Moves.SHELL_TRAP,
+  MoveId.SHELL_TRAP,
-  Moves.SKETCH,
+  MoveId.SKETCH,
-  Moves.SLEEP_TALK,
+  MoveId.SLEEP_TALK,
-  Moves.SNATCH,
+  MoveId.SNATCH,
-  Moves.SPIKY_SHIELD,
+  MoveId.SPIKY_SHIELD,
-  Moves.SPOTLIGHT,
+  MoveId.SPOTLIGHT,
-  Moves.STRUGGLE,
+  MoveId.STRUGGLE,
-  Moves.SWITCHEROO,
+  MoveId.SWITCHEROO,
-  Moves.TRANSFORM,
+  MoveId.TRANSFORM,
-  Moves.TRICK,
+  MoveId.TRICK,
-  Moves.WHIRLWIND,
+  MoveId.WHIRLWIND,
 ]);
 
-export const invalidMirrorMoveMoves: ReadonlySet<Moves> = new Set([
+export const invalidMirrorMoveMoves: ReadonlySet<MoveId> = new Set([
-  Moves.ACUPRESSURE,
+  MoveId.ACUPRESSURE,
-  Moves.AFTER_YOU,
+  MoveId.AFTER_YOU,
-  Moves.AROMATIC_MIST,
+  MoveId.AROMATIC_MIST,
-  Moves.BEAK_BLAST,
+  MoveId.BEAK_BLAST,
-  Moves.BELCH,
+  MoveId.BELCH,
-  Moves.CHILLY_RECEPTION,
+  MoveId.CHILLY_RECEPTION,
-  Moves.COACHING,
+  MoveId.COACHING,
-  Moves.CONVERSION_2,
+  MoveId.CONVERSION_2,
-  Moves.COUNTER,
+  MoveId.COUNTER,
-  Moves.CRAFTY_SHIELD,
+  MoveId.CRAFTY_SHIELD,
-  Moves.CURSE,
+  MoveId.CURSE,
-  Moves.DECORATE,
+  MoveId.DECORATE,
-  Moves.DOODLE,
+  MoveId.DOODLE,
-  Moves.DOOM_DESIRE,
+  MoveId.DOOM_DESIRE,
-  Moves.DRAGON_CHEER,
+  MoveId.DRAGON_CHEER,
-  Moves.ELECTRIC_TERRAIN,
+  MoveId.ELECTRIC_TERRAIN,
-  Moves.FINAL_GAMBIT,
+  MoveId.FINAL_GAMBIT,
-  Moves.FLORAL_HEALING,
+  MoveId.FLORAL_HEALING,
-  Moves.FLOWER_SHIELD,
+  MoveId.FLOWER_SHIELD,
-  Moves.FOCUS_PUNCH,
+  MoveId.FOCUS_PUNCH,
-  Moves.FUTURE_SIGHT,
+  MoveId.FUTURE_SIGHT,
-  Moves.GEAR_UP,
+  MoveId.GEAR_UP,
-  Moves.GRASSY_TERRAIN,
+  MoveId.GRASSY_TERRAIN,
-  Moves.GRAVITY,
+  MoveId.GRAVITY,
-  Moves.GUARD_SPLIT,
+  MoveId.GUARD_SPLIT,
-  Moves.HAIL,
+  MoveId.HAIL,
-  Moves.HAZE,
+  MoveId.HAZE,
-  Moves.HEAL_PULSE,
+  MoveId.HEAL_PULSE,
-  Moves.HELPING_HAND,
+  MoveId.HELPING_HAND,
-  Moves.HOLD_HANDS,
+  MoveId.HOLD_HANDS,
-  Moves.INSTRUCT,
+  MoveId.INSTRUCT,
-  Moves.ION_DELUGE,
+  MoveId.ION_DELUGE,
-  Moves.MAGNETIC_FLUX,
+  MoveId.MAGNETIC_FLUX,
-  Moves.MAT_BLOCK,
+  MoveId.MAT_BLOCK,
-  Moves.ME_FIRST,
+  MoveId.ME_FIRST,
-  Moves.MIMIC,
+  MoveId.MIMIC,
-  Moves.MIRROR_COAT,
+  MoveId.MIRROR_COAT,
-  Moves.MIRROR_MOVE,
+  MoveId.MIRROR_MOVE,
-  Moves.MIST,
+  MoveId.MIST,
-  Moves.MISTY_TERRAIN,
+  MoveId.MISTY_TERRAIN,
-  Moves.MUD_SPORT,
+  MoveId.MUD_SPORT,
-  Moves.PERISH_SONG,
+  MoveId.PERISH_SONG,
-  Moves.POWER_SPLIT,
+  MoveId.POWER_SPLIT,
-  Moves.PSYCH_UP,
+  MoveId.PSYCH_UP,
-  Moves.PSYCHIC_TERRAIN,
+  MoveId.PSYCHIC_TERRAIN,
-  Moves.PURIFY,
+  MoveId.PURIFY,
-  Moves.QUICK_GUARD,
+  MoveId.QUICK_GUARD,
-  Moves.RAIN_DANCE,
+  MoveId.RAIN_DANCE,
-  Moves.REFLECT_TYPE,
+  MoveId.REFLECT_TYPE,
-  Moves.ROLE_PLAY,
+  MoveId.ROLE_PLAY,
-  Moves.ROTOTILLER,
+  MoveId.ROTOTILLER,
-  Moves.SANDSTORM,
+  MoveId.SANDSTORM,
-  Moves.SHELL_TRAP,
+  MoveId.SHELL_TRAP,
-  Moves.SKETCH,
+  MoveId.SKETCH,
-  Moves.SNOWSCAPE,
+  MoveId.SNOWSCAPE,
-  Moves.SPIT_UP,
+  MoveId.SPIT_UP,
-  Moves.SPOTLIGHT,
+  MoveId.SPOTLIGHT,
-  Moves.STRUGGLE,
+  MoveId.STRUGGLE,
-  Moves.SUNNY_DAY,
+  MoveId.SUNNY_DAY,
-  Moves.TEATIME,
+  MoveId.TEATIME,
-  Moves.TRANSFORM,
+  MoveId.TRANSFORM,
-  Moves.WATER_SPORT,
+  MoveId.WATER_SPORT,
-  Moves.WIDE_GUARD,
+  MoveId.WIDE_GUARD,
 ]);
 
 /** Set of moves that can never have their type overridden by an ability like Pixilate or Normalize
  *
  * Excludes tera blast and tera starstorm, as these are only conditionally forbidden
  */
-export const noAbilityTypeOverrideMoves: ReadonlySet<Moves> = new Set([
+export const noAbilityTypeOverrideMoves: ReadonlySet<MoveId> = new Set([
-  Moves.WEATHER_BALL,
+  MoveId.WEATHER_BALL,
-  Moves.JUDGMENT,
+  MoveId.JUDGMENT,
-  Moves.REVELATION_DANCE,
+  MoveId.REVELATION_DANCE,
-  Moves.MULTI_ATTACK,
+  MoveId.MULTI_ATTACK,
-  Moves.TERRAIN_PULSE,
+  MoveId.TERRAIN_PULSE,
-  Moves.NATURAL_GIFT,
+  MoveId.NATURAL_GIFT,
-  Moves.TECHNO_BLAST,
+  MoveId.TECHNO_BLAST,
-  Moves.HIDDEN_POWER,
+  MoveId.HIDDEN_POWER,
 ]);

src/data/mystery-encounters/encounters/a-trainers-test-encounter.ts

@@ -12,7 +12,7 @@ import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounte
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { TrainerType } from "#enums/trainer-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { getSpriteKeysFromSpecies } from "#app/data/mystery-encounters/utils/encounter-pokemon-utils";
 import { randSeedInt } from "#app/utils/common";
 import i18next from "i18next";
@@ -54,27 +54,27 @@ export const ATrainersTestEncounter: MysteryEncounter = MysteryEncounterBuilder.
     switch (randSeedInt(5)) {
       case 1:
         trainerType = TrainerType.CHERYL;
-        spriteKeys = getSpriteKeysFromSpecies(Species.BLISSEY);
+        spriteKeys = getSpriteKeysFromSpecies(SpeciesId.BLISSEY);
         trainerNameKey = "cheryl";
         break;
       case 2:
         trainerType = TrainerType.MARLEY;
-        spriteKeys = getSpriteKeysFromSpecies(Species.ARCANINE);
+        spriteKeys = getSpriteKeysFromSpecies(SpeciesId.ARCANINE);
         trainerNameKey = "marley";
         break;
       case 3:
         trainerType = TrainerType.MIRA;
-        spriteKeys = getSpriteKeysFromSpecies(Species.ALAKAZAM, false, 1);
+        spriteKeys = getSpriteKeysFromSpecies(SpeciesId.ALAKAZAM, false, 1);
         trainerNameKey = "mira";
         break;
       case 4:
         trainerType = TrainerType.RILEY;
-        spriteKeys = getSpriteKeysFromSpecies(Species.LUCARIO, false, 1);
+        spriteKeys = getSpriteKeysFromSpecies(SpeciesId.LUCARIO, false, 1);
         trainerNameKey = "riley";
         break;
       default:
         trainerType = TrainerType.BUCK;
-        spriteKeys = getSpriteKeysFromSpecies(Species.CLAYDOL);
+        spriteKeys = getSpriteKeysFromSpecies(SpeciesId.CLAYDOL);
         trainerNameKey = "buck";
         break;
     }

src/data/mystery-encounters/encounters/absolute-avarice-encounter.ts

@@ -11,7 +11,7 @@ import { EnemyPokemon, PokemonMove } from "#app/field/pokemon";
 import type { BerryModifierType, PokemonHeldItemModifierType } from "#app/modifier/modifier-type";
 import { modifierTypes } from "#app/modifier/modifier-type";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { globalScene } from "#app/global-scene";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
@@ -22,7 +22,7 @@ import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
 import { BerryModifier, PokemonInstantReviveModifier } from "#app/modifier/modifier";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { BattlerTagType } from "#enums/battler-tag-type";
 import { randInt } from "#app/utils/common";
 import { BattlerIndex } from "#app/battle";
@@ -59,7 +59,7 @@ export const AbsoluteAvariceEncounter: MysteryEncounter = MysteryEncounterBuilde
       // This sprite has the shadow
       spriteKey: "",
       fileRoot: "",
-      species: Species.GREEDENT,
+      species: SpeciesId.GREEDENT,
       hasShadow: true,
       alpha: 0.001,
       repeat: true,
@@ -68,7 +68,7 @@ export const AbsoluteAvariceEncounter: MysteryEncounter = MysteryEncounterBuilde
     {
       spriteKey: "",
       fileRoot: "",
-      species: Species.GREEDENT,
+      species: SpeciesId.GREEDENT,
       hasShadow: false,
       repeat: true,
       x: -5,
@@ -228,11 +228,11 @@ export const AbsoluteAvariceEncounter: MysteryEncounter = MysteryEncounterBuilde
       levelAdditiveModifier: 1,
       pokemonConfigs: [
         {
-          species: getPokemonSpecies(Species.GREEDENT),
+          species: getPokemonSpecies(SpeciesId.GREEDENT),
           isBoss: true,
           bossSegments: 3,
           shiny: false, // Shiny lock because of consistency issues between the different options
-          moveSet: [Moves.THRASH, Moves.CRUNCH, Moves.BODY_PRESS, Moves.SLACK_OFF],
+          moveSet: [MoveId.THRASH, MoveId.CRUNCH, MoveId.BODY_PRESS, MoveId.SLACK_OFF],
           modifierConfigs: bossModifierConfigs,
           tags: [BattlerTagType.MYSTERY_ENCOUNTER_POST_SUMMON],
           mysteryEncounterBattleEffects: (pokemon: Pokemon) => {
@@ -246,7 +246,7 @@ export const AbsoluteAvariceEncounter: MysteryEncounter = MysteryEncounterBuilde
     };
 
     encounter.enemyPartyConfigs = [config];
-    encounter.setDialogueToken("greedentName", getPokemonSpecies(Species.GREEDENT).getName());
+    encounter.setDialogueToken("greedentName", getPokemonSpecies(SpeciesId.GREEDENT).getName());
 
     return true;
   })
@@ -302,7 +302,7 @@ export const AbsoluteAvariceEncounter: MysteryEncounter = MysteryEncounterBuilde
         encounter.startOfBattleEffects.push({
           sourceBattlerIndex: BattlerIndex.ENEMY,
           targets: [BattlerIndex.ENEMY],
-          move: new PokemonMove(Moves.STUFF_CHEEKS),
+          move: new PokemonMove(MoveId.STUFF_CHEEKS),
           ignorePp: true,
         });
 
@@ -373,12 +373,12 @@ export const AbsoluteAvariceEncounter: MysteryEncounter = MysteryEncounterBuilde
         // Let it have the food
         // Greedent joins the team, level equal to 2 below highest party member (shiny locked)
         const level = getHighestLevelPlayerPokemon(false, true).level - 2;
-        const greedent = new EnemyPokemon(getPokemonSpecies(Species.GREEDENT), level, TrainerSlot.NONE, false, true);
+        const greedent = new EnemyPokemon(getPokemonSpecies(SpeciesId.GREEDENT), level, TrainerSlot.NONE, false, true);
         greedent.moveset = [
-          new PokemonMove(Moves.THRASH),
+          new PokemonMove(MoveId.THRASH),
-          new PokemonMove(Moves.BODY_PRESS),
+          new PokemonMove(MoveId.BODY_PRESS),
-          new PokemonMove(Moves.STUFF_CHEEKS),
+          new PokemonMove(MoveId.STUFF_CHEEKS),
-          new PokemonMove(Moves.SLACK_OFF),
+          new PokemonMove(MoveId.SLACK_OFF),
         ];
         greedent.passive = true;
 

src/data/mystery-encounters/encounters/an-offer-you-cant-refuse-encounter.ts

@@ -6,7 +6,7 @@ import {
 } from "#app/data/mystery-encounters/utils/encounter-phase-utils";
 import { modifierTypes } from "#app/modifier/modifier-type";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { globalScene } from "#app/global-scene";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
@@ -50,7 +50,7 @@ export const AnOfferYouCantRefuseEncounter: MysteryEncounter = MysteryEncounterB
   .withScenePartySizeRequirement(2, 6, true) // Must have at least 2 pokemon in party
   .withIntroSpriteConfigs([
     {
-      spriteKey: Species.LIEPARD.toString(),
+      spriteKey: SpeciesId.LIEPARD.toString(),
       fileRoot: "pokemon",
       hasShadow: true,
       repeat: true,
@@ -112,7 +112,7 @@ export const AnOfferYouCantRefuseEncounter: MysteryEncounter = MysteryEncounterB
 
     const shinyCharm = generateModifierType(modifierTypes.SHINY_CHARM);
     encounter.setDialogueToken("itemName", shinyCharm?.name ?? i18next.t("modifierType:ModifierType.SHINY_CHARM.name"));
-    encounter.setDialogueToken("liepardName", getPokemonSpecies(Species.LIEPARD).getName());
+    encounter.setDialogueToken("liepardName", getPokemonSpecies(SpeciesId.LIEPARD).getName());
 
     return true;
   })
@@ -167,7 +167,7 @@ export const AnOfferYouCantRefuseEncounter: MysteryEncounter = MysteryEncounterB
         // Update money and remove pokemon from party
         updatePlayerMoney(encounter.misc.price);
 
-        setEncounterExp(encounter.options[1].primaryPokemon!.id, getPokemonSpecies(Species.LIEPARD).baseExp, true);
+        setEncounterExp(encounter.options[1].primaryPokemon!.id, getPokemonSpecies(SpeciesId.LIEPARD).baseExp, true);
 
         leaveEncounterWithoutBattle(true);
       })

src/data/mystery-encounters/encounters/bug-type-superfan-encounter.ts

@@ -21,13 +21,13 @@ import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounte
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { TrainerType } from "#enums/trainer-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import type { PlayerPokemon } from "#app/field/pokemon";
 import type Pokemon from "#app/field/pokemon";
 import { PokemonMove } from "#app/field/pokemon";
 import { getEncounterText, showEncounterDialogue } from "#app/data/mystery-encounters/utils/encounter-dialogue-utils";
 import { LearnMovePhase } from "#app/phases/learn-move-phase";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import type { OptionSelectItem } from "#app/ui/abstact-option-select-ui-handler";
 import { MysteryEncounterOptionBuilder } from "#app/data/mystery-encounters/mystery-encounter-option";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
@@ -59,110 +59,116 @@ import { getSpriteKeysFromSpecies } from "#app/data/mystery-encounters/utils/enc
 const namespace = "mysteryEncounters/bugTypeSuperfan";
 
 const POOL_1_POKEMON = [
-  Species.PARASECT,
+  SpeciesId.PARASECT,
-  Species.VENOMOTH,
+  SpeciesId.VENOMOTH,
-  Species.LEDIAN,
+  SpeciesId.LEDIAN,
-  Species.ARIADOS,
+  SpeciesId.ARIADOS,
-  Species.YANMA,
+  SpeciesId.YANMA,
-  Species.BEAUTIFLY,
+  SpeciesId.BEAUTIFLY,
-  Species.DUSTOX,
+  SpeciesId.DUSTOX,
-  Species.MASQUERAIN,
+  SpeciesId.MASQUERAIN,
-  Species.NINJASK,
+  SpeciesId.NINJASK,
-  Species.VOLBEAT,
+  SpeciesId.VOLBEAT,
-  Species.ILLUMISE,
+  SpeciesId.ILLUMISE,
-  Species.ANORITH,
+  SpeciesId.ANORITH,
-  Species.KRICKETUNE,
+  SpeciesId.KRICKETUNE,
-  Species.WORMADAM,
+  SpeciesId.WORMADAM,
-  Species.MOTHIM,
+  SpeciesId.MOTHIM,
-  Species.SKORUPI,
+  SpeciesId.SKORUPI,
-  Species.JOLTIK,
+  SpeciesId.JOLTIK,
-  Species.LARVESTA,
+  SpeciesId.LARVESTA,
-  Species.VIVILLON,
+  SpeciesId.VIVILLON,
-  Species.CHARJABUG,
+  SpeciesId.CHARJABUG,
-  Species.RIBOMBEE,
+  SpeciesId.RIBOMBEE,
-  Species.SPIDOPS,
+  SpeciesId.SPIDOPS,
-  Species.LOKIX,
+  SpeciesId.LOKIX,
 ];
 
 const POOL_2_POKEMON = [
-  Species.SCYTHER,
+  SpeciesId.SCYTHER,
-  Species.PINSIR,
+  SpeciesId.PINSIR,
-  Species.HERACROSS,
+  SpeciesId.HERACROSS,
-  Species.FORRETRESS,
+  SpeciesId.FORRETRESS,
-  Species.SCIZOR,
+  SpeciesId.SCIZOR,
-  Species.SHUCKLE,
+  SpeciesId.SHUCKLE,
-  Species.SHEDINJA,
+  SpeciesId.SHEDINJA,
-  Species.ARMALDO,
+  SpeciesId.ARMALDO,
-  Species.VESPIQUEN,
+  SpeciesId.VESPIQUEN,
-  Species.DRAPION,
+  SpeciesId.DRAPION,
-  Species.YANMEGA,
+  SpeciesId.YANMEGA,
-  Species.LEAVANNY,
+  SpeciesId.LEAVANNY,
-  Species.SCOLIPEDE,
+  SpeciesId.SCOLIPEDE,
-  Species.CRUSTLE,
+  SpeciesId.CRUSTLE,
-  Species.ESCAVALIER,
+  SpeciesId.ESCAVALIER,
-  Species.ACCELGOR,
+  SpeciesId.ACCELGOR,
-  Species.GALVANTULA,
+  SpeciesId.GALVANTULA,
-  Species.VIKAVOLT,
+  SpeciesId.VIKAVOLT,
-  Species.ARAQUANID,
+  SpeciesId.ARAQUANID,
-  Species.ORBEETLE,
+  SpeciesId.ORBEETLE,
-  Species.CENTISKORCH,
+  SpeciesId.CENTISKORCH,
-  Species.FROSMOTH,
+  SpeciesId.FROSMOTH,
-  Species.KLEAVOR,
+  SpeciesId.KLEAVOR,
 ];
 
-const POOL_3_POKEMON: { species: Species; formIndex?: number }[] = [
+const POOL_3_POKEMON: { species: SpeciesId; formIndex?: number }[] = [
   {
-    species: Species.PINSIR,
+    species: SpeciesId.PINSIR,
     formIndex: 1,
   },
   {
-    species: Species.SCIZOR,
+    species: SpeciesId.SCIZOR,
     formIndex: 1,
   },
   {
-    species: Species.HERACROSS,
+    species: SpeciesId.HERACROSS,
     formIndex: 1,
   },
   {
-    species: Species.ORBEETLE,
+    species: SpeciesId.ORBEETLE,
     formIndex: 1,
   },
   {
-    species: Species.CENTISKORCH,
+    species: SpeciesId.CENTISKORCH,
     formIndex: 1,
   },
   {
-    species: Species.DURANT,
+    species: SpeciesId.DURANT,
   },
   {
-    species: Species.VOLCARONA,
+    species: SpeciesId.VOLCARONA,
   },
   {
-    species: Species.GOLISOPOD,
+    species: SpeciesId.GOLISOPOD,
   },
 ];
 
-const POOL_4_POKEMON = [Species.GENESECT, Species.SLITHER_WING, Species.BUZZWOLE, Species.PHEROMOSA];
+const POOL_4_POKEMON = [SpeciesId.GENESECT, SpeciesId.SLITHER_WING, SpeciesId.BUZZWOLE, SpeciesId.PHEROMOSA];
 
-const PHYSICAL_TUTOR_MOVES = [Moves.MEGAHORN, Moves.ATTACK_ORDER, Moves.BUG_BITE, Moves.FIRST_IMPRESSION, Moves.LUNGE];
+const PHYSICAL_TUTOR_MOVES = [
+  MoveId.MEGAHORN,
+  MoveId.ATTACK_ORDER,
+  MoveId.BUG_BITE,
+  MoveId.FIRST_IMPRESSION,
+  MoveId.LUNGE,
+];
 
 const SPECIAL_TUTOR_MOVES = [
-  Moves.SILVER_WIND,
+  MoveId.SILVER_WIND,
-  Moves.SIGNAL_BEAM,
+  MoveId.SIGNAL_BEAM,
-  Moves.BUG_BUZZ,
+  MoveId.BUG_BUZZ,
-  Moves.POLLEN_PUFF,
+  MoveId.POLLEN_PUFF,
-  Moves.STRUGGLE_BUG,
+  MoveId.STRUGGLE_BUG,
 ];
 
 const STATUS_TUTOR_MOVES = [
-  Moves.STRING_SHOT,
+  MoveId.STRING_SHOT,
-  Moves.DEFEND_ORDER,
+  MoveId.DEFEND_ORDER,
-  Moves.RAGE_POWDER,
+  MoveId.RAGE_POWDER,
-  Moves.STICKY_WEB,
+  MoveId.STICKY_WEB,
-  Moves.SILK_TRAP,
+  MoveId.SILK_TRAP,
 ];
 
-const MISC_TUTOR_MOVES = [Moves.LEECH_LIFE, Moves.U_TURN, Moves.HEAL_ORDER, Moves.QUIVER_DANCE, Moves.INFESTATION];
+const MISC_TUTOR_MOVES = [MoveId.LEECH_LIFE, MoveId.U_TURN, MoveId.HEAL_ORDER, MoveId.QUIVER_DANCE, MoveId.INFESTATION];
 
 /**
  * Wave breakpoints that determine how strong to make the Bug-Type Superfan's team
@@ -213,12 +219,12 @@ export const BugTypeSuperfanEncounter: MysteryEncounter = MysteryEncounterBuilde
 
     let beedrillKeys: { spriteKey: string; fileRoot: string }, butterfreeKeys: { spriteKey: string; fileRoot: string };
     if (globalScene.currentBattle.waveIndex < WAVE_LEVEL_BREAKPOINTS[3]) {
-      beedrillKeys = getSpriteKeysFromSpecies(Species.BEEDRILL, false);
+      beedrillKeys = getSpriteKeysFromSpecies(SpeciesId.BEEDRILL, false);
-      butterfreeKeys = getSpriteKeysFromSpecies(Species.BUTTERFREE, false);
+      butterfreeKeys = getSpriteKeysFromSpecies(SpeciesId.BUTTERFREE, false);
     } else {
       // Mega Beedrill/Gmax Butterfree
-      beedrillKeys = getSpriteKeysFromSpecies(Species.BEEDRILL, false, 1);
+      beedrillKeys = getSpriteKeysFromSpecies(SpeciesId.BEEDRILL, false, 1);
-      butterfreeKeys = getSpriteKeysFromSpecies(Species.BUTTERFREE, false, 1);
+      butterfreeKeys = getSpriteKeysFromSpecies(SpeciesId.BUTTERFREE, false, 1);
     }
 
     encounter.spriteConfigs = [
@@ -519,26 +525,26 @@ function getTrainerConfigForWave(waveIndex: number) {
   if (waveIndex < WAVE_LEVEL_BREAKPOINTS[0]) {
     // Use default template (2 AVG)
     config
-      .setPartyMemberFunc(0, getRandomPartyMemberFunc([Species.BEEDRILL], TrainerSlot.TRAINER, true))
+      .setPartyMemberFunc(0, getRandomPartyMemberFunc([SpeciesId.BEEDRILL], TrainerSlot.TRAINER, true))
-      .setPartyMemberFunc(1, getRandomPartyMemberFunc([Species.BUTTERFREE], TrainerSlot.TRAINER, true));
+      .setPartyMemberFunc(1, getRandomPartyMemberFunc([SpeciesId.BUTTERFREE], TrainerSlot.TRAINER, true));
   } else if (waveIndex < WAVE_LEVEL_BREAKPOINTS[1]) {
     config
       .setPartyTemplates(new TrainerPartyTemplate(3, PartyMemberStrength.AVERAGE))
-      .setPartyMemberFunc(0, getRandomPartyMemberFunc([Species.BEEDRILL], TrainerSlot.TRAINER, true))
+      .setPartyMemberFunc(0, getRandomPartyMemberFunc([SpeciesId.BEEDRILL], TrainerSlot.TRAINER, true))
-      .setPartyMemberFunc(1, getRandomPartyMemberFunc([Species.BUTTERFREE], TrainerSlot.TRAINER, true))
+      .setPartyMemberFunc(1, getRandomPartyMemberFunc([SpeciesId.BUTTERFREE], TrainerSlot.TRAINER, true))
       .setPartyMemberFunc(2, getRandomPartyMemberFunc(POOL_1_POKEMON, TrainerSlot.TRAINER, true));
   } else if (waveIndex < WAVE_LEVEL_BREAKPOINTS[2]) {
     config
       .setPartyTemplates(new TrainerPartyTemplate(4, PartyMemberStrength.AVERAGE))
-      .setPartyMemberFunc(0, getRandomPartyMemberFunc([Species.BEEDRILL], TrainerSlot.TRAINER, true))
+      .setPartyMemberFunc(0, getRandomPartyMemberFunc([SpeciesId.BEEDRILL], TrainerSlot.TRAINER, true))
-      .setPartyMemberFunc(1, getRandomPartyMemberFunc([Species.BUTTERFREE], TrainerSlot.TRAINER, true))
+      .setPartyMemberFunc(1, getRandomPartyMemberFunc([SpeciesId.BUTTERFREE], TrainerSlot.TRAINER, true))
       .setPartyMemberFunc(2, getRandomPartyMemberFunc(POOL_1_POKEMON, TrainerSlot.TRAINER, true))
       .setPartyMemberFunc(3, getRandomPartyMemberFunc(POOL_2_POKEMON, TrainerSlot.TRAINER, true));
   } else if (waveIndex < WAVE_LEVEL_BREAKPOINTS[3]) {
     config
       .setPartyTemplates(new TrainerPartyTemplate(5, PartyMemberStrength.AVERAGE))
-      .setPartyMemberFunc(0, getRandomPartyMemberFunc([Species.BEEDRILL], TrainerSlot.TRAINER, true))
+      .setPartyMemberFunc(0, getRandomPartyMemberFunc([SpeciesId.BEEDRILL], TrainerSlot.TRAINER, true))
-      .setPartyMemberFunc(1, getRandomPartyMemberFunc([Species.BUTTERFREE], TrainerSlot.TRAINER, true))
+      .setPartyMemberFunc(1, getRandomPartyMemberFunc([SpeciesId.BUTTERFREE], TrainerSlot.TRAINER, true))
       .setPartyMemberFunc(2, getRandomPartyMemberFunc(POOL_1_POKEMON, TrainerSlot.TRAINER, true))
       .setPartyMemberFunc(3, getRandomPartyMemberFunc(POOL_2_POKEMON, TrainerSlot.TRAINER, true))
       .setPartyMemberFunc(4, getRandomPartyMemberFunc(POOL_2_POKEMON, TrainerSlot.TRAINER, true));
@@ -547,7 +553,7 @@ function getTrainerConfigForWave(waveIndex: number) {
       .setPartyTemplates(new TrainerPartyTemplate(5, PartyMemberStrength.AVERAGE))
       .setPartyMemberFunc(
         0,
-        getRandomPartyMemberFunc([Species.BEEDRILL], TrainerSlot.TRAINER, true, p => {
+        getRandomPartyMemberFunc([SpeciesId.BEEDRILL], TrainerSlot.TRAINER, true, p => {
           p.formIndex = 1;
           p.generateAndPopulateMoveset();
           p.generateName();
@@ -555,7 +561,7 @@ function getTrainerConfigForWave(waveIndex: number) {
       )
       .setPartyMemberFunc(
         1,
-        getRandomPartyMemberFunc([Species.BUTTERFREE], TrainerSlot.TRAINER, true, p => {
+        getRandomPartyMemberFunc([SpeciesId.BUTTERFREE], TrainerSlot.TRAINER, true, p => {
           p.formIndex = 1;
           p.generateAndPopulateMoveset();
           p.generateName();
@@ -580,7 +586,7 @@ function getTrainerConfigForWave(waveIndex: number) {
       .setPartyTemplates(new TrainerPartyTemplate(5, PartyMemberStrength.AVERAGE))
       .setPartyMemberFunc(
         0,
-        getRandomPartyMemberFunc([Species.BEEDRILL], TrainerSlot.TRAINER, true, p => {
+        getRandomPartyMemberFunc([SpeciesId.BEEDRILL], TrainerSlot.TRAINER, true, p => {
           p.formIndex = 1;
           p.generateAndPopulateMoveset();
           p.generateName();
@@ -588,7 +594,7 @@ function getTrainerConfigForWave(waveIndex: number) {
       )
       .setPartyMemberFunc(
         1,
-        getRandomPartyMemberFunc([Species.BUTTERFREE], TrainerSlot.TRAINER, true, p => {
+        getRandomPartyMemberFunc([SpeciesId.BUTTERFREE], TrainerSlot.TRAINER, true, p => {
           p.formIndex = 1;
           p.generateAndPopulateMoveset();
           p.generateName();
@@ -625,7 +631,7 @@ function getTrainerConfigForWave(waveIndex: number) {
       )
       .setPartyMemberFunc(
         0,
-        getRandomPartyMemberFunc([Species.BEEDRILL], TrainerSlot.TRAINER, true, p => {
+        getRandomPartyMemberFunc([SpeciesId.BEEDRILL], TrainerSlot.TRAINER, true, p => {
           p.formIndex = 1;
           p.generateAndPopulateMoveset();
           p.generateName();
@@ -633,7 +639,7 @@ function getTrainerConfigForWave(waveIndex: number) {
       )
       .setPartyMemberFunc(
         1,
-        getRandomPartyMemberFunc([Species.BUTTERFREE], TrainerSlot.TRAINER, true, p => {
+        getRandomPartyMemberFunc([SpeciesId.BUTTERFREE], TrainerSlot.TRAINER, true, p => {
           p.formIndex = 1;
           p.generateAndPopulateMoveset();
           p.generateName();
@@ -663,7 +669,7 @@ function getTrainerConfigForWave(waveIndex: number) {
       )
       .setPartyMemberFunc(
         0,
-        getRandomPartyMemberFunc([Species.BEEDRILL], TrainerSlot.TRAINER, true, p => {
+        getRandomPartyMemberFunc([SpeciesId.BEEDRILL], TrainerSlot.TRAINER, true, p => {
           p.setBoss(true, 2);
           p.formIndex = 1;
           p.generateAndPopulateMoveset();
@@ -672,7 +678,7 @@ function getTrainerConfigForWave(waveIndex: number) {
       )
       .setPartyMemberFunc(
         1,
-        getRandomPartyMemberFunc([Species.BUTTERFREE], TrainerSlot.TRAINER, true, p => {
+        getRandomPartyMemberFunc([SpeciesId.BUTTERFREE], TrainerSlot.TRAINER, true, p => {
           p.setBoss(true, 2);
           p.formIndex = 1;
           p.generateAndPopulateMoveset();

src/data/mystery-encounters/encounters/clowning-around-encounter.ts

@@ -20,10 +20,10 @@ import { globalScene } from "#app/global-scene";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { TrainerType } from "#enums/trainer-type";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 import {
   applyAbilityOverrideToPokemon,
   applyModifierTypeToPlayerPokemon,
@@ -42,7 +42,7 @@ import { Ability } from "#app/data/abilities/ability-class";
 import { BerryModifier } from "#app/modifier/modifier";
 import { BerryType } from "#enums/berry-type";
 import { BattlerIndex } from "#app/battle";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { EncounterBattleAnim } from "#app/data/battle-anims";
 import { MoveCategory } from "#enums/MoveCategory";
 import { CustomPokemonData } from "#app/data/custom-pokemon-data";
@@ -54,21 +54,21 @@ import { Challenges } from "#enums/challenges";
 const namespace = "mysteryEncounters/clowningAround";
 
 const RANDOM_ABILITY_POOL = [
-  Abilities.STURDY,
+  AbilityId.STURDY,
-  Abilities.PICKUP,
+  AbilityId.PICKUP,
-  Abilities.INTIMIDATE,
+  AbilityId.INTIMIDATE,
-  Abilities.GUTS,
+  AbilityId.GUTS,
-  Abilities.DROUGHT,
+  AbilityId.DROUGHT,
-  Abilities.DRIZZLE,
+  AbilityId.DRIZZLE,
-  Abilities.SNOW_WARNING,
+  AbilityId.SNOW_WARNING,
-  Abilities.SAND_STREAM,
+  AbilityId.SAND_STREAM,
-  Abilities.ELECTRIC_SURGE,
+  AbilityId.ELECTRIC_SURGE,
-  Abilities.PSYCHIC_SURGE,
+  AbilityId.PSYCHIC_SURGE,
-  Abilities.GRASSY_SURGE,
+  AbilityId.GRASSY_SURGE,
-  Abilities.MISTY_SURGE,
+  AbilityId.MISTY_SURGE,
-  Abilities.MAGICIAN,
+  AbilityId.MAGICIAN,
-  Abilities.SHEER_FORCE,
+  AbilityId.SHEER_FORCE,
-  Abilities.PRANKSTER,
+  AbilityId.PRANKSTER,
 ];
 
 /**
@@ -86,7 +86,7 @@ export const ClowningAroundEncounter: MysteryEncounter = MysteryEncounterBuilder
   .withAutoHideIntroVisuals(false)
   .withIntroSpriteConfigs([
     {
-      spriteKey: Species.MR_MIME.toString(),
+      spriteKey: SpeciesId.MR_MIME.toString(),
       fileRoot: "pokemon",
       hasShadow: true,
       repeat: true,
@@ -96,7 +96,7 @@ export const ClowningAroundEncounter: MysteryEncounter = MysteryEncounterBuilder
       yShadow: -3,
     },
     {
-      spriteKey: Species.BLACEPHALON.toString(),
+      spriteKey: SpeciesId.BLACEPHALON.toString(),
       fileRoot: "pokemon/exp",
       hasShadow: true,
       repeat: true,
@@ -154,28 +154,28 @@ export const ClowningAroundEncounter: MysteryEncounter = MysteryEncounterBuilder
       pokemonConfigs: [
         // Overrides first 2 pokemon to be Mr. Mime and Blacephalon
         {
-          species: getPokemonSpecies(Species.MR_MIME),
+          species: getPokemonSpecies(SpeciesId.MR_MIME),
           isBoss: true,
-          moveSet: [Moves.TEETER_DANCE, Moves.ALLY_SWITCH, Moves.DAZZLING_GLEAM, Moves.PSYCHIC],
+          moveSet: [MoveId.TEETER_DANCE, MoveId.ALLY_SWITCH, MoveId.DAZZLING_GLEAM, MoveId.PSYCHIC],
         },
         {
           // Blacephalon has the random ability from pool, and 2 entirely random types to fit with the theme of the encounter
-          species: getPokemonSpecies(Species.BLACEPHALON),
+          species: getPokemonSpecies(SpeciesId.BLACEPHALON),
           customPokemonData: new CustomPokemonData({
             ability: ability,
             types: [firstType, secondType],
           }),
           isBoss: true,
-          moveSet: [Moves.TRICK, Moves.HYPNOSIS, Moves.SHADOW_BALL, Moves.MIND_BLOWN],
+          moveSet: [MoveId.TRICK, MoveId.HYPNOSIS, MoveId.SHADOW_BALL, MoveId.MIND_BLOWN],
         },
       ],
       doubleBattle: true,
     });
 
     // Load animations/sfx for start of fight moves
-    loadCustomMovesForEncounter([Moves.ROLE_PLAY, Moves.TAUNT]);
+    loadCustomMovesForEncounter([MoveId.ROLE_PLAY, MoveId.TAUNT]);
 
-    encounter.setDialogueToken("blacephalonName", getPokemonSpecies(Species.BLACEPHALON).getName());
+    encounter.setDialogueToken("blacephalonName", getPokemonSpecies(SpeciesId.BLACEPHALON).getName());
 
     return true;
   })
@@ -208,19 +208,19 @@ export const ClowningAroundEncounter: MysteryEncounter = MysteryEncounterBuilder
             // Mr. Mime copies the Blacephalon's random ability
             sourceBattlerIndex: BattlerIndex.ENEMY,
             targets: [BattlerIndex.ENEMY_2],
-            move: new PokemonMove(Moves.ROLE_PLAY),
+            move: new PokemonMove(MoveId.ROLE_PLAY),
             ignorePp: true,
           },
           {
             sourceBattlerIndex: BattlerIndex.ENEMY_2,
             targets: [BattlerIndex.PLAYER],
-            move: new PokemonMove(Moves.TAUNT),
+            move: new PokemonMove(MoveId.TAUNT),
             ignorePp: true,
           },
           {
             sourceBattlerIndex: BattlerIndex.ENEMY_2,
             targets: [BattlerIndex.PLAYER_2],
-            move: new PokemonMove(Moves.TAUNT),
+            move: new PokemonMove(MoveId.TAUNT),
             ignorePp: true,
           },
         );

src/data/mystery-encounters/encounters/dancing-lessons-encounter.ts

@@ -31,14 +31,14 @@ import { StatStageChangePhase } from "#app/phases/stat-stage-change-phase";
 import PokemonData from "#app/system/pokemon-data";
 import type { OptionSelectItem } from "#app/ui/abstact-option-select-ui-handler";
 import { BattlerTagType } from "#enums/battler-tag-type";
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
 import { EncounterAnim } from "#enums/encounter-anims";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
 import { PokeballType } from "#enums/pokeball";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { Stat } from "#enums/stat";
 import i18next from "i18next";
 
@@ -47,46 +47,46 @@ const namespace = "mysteryEncounters/dancingLessons";
 
 // Fire form
 const BAILE_STYLE_BIOMES = [
-  Biome.VOLCANO,
+  BiomeId.VOLCANO,
-  Biome.BEACH,
+  BiomeId.BEACH,
-  Biome.ISLAND,
+  BiomeId.ISLAND,
-  Biome.WASTELAND,
+  BiomeId.WASTELAND,
-  Biome.MOUNTAIN,
+  BiomeId.MOUNTAIN,
-  Biome.BADLANDS,
+  BiomeId.BADLANDS,
-  Biome.DESERT,
+  BiomeId.DESERT,
 ];
 
 // Electric form
 const POM_POM_STYLE_BIOMES = [
-  Biome.CONSTRUCTION_SITE,
+  BiomeId.CONSTRUCTION_SITE,
-  Biome.POWER_PLANT,
+  BiomeId.POWER_PLANT,
-  Biome.FACTORY,
+  BiomeId.FACTORY,
-  Biome.LABORATORY,
+  BiomeId.LABORATORY,
-  Biome.SLUM,
+  BiomeId.SLUM,
-  Biome.METROPOLIS,
+  BiomeId.METROPOLIS,
-  Biome.DOJO,
+  BiomeId.DOJO,
 ];
 
 // Psychic form
 const PAU_STYLE_BIOMES = [
-  Biome.JUNGLE,
+  BiomeId.JUNGLE,
-  Biome.FAIRY_CAVE,
+  BiomeId.FAIRY_CAVE,
-  Biome.MEADOW,
+  BiomeId.MEADOW,
-  Biome.PLAINS,
+  BiomeId.PLAINS,
-  Biome.GRASS,
+  BiomeId.GRASS,
-  Biome.TALL_GRASS,
+  BiomeId.TALL_GRASS,
-  Biome.FOREST,
+  BiomeId.FOREST,
 ];
 
 // Ghost form
 const SENSU_STYLE_BIOMES = [
-  Biome.RUINS,
+  BiomeId.RUINS,
-  Biome.SWAMP,
+  BiomeId.SWAMP,
-  Biome.CAVE,
+  BiomeId.CAVE,
-  Biome.ABYSS,
+  BiomeId.ABYSS,
-  Biome.GRAVEYARD,
+  BiomeId.GRAVEYARD,
-  Biome.LAKE,
+  BiomeId.LAKE,
-  Biome.TEMPLE,
+  BiomeId.TEMPLE,
 ];
 
 /**
@@ -127,14 +127,14 @@ export const DancingLessonsEncounter: MysteryEncounter = MysteryEncounterBuilder
   .withOnInit(() => {
     const encounter = globalScene.currentBattle.mysteryEncounter!;
 
-    const species = getPokemonSpecies(Species.ORICORIO);
+    const species = getPokemonSpecies(SpeciesId.ORICORIO);
     const level = getEncounterPokemonLevelForWave(STANDARD_ENCOUNTER_BOOSTED_LEVEL_MODIFIER);
     const enemyPokemon = new EnemyPokemon(species, level, TrainerSlot.NONE, false);
-    if (!enemyPokemon.moveset.some(m => m && m.getMove().id === Moves.REVELATION_DANCE)) {
+    if (!enemyPokemon.moveset.some(m => m && m.getMove().id === MoveId.REVELATION_DANCE)) {
       if (enemyPokemon.moveset.length < 4) {
-        enemyPokemon.moveset.push(new PokemonMove(Moves.REVELATION_DANCE));
+        enemyPokemon.moveset.push(new PokemonMove(MoveId.REVELATION_DANCE));
       } else {
-        enemyPokemon.moveset[0] = new PokemonMove(Moves.REVELATION_DANCE);
+        enemyPokemon.moveset[0] = new PokemonMove(MoveId.REVELATION_DANCE);
       }
     }
 
@@ -193,7 +193,7 @@ export const DancingLessonsEncounter: MysteryEncounter = MysteryEncounterBuilder
       oricorioData,
     };
 
-    encounter.setDialogueToken("oricorioName", getPokemonSpecies(Species.ORICORIO).getName());
+    encounter.setDialogueToken("oricorioName", getPokemonSpecies(SpeciesId.ORICORIO).getName());
 
     return true;
   })
@@ -215,7 +215,7 @@ export const DancingLessonsEncounter: MysteryEncounter = MysteryEncounterBuilder
         encounter.startOfBattleEffects.push({
           sourceBattlerIndex: BattlerIndex.ENEMY,
           targets: [BattlerIndex.PLAYER],
-          move: new PokemonMove(Moves.REVELATION_DANCE),
+          move: new PokemonMove(MoveId.REVELATION_DANCE),
           ignorePp: true,
         });
 
@@ -246,7 +246,7 @@ export const DancingLessonsEncounter: MysteryEncounter = MysteryEncounterBuilder
         const onPokemonSelected = (pokemon: PlayerPokemon) => {
           encounter.setDialogueToken("selectedPokemon", pokemon.getNameToRender());
           globalScene.unshiftPhase(
-            new LearnMovePhase(globalScene.getPlayerParty().indexOf(pokemon), Moves.REVELATION_DANCE),
+            new LearnMovePhase(globalScene.getPlayerParty().indexOf(pokemon), MoveId.REVELATION_DANCE),
           );
 
           // Play animation again to "learn" the dance

src/data/mystery-encounters/encounters/dark-deal-encounter.ts

@@ -1,7 +1,7 @@
 import type { PokemonType } from "#enums/pokemon-type";
 import { isNullOrUndefined, randSeedInt } from "#app/utils/common";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { globalScene } from "#app/global-scene";
 import { modifierTypes } from "#app/modifier/modifier-type";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
@@ -27,68 +27,68 @@ const namespace = "mysteryEncounters/darkDeal";
 
 /** Exclude Ultra Beasts (inludes Cosmog/Solgaleo/Lunala/Necrozma), Paradox (includes Miraidon/Koraidon), Eternatus, and Mythicals */
 const excludedBosses = [
-  Species.NECROZMA,
+  SpeciesId.NECROZMA,
-  Species.COSMOG,
+  SpeciesId.COSMOG,
-  Species.COSMOEM,
+  SpeciesId.COSMOEM,
-  Species.SOLGALEO,
+  SpeciesId.SOLGALEO,
-  Species.LUNALA,
+  SpeciesId.LUNALA,
-  Species.ETERNATUS,
+  SpeciesId.ETERNATUS,
-  Species.NIHILEGO,
+  SpeciesId.NIHILEGO,
-  Species.BUZZWOLE,
+  SpeciesId.BUZZWOLE,
-  Species.PHEROMOSA,
+  SpeciesId.PHEROMOSA,
-  Species.XURKITREE,
+  SpeciesId.XURKITREE,
-  Species.CELESTEELA,
+  SpeciesId.CELESTEELA,
-  Species.KARTANA,
+  SpeciesId.KARTANA,
-  Species.GUZZLORD,
+  SpeciesId.GUZZLORD,
-  Species.POIPOLE,
+  SpeciesId.POIPOLE,
-  Species.NAGANADEL,
+  SpeciesId.NAGANADEL,
-  Species.STAKATAKA,
+  SpeciesId.STAKATAKA,
-  Species.BLACEPHALON,
+  SpeciesId.BLACEPHALON,
-  Species.GREAT_TUSK,
+  SpeciesId.GREAT_TUSK,
-  Species.SCREAM_TAIL,
+  SpeciesId.SCREAM_TAIL,
-  Species.BRUTE_BONNET,
+  SpeciesId.BRUTE_BONNET,
-  Species.FLUTTER_MANE,
+  SpeciesId.FLUTTER_MANE,
-  Species.SLITHER_WING,
+  SpeciesId.SLITHER_WING,
-  Species.SANDY_SHOCKS,
+  SpeciesId.SANDY_SHOCKS,
-  Species.ROARING_MOON,
+  SpeciesId.ROARING_MOON,
-  Species.KORAIDON,
+  SpeciesId.KORAIDON,
-  Species.WALKING_WAKE,
+  SpeciesId.WALKING_WAKE,
-  Species.GOUGING_FIRE,
+  SpeciesId.GOUGING_FIRE,
-  Species.RAGING_BOLT,
+  SpeciesId.RAGING_BOLT,
-  Species.IRON_TREADS,
+  SpeciesId.IRON_TREADS,
-  Species.IRON_BUNDLE,
+  SpeciesId.IRON_BUNDLE,
-  Species.IRON_HANDS,
+  SpeciesId.IRON_HANDS,
-  Species.IRON_JUGULIS,
+  SpeciesId.IRON_JUGULIS,
-  Species.IRON_MOTH,
+  SpeciesId.IRON_MOTH,
-  Species.IRON_THORNS,
+  SpeciesId.IRON_THORNS,
-  Species.IRON_VALIANT,
+  SpeciesId.IRON_VALIANT,
-  Species.MIRAIDON,
+  SpeciesId.MIRAIDON,
-  Species.IRON_LEAVES,
+  SpeciesId.IRON_LEAVES,
-  Species.IRON_BOULDER,
+  SpeciesId.IRON_BOULDER,
-  Species.IRON_CROWN,
+  SpeciesId.IRON_CROWN,
-  Species.MEW,
+  SpeciesId.MEW,
-  Species.CELEBI,
+  SpeciesId.CELEBI,
-  Species.DEOXYS,
+  SpeciesId.DEOXYS,
-  Species.JIRACHI,
+  SpeciesId.JIRACHI,
-  Species.DARKRAI,
+  SpeciesId.DARKRAI,
-  Species.PHIONE,
+  SpeciesId.PHIONE,
-  Species.MANAPHY,
+  SpeciesId.MANAPHY,
-  Species.ARCEUS,
+  SpeciesId.ARCEUS,
-  Species.SHAYMIN,
+  SpeciesId.SHAYMIN,
-  Species.VICTINI,
+  SpeciesId.VICTINI,
-  Species.MELOETTA,
+  SpeciesId.MELOETTA,
-  Species.KELDEO,
+  SpeciesId.KELDEO,
-  Species.GENESECT,
+  SpeciesId.GENESECT,
-  Species.DIANCIE,
+  SpeciesId.DIANCIE,
-  Species.HOOPA,
+  SpeciesId.HOOPA,
-  Species.VOLCANION,
+  SpeciesId.VOLCANION,
-  Species.MAGEARNA,
+  SpeciesId.MAGEARNA,
-  Species.MARSHADOW,
+  SpeciesId.MARSHADOW,
-  Species.ZERAORA,
+  SpeciesId.ZERAORA,
-  Species.ZARUDE,
+  SpeciesId.ZARUDE,
-  Species.MELTAN,
+  SpeciesId.MELTAN,
-  Species.MELMETAL,
+  SpeciesId.MELMETAL,
-  Species.PECHARUNT,
+  SpeciesId.PECHARUNT,
 ];
 
 /**

src/data/mystery-encounters/encounters/delibirdy-encounter.ts

@@ -36,7 +36,7 @@ import { randSeedItem } from "#app/utils/common";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { timedEventManager } from "#app/global-event-manager";
 
 /** the i18n namespace for this encounter */
@@ -95,7 +95,7 @@ export const DelibirdyEncounter: MysteryEncounter = MysteryEncounterBuilder.with
     {
       spriteKey: "",
       fileRoot: "",
-      species: Species.DELIBIRD,
+      species: SpeciesId.DELIBIRD,
       hasShadow: true,
       repeat: true,
       startFrame: 38,
@@ -104,7 +104,7 @@ export const DelibirdyEncounter: MysteryEncounter = MysteryEncounterBuilder.with
     {
       spriteKey: "",
       fileRoot: "",
-      species: Species.DELIBIRD,
+      species: SpeciesId.DELIBIRD,
       hasShadow: true,
       repeat: true,
       scale: 1.06,
@@ -112,7 +112,7 @@ export const DelibirdyEncounter: MysteryEncounter = MysteryEncounterBuilder.with
     {
       spriteKey: "",
       fileRoot: "",
-      species: Species.DELIBIRD,
+      species: SpeciesId.DELIBIRD,
       hasShadow: true,
       repeat: true,
       startFrame: 65,
@@ -137,7 +137,7 @@ export const DelibirdyEncounter: MysteryEncounter = MysteryEncounterBuilder.with
   ])
   .withOnInit(() => {
     const encounter = globalScene.currentBattle.mysteryEncounter!;
-    encounter.setDialogueToken("delibirdName", getPokemonSpecies(Species.DELIBIRD).getName());
+    encounter.setDialogueToken("delibirdName", getPokemonSpecies(SpeciesId.DELIBIRD).getName());
 
     globalScene.loadBgm("mystery_encounter_delibirdy", "mystery_encounter_delibirdy.mp3");
     return true;

src/data/mystery-encounters/encounters/department-store-sale-encounter.ts

@@ -6,7 +6,7 @@ import type { ModifierTypeFunc } from "#app/modifier/modifier-type";
 import { modifierTypes } from "#app/modifier/modifier-type";
 import { randSeedInt } from "#app/utils/common";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
@@ -35,7 +35,7 @@ export const DepartmentStoreSaleEncounter: MysteryEncounter = MysteryEncounterBu
     {
       spriteKey: "",
       fileRoot: "",
-      species: Species.FURFROU,
+      species: SpeciesId.FURFROU,
       hasShadow: true,
       repeat: true,
       x: 30,

src/data/mystery-encounters/encounters/fiery-fallout-encounter.ts

@@ -20,14 +20,14 @@ import {
   CombinationPokemonRequirement,
   TypeRequirement,
 } from "#app/data/mystery-encounters/mystery-encounter-requirements";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
 import { Gender } from "#app/data/gender";
 import { PokemonType } from "#enums/pokemon-type";
 import { BattlerIndex } from "#app/battle";
 import type Pokemon from "#app/field/pokemon";
 import { PokemonMove } from "#app/field/pokemon";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { EncounterBattleAnim } from "#app/data/battle-anims";
 import { WeatherType } from "#enums/weather-type";
 import { isNullOrUndefined, randSeedInt } from "#app/utils/common";
@@ -42,7 +42,7 @@ import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
 import { EncounterAnim } from "#enums/encounter-anims";
 import { CLASSIC_MODE_MYSTERY_ENCOUNTER_WAVES } from "#app/constants";
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 import { BattlerTagType } from "#enums/battler-tag-type";
 import { StatStageChangePhase } from "#app/phases/stat-stage-change-phase";
 import { Stat } from "#enums/stat";
@@ -83,7 +83,7 @@ export const FieryFalloutEncounter: MysteryEncounter = MysteryEncounterBuilder.w
     const encounter = globalScene.currentBattle.mysteryEncounter!;
 
     // Calculate boss mons
-    const volcaronaSpecies = getPokemonSpecies(Species.VOLCARONA);
+    const volcaronaSpecies = getPokemonSpecies(SpeciesId.VOLCARONA);
     const config: EnemyPartyConfig = {
       pokemonConfigs: [
         {
@@ -119,7 +119,7 @@ export const FieryFalloutEncounter: MysteryEncounter = MysteryEncounterBuilder.w
       {
         spriteKey: "",
         fileRoot: "",
-        species: Species.VOLCARONA,
+        species: SpeciesId.VOLCARONA,
         repeat: true,
         hidden: true,
         hasShadow: true,
@@ -129,7 +129,7 @@ export const FieryFalloutEncounter: MysteryEncounter = MysteryEncounterBuilder.w
       {
         spriteKey: "",
         fileRoot: "",
-        species: Species.VOLCARONA,
+        species: SpeciesId.VOLCARONA,
         repeat: true,
         hidden: true,
         hasShadow: true,
@@ -138,12 +138,12 @@ export const FieryFalloutEncounter: MysteryEncounter = MysteryEncounterBuilder.w
     ];
 
     // Load animations/sfx for Volcarona moves
-    loadCustomMovesForEncounter([Moves.FIRE_SPIN, Moves.QUIVER_DANCE]);
+    loadCustomMovesForEncounter([MoveId.FIRE_SPIN, MoveId.QUIVER_DANCE]);
 
     const pokemon = globalScene.getEnemyPokemon();
     globalScene.arena.trySetWeather(WeatherType.SUNNY, pokemon);
 
-    encounter.setDialogueToken("volcaronaName", getPokemonSpecies(Species.VOLCARONA).getName());
+    encounter.setDialogueToken("volcaronaName", getPokemonSpecies(SpeciesId.VOLCARONA).getName());
 
     return true;
   })
@@ -193,13 +193,13 @@ export const FieryFalloutEncounter: MysteryEncounter = MysteryEncounterBuilder.w
         {
           sourceBattlerIndex: BattlerIndex.ENEMY,
           targets: [BattlerIndex.PLAYER],
-          move: new PokemonMove(Moves.FIRE_SPIN),
+          move: new PokemonMove(MoveId.FIRE_SPIN),
           ignorePp: true,
         },
         {
           sourceBattlerIndex: BattlerIndex.ENEMY_2,
           targets: [BattlerIndex.PLAYER_2],
-          move: new PokemonMove(Moves.FIRE_SPIN),
+          move: new PokemonMove(MoveId.FIRE_SPIN),
           ignorePp: true,
         },
       );
@@ -239,11 +239,11 @@ export const FieryFalloutEncounter: MysteryEncounter = MysteryEncounterBuilder.w
         if (chosenPokemon.trySetStatus(StatusEffect.BURN)) {
           // Burn applied
           encounter.setDialogueToken("burnedPokemon", chosenPokemon.getNameToRender());
-          encounter.setDialogueToken("abilityName", new Ability(Abilities.HEATPROOF, 3).name);
+          encounter.setDialogueToken("abilityName", new Ability(AbilityId.HEATPROOF, 3).name);
           queueEncounterMessage(`${namespace}:option.2.target_burned`);
 
           // Also permanently change the burned Pokemon's ability to Heatproof
-          applyAbilityOverrideToPokemon(chosenPokemon, Abilities.HEATPROOF);
+          applyAbilityOverrideToPokemon(chosenPokemon, AbilityId.HEATPROOF);
         }
       }
 
@@ -283,7 +283,7 @@ export const FieryFalloutEncounter: MysteryEncounter = MysteryEncounterBuilder.w
 
         const primary = encounter.options[2].primaryPokemon!;
 
-        setEncounterExp([primary.id], getPokemonSpecies(Species.VOLCARONA).baseExp * 2);
+        setEncounterExp([primary.id], getPokemonSpecies(SpeciesId.VOLCARONA).baseExp * 2);
         leaveEncounterWithoutBattle();
       })
       .build(),

src/data/mystery-encounters/encounters/fun-and-games-encounter.ts

@@ -19,7 +19,7 @@ import { MoneyRequirement } from "#app/data/mystery-encounters/mystery-encounter
 import { queueEncounterMessage, showEncounterText } from "#app/data/mystery-encounters/utils/encounter-dialogue-utils";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import i18next from "i18next";
 import { getPokemonNameWithAffix } from "#app/messages";
 import { PlayerGender } from "#enums/player-gender";
@@ -91,7 +91,7 @@ export const FunAndGamesEncounter: MysteryEncounter = MysteryEncounterBuilder.wi
   .withOnInit(() => {
     const encounter = globalScene.currentBattle.mysteryEncounter!;
     globalScene.loadBgm("mystery_encounter_fun_and_games", "mystery_encounter_fun_and_games.mp3");
-    encounter.setDialogueToken("wobbuffetName", getPokemonSpecies(Species.WOBBUFFET).getName());
+    encounter.setDialogueToken("wobbuffetName", getPokemonSpecies(SpeciesId.WOBBUFFET).getName());
     return true;
   })
   .withOnVisualsStart(() => {
@@ -214,7 +214,7 @@ async function summonPlayerPokemon() {
     });
 
     // Also loads Wobbuffet data (cannot be shiny)
-    const enemySpecies = getPokemonSpecies(Species.WOBBUFFET);
+    const enemySpecies = getPokemonSpecies(SpeciesId.WOBBUFFET);
     globalScene.currentBattle.enemyParty = [];
     const wobbuffet = globalScene.addEnemyPokemon(
       enemySpecies,

src/data/mystery-encounters/encounters/global-trade-system-encounter.ts

@@ -17,7 +17,7 @@ import { globalScene } from "#app/global-scene";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import type PokemonSpecies from "#app/data/pokemon-species";
 import { allSpecies, getPokemonSpecies } from "#app/data/pokemon-species";
 import { getTypeRgb } from "#app/data/type";
@@ -64,39 +64,39 @@ const WONDER_TRADE_SHINY_CHANCE = 512;
 const MAX_WONDER_TRADE_SHINY_CHANCE = 4096;
 
 const LEGENDARY_TRADE_POOLS = {
-  1: [Species.RATTATA, Species.PIDGEY, Species.WEEDLE],
+  1: [SpeciesId.RATTATA, SpeciesId.PIDGEY, SpeciesId.WEEDLE],
-  2: [Species.SENTRET, Species.HOOTHOOT, Species.LEDYBA],
+  2: [SpeciesId.SENTRET, SpeciesId.HOOTHOOT, SpeciesId.LEDYBA],
-  3: [Species.POOCHYENA, Species.ZIGZAGOON, Species.TAILLOW],
+  3: [SpeciesId.POOCHYENA, SpeciesId.ZIGZAGOON, SpeciesId.TAILLOW],
-  4: [Species.BIDOOF, Species.STARLY, Species.KRICKETOT],
+  4: [SpeciesId.BIDOOF, SpeciesId.STARLY, SpeciesId.KRICKETOT],
-  5: [Species.PATRAT, Species.PURRLOIN, Species.PIDOVE],
+  5: [SpeciesId.PATRAT, SpeciesId.PURRLOIN, SpeciesId.PIDOVE],
-  6: [Species.BUNNELBY, Species.LITLEO, Species.SCATTERBUG],
+  6: [SpeciesId.BUNNELBY, SpeciesId.LITLEO, SpeciesId.SCATTERBUG],
-  7: [Species.PIKIPEK, Species.YUNGOOS, Species.ROCKRUFF],
+  7: [SpeciesId.PIKIPEK, SpeciesId.YUNGOOS, SpeciesId.ROCKRUFF],
-  8: [Species.SKWOVET, Species.WOOLOO, Species.ROOKIDEE],
+  8: [SpeciesId.SKWOVET, SpeciesId.WOOLOO, SpeciesId.ROOKIDEE],
-  9: [Species.LECHONK, Species.FIDOUGH, Species.TAROUNTULA],
+  9: [SpeciesId.LECHONK, SpeciesId.FIDOUGH, SpeciesId.TAROUNTULA],
 };
 
 /** Exclude Paradox mons as they aren't considered legendary/mythical */
 const EXCLUDED_TRADE_SPECIES = [
-  Species.GREAT_TUSK,
+  SpeciesId.GREAT_TUSK,
-  Species.SCREAM_TAIL,
+  SpeciesId.SCREAM_TAIL,
-  Species.BRUTE_BONNET,
+  SpeciesId.BRUTE_BONNET,
-  Species.FLUTTER_MANE,
+  SpeciesId.FLUTTER_MANE,
-  Species.SLITHER_WING,
+  SpeciesId.SLITHER_WING,
-  Species.SANDY_SHOCKS,
+  SpeciesId.SANDY_SHOCKS,
-  Species.ROARING_MOON,
+  SpeciesId.ROARING_MOON,
-  Species.WALKING_WAKE,
+  SpeciesId.WALKING_WAKE,
-  Species.GOUGING_FIRE,
+  SpeciesId.GOUGING_FIRE,
-  Species.RAGING_BOLT,
+  SpeciesId.RAGING_BOLT,
-  Species.IRON_TREADS,
+  SpeciesId.IRON_TREADS,
-  Species.IRON_BUNDLE,
+  SpeciesId.IRON_BUNDLE,
-  Species.IRON_HANDS,
+  SpeciesId.IRON_HANDS,
-  Species.IRON_JUGULIS,
+  SpeciesId.IRON_JUGULIS,
-  Species.IRON_MOTH,
+  SpeciesId.IRON_MOTH,
-  Species.IRON_THORNS,
+  SpeciesId.IRON_THORNS,
-  Species.IRON_VALIANT,
+  SpeciesId.IRON_VALIANT,
-  Species.IRON_LEAVES,
+  SpeciesId.IRON_LEAVES,
-  Species.IRON_BOULDER,
+  SpeciesId.IRON_BOULDER,
-  Species.IRON_CROWN,
+  SpeciesId.IRON_CROWN,
 ];
 
 /**

src/data/mystery-encounters/encounters/lost-at-sea-encounter.ts

@@ -1,6 +1,6 @@
 import { getPokemonSpecies } from "#app/data/pokemon-species";
-import { Moves } from "#app/enums/moves";
+import { MoveId } from "#enums/move-id";
-import { Species } from "#app/enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
 import { globalScene } from "#app/global-scene";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
@@ -13,8 +13,8 @@ import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode
 import { CLASSIC_MODE_MYSTERY_ENCOUNTER_WAVES } from "#app/constants";
 import { PokemonMove } from "#app/field/pokemon";
 
-const OPTION_1_REQUIRED_MOVE = Moves.SURF;
+const OPTION_1_REQUIRED_MOVE = MoveId.SURF;
-const OPTION_2_REQUIRED_MOVE = Moves.FLY;
+const OPTION_2_REQUIRED_MOVE = MoveId.FLY;
 /**
  * Damage percentage taken when wandering aimlessly.
  * Can be a number between `0` - `100`.
@@ -129,7 +129,7 @@ export const LostAtSeaEncounter: MysteryEncounter = MysteryEncounterBuilder.with
  * Generic handler for using a guiding pokemon to guide you back.
  */
 function handlePokemonGuidingYouPhase() {
-  const laprasSpecies = getPokemonSpecies(Species.LAPRAS);
+  const laprasSpecies = getPokemonSpecies(SpeciesId.LAPRAS);
   const { mysteryEncounter } = globalScene.currentBattle;
 
   if (mysteryEncounter?.selectedOption?.primaryPokemon?.id) {

src/data/mystery-encounters/encounters/mysterious-chest-encounter.ts

@@ -19,11 +19,11 @@ import { CLASSIC_MODE_MYSTERY_ENCOUNTER_WAVES } from "#app/constants";
 import { ModifierTier } from "#app/modifier/modifier-tier";
 import { GameOverPhase } from "#app/phases/game-over-phase";
 import { randSeedInt } from "#app/utils/common";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 
 /** i18n namespace for encounter */
 const namespace = "mysteryEncounters/mysteriousChest";
@@ -86,17 +86,17 @@ export const MysteriousChestEncounter: MysteryEncounter = MysteryEncounterBuilde
       disableSwitch: true,
       pokemonConfigs: [
         {
-          species: getPokemonSpecies(Species.GIMMIGHOUL),
+          species: getPokemonSpecies(SpeciesId.GIMMIGHOUL),
           formIndex: 0,
           isBoss: true,
-          moveSet: [Moves.NASTY_PLOT, Moves.SHADOW_BALL, Moves.POWER_GEM, Moves.THIEF],
+          moveSet: [MoveId.NASTY_PLOT, MoveId.SHADOW_BALL, MoveId.POWER_GEM, MoveId.THIEF],
         },
       ],
     };
 
     encounter.enemyPartyConfigs = [config];
 
-    encounter.setDialogueToken("gimmighoulName", getPokemonSpecies(Species.GIMMIGHOUL).getName());
+    encounter.setDialogueToken("gimmighoulName", getPokemonSpecies(SpeciesId.GIMMIGHOUL).getName());
     encounter.setDialogueToken("trapPercent", TRAP_PERCENT.toString());
     encounter.setDialogueToken("commonPercent", COMMON_REWARDS_PERCENT.toString());
     encounter.setDialogueToken("ultraPercent", ULTRA_REWARDS_PERCENT.toString());

src/data/mystery-encounters/encounters/shady-vitamin-dealer-encounter.ts

@@ -10,7 +10,7 @@ import type Pokemon from "#app/field/pokemon";
 import { modifierTypes } from "#app/modifier/modifier-type";
 import { randSeedInt } from "#app/utils/common";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { globalScene } from "#app/global-scene";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
@@ -49,7 +49,7 @@ export const ShadyVitaminDealerEncounter: MysteryEncounter = MysteryEncounterBui
   .withPrimaryPokemonHealthRatioRequirement([0.51, 1]) // At least 1 Pokemon must have above half HP
   .withIntroSpriteConfigs([
     {
-      spriteKey: Species.KROOKODILE.toString(),
+      spriteKey: SpeciesId.KROOKODILE.toString(),
       fileRoot: "pokemon",
       hasShadow: true,
       repeat: true,

src/data/mystery-encounters/encounters/slumbering-snorlax-encounter.ts

@@ -2,7 +2,7 @@ import { STEALING_MOVES } from "#app/data/mystery-encounters/requirements/requir
 import type { PokemonHeldItemModifierType } from "#app/modifier/modifier-type";
 import { modifierTypes } from "#app/modifier/modifier-type";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { globalScene } from "#app/global-scene";
 import { StatusEffect } from "#enums/status-effect";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
@@ -20,7 +20,7 @@ import {
 } from "../utils/encounter-phase-utils";
 import { queueEncounterMessage } from "#app/data/mystery-encounters/utils/encounter-dialogue-utils";
 import { Nature } from "#enums/nature";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { BattlerIndex } from "#app/battle";
 import { AiType, PokemonMove } from "#app/field/pokemon";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
@@ -50,7 +50,7 @@ export const SlumberingSnorlaxEncounter: MysteryEncounter = MysteryEncounterBuil
   .withFleeAllowed(false)
   .withIntroSpriteConfigs([
     {
-      spriteKey: Species.SNORLAX.toString(),
+      spriteKey: SpeciesId.SNORLAX.toString(),
       fileRoot: "pokemon",
       hasShadow: true,
       tint: 0.25,
@@ -69,14 +69,14 @@ export const SlumberingSnorlaxEncounter: MysteryEncounter = MysteryEncounterBuil
     console.log(encounter);
 
     // Calculate boss mon
-    const bossSpecies = getPokemonSpecies(Species.SNORLAX);
+    const bossSpecies = getPokemonSpecies(SpeciesId.SNORLAX);
     const pokemonConfig: EnemyPokemonConfig = {
       species: bossSpecies,
       isBoss: true,
       shiny: false, // Shiny lock because shiny is rolled only if the battle option is picked
       status: [StatusEffect.SLEEP, 6], // Extra turns on timer for Snorlax's start of fight moves
       nature: Nature.DOCILE,
-      moveSet: [Moves.BODY_SLAM, Moves.CRUNCH, Moves.SLEEP_TALK, Moves.REST],
+      moveSet: [MoveId.BODY_SLAM, MoveId.CRUNCH, MoveId.SLEEP_TALK, MoveId.REST],
       modifierConfigs: [
         {
           modifier: generateModifierType(modifierTypes.BERRY, [BerryType.SITRUS]) as PokemonHeldItemModifierType,
@@ -106,9 +106,9 @@ export const SlumberingSnorlaxEncounter: MysteryEncounter = MysteryEncounterBuil
     encounter.enemyPartyConfigs = [config];
 
     // Load animations/sfx for Snorlax fight start moves
-    loadCustomMovesForEncounter([Moves.SNORE]);
+    loadCustomMovesForEncounter([MoveId.SNORE]);
 
-    encounter.setDialogueToken("snorlaxName", getPokemonSpecies(Species.SNORLAX).getName());
+    encounter.setDialogueToken("snorlaxName", getPokemonSpecies(SpeciesId.SNORLAX).getName());
 
     return true;
   })
@@ -133,14 +133,12 @@ export const SlumberingSnorlaxEncounter: MysteryEncounter = MysteryEncounterBuil
         guaranteedModifierTypeFuncs: [modifierTypes.LEFTOVERS],
         fillRemaining: true,
       });
-      encounter.startOfBattleEffects.push(
+      encounter.startOfBattleEffects.push({
-        {
+        sourceBattlerIndex: BattlerIndex.ENEMY,
-          sourceBattlerIndex: BattlerIndex.ENEMY,
+        targets: [BattlerIndex.PLAYER],
-          targets: [BattlerIndex.PLAYER],
+        move: new PokemonMove(MoveId.SNORE),
-          move: new PokemonMove(Moves.SNORE),
+        ignorePp: true,
-          ignorePp: true,
+      });
-        },
-      );
       await initBattleWithEnemyConfig(encounter.enemyPartyConfigs[0]);
     },
   )
@@ -183,7 +181,7 @@ export const SlumberingSnorlaxEncounter: MysteryEncounter = MysteryEncounterBuil
           fillRemaining: false,
         });
         // Snorlax exp to Pokemon that did the stealing
-        setEncounterExp(instance.primaryPokemon!.id, getPokemonSpecies(Species.SNORLAX).baseExp);
+        setEncounterExp(instance.primaryPokemon!.id, getPokemonSpecies(SpeciesId.SNORLAX).baseExp);
         leaveEncounterWithoutBattle();
       })
       .build(),

src/data/mystery-encounters/encounters/teleporting-hijinks-encounter.ts

@@ -20,7 +20,7 @@ import { queueEncounterMessage, showEncounterText } from "#app/data/mystery-enco
 import PokemonData from "#app/system/pokemon-data";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
 import { getBiomeKey } from "#app/field/arena";
 import { PokemonType } from "#enums/pokemon-type";
 import { getPartyLuckValue, modifierTypes } from "#app/modifier/modifier-type";
@@ -39,7 +39,14 @@ import {
 const namespace = "mysteryEncounters/teleportingHijinks";
 
 const MONEY_COST_MULTIPLIER = 1.75;
-const BIOME_CANDIDATES = [Biome.SPACE, Biome.FAIRY_CAVE, Biome.LABORATORY, Biome.ISLAND, Biome.WASTELAND, Biome.DOJO];
+const BIOME_CANDIDATES = [
+  BiomeId.SPACE,
+  BiomeId.FAIRY_CAVE,
+  BiomeId.LABORATORY,
+  BiomeId.ISLAND,
+  BiomeId.WASTELAND,
+  BiomeId.DOJO,
+];
 const MACHINE_INTERFACING_TYPES = [PokemonType.ELECTRIC, PokemonType.STEEL];
 
 /**
@@ -229,7 +236,7 @@ async function doBiomeTransitionDialogueAndBattleInit() {
   return config;
 }
 
-async function animateBiomeChange(nextBiome: Biome) {
+async function animateBiomeChange(nextBiome: BiomeId) {
   return new Promise<void>(resolve => {
     globalScene.tweens.add({
       targets: [globalScene.arenaEnemy, globalScene.lastEnemyTrainer],

src/data/mystery-encounters/encounters/the-expert-pokemon-breeder-encounter.ts

@@ -11,14 +11,14 @@ import { randSeedShuffle } from "#app/utils/common";
 import type MysteryEncounter from "../mystery-encounter";
 import { MysteryEncounterBuilder } from "../mystery-encounter";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
 import { TrainerType } from "#enums/trainer-type";
 import i18next from "i18next";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
 import { speciesStarterCosts } from "#app/data/balance/starters";
 import { Nature } from "#enums/nature";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import type { PlayerPokemon } from "#app/field/pokemon";
 import { getEncounterText } from "#app/data/mystery-encounters/utils/encounter-dialogue-utils";
 import type { IEggOptions } from "#app/data/egg";
@@ -42,75 +42,75 @@ const FINAL_STAGE_EVOLUTION_WAVE = 75;
 const FRIENDSHIP_ADDED = 20;
 
 class BreederSpeciesEvolution {
-  species: Species;
+  species: SpeciesId;
   evolution: number;
 
-  constructor(species: Species, evolution: number) {
+  constructor(species: SpeciesId, evolution: number) {
     this.species = species;
     this.evolution = evolution;
   }
 }
 
-const POOL_1_POKEMON: (Species | BreederSpeciesEvolution)[][] = [
+const POOL_1_POKEMON: (SpeciesId | BreederSpeciesEvolution)[][] = [
-  [Species.MUNCHLAX, new BreederSpeciesEvolution(Species.SNORLAX, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.MUNCHLAX, new BreederSpeciesEvolution(SpeciesId.SNORLAX, SECOND_STAGE_EVOLUTION_WAVE)],
   [
-    Species.HAPPINY,
+    SpeciesId.HAPPINY,
-    new BreederSpeciesEvolution(Species.CHANSEY, FIRST_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.CHANSEY, FIRST_STAGE_EVOLUTION_WAVE),
-    new BreederSpeciesEvolution(Species.BLISSEY, FINAL_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.BLISSEY, FINAL_STAGE_EVOLUTION_WAVE),
   ],
   [
-    Species.MAGBY,
+    SpeciesId.MAGBY,
-    new BreederSpeciesEvolution(Species.MAGMAR, FIRST_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.MAGMAR, FIRST_STAGE_EVOLUTION_WAVE),
-    new BreederSpeciesEvolution(Species.MAGMORTAR, FINAL_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.MAGMORTAR, FINAL_STAGE_EVOLUTION_WAVE),
   ],
   [
-    Species.ELEKID,
+    SpeciesId.ELEKID,
-    new BreederSpeciesEvolution(Species.ELECTABUZZ, FIRST_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.ELECTABUZZ, FIRST_STAGE_EVOLUTION_WAVE),
-    new BreederSpeciesEvolution(Species.ELECTIVIRE, FINAL_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.ELECTIVIRE, FINAL_STAGE_EVOLUTION_WAVE),
   ],
-  [Species.RIOLU, new BreederSpeciesEvolution(Species.LUCARIO, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.RIOLU, new BreederSpeciesEvolution(SpeciesId.LUCARIO, SECOND_STAGE_EVOLUTION_WAVE)],
   [
-    Species.BUDEW,
+    SpeciesId.BUDEW,
-    new BreederSpeciesEvolution(Species.ROSELIA, FIRST_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.ROSELIA, FIRST_STAGE_EVOLUTION_WAVE),
-    new BreederSpeciesEvolution(Species.ROSERADE, FINAL_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.ROSERADE, FINAL_STAGE_EVOLUTION_WAVE),
   ],
-  [Species.TOXEL, new BreederSpeciesEvolution(Species.TOXTRICITY, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.TOXEL, new BreederSpeciesEvolution(SpeciesId.TOXTRICITY, SECOND_STAGE_EVOLUTION_WAVE)],
   [
-    Species.MIME_JR,
+    SpeciesId.MIME_JR,
-    new BreederSpeciesEvolution(Species.GALAR_MR_MIME, FIRST_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.GALAR_MR_MIME, FIRST_STAGE_EVOLUTION_WAVE),
-    new BreederSpeciesEvolution(Species.MR_RIME, FINAL_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.MR_RIME, FINAL_STAGE_EVOLUTION_WAVE),
   ],
 ];
 
-const POOL_2_POKEMON: (Species | BreederSpeciesEvolution)[][] = [
+const POOL_2_POKEMON: (SpeciesId | BreederSpeciesEvolution)[][] = [
   [
-    Species.PICHU,
+    SpeciesId.PICHU,
-    new BreederSpeciesEvolution(Species.PIKACHU, FIRST_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.PIKACHU, FIRST_STAGE_EVOLUTION_WAVE),
-    new BreederSpeciesEvolution(Species.RAICHU, FINAL_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.RAICHU, FINAL_STAGE_EVOLUTION_WAVE),
   ],
   [
-    Species.PICHU,
+    SpeciesId.PICHU,
-    new BreederSpeciesEvolution(Species.PIKACHU, FIRST_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.PIKACHU, FIRST_STAGE_EVOLUTION_WAVE),
-    new BreederSpeciesEvolution(Species.ALOLA_RAICHU, FINAL_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.ALOLA_RAICHU, FINAL_STAGE_EVOLUTION_WAVE),
   ],
-  [Species.SMOOCHUM, new BreederSpeciesEvolution(Species.JYNX, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.SMOOCHUM, new BreederSpeciesEvolution(SpeciesId.JYNX, SECOND_STAGE_EVOLUTION_WAVE)],
-  [Species.TYROGUE, new BreederSpeciesEvolution(Species.HITMONLEE, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.TYROGUE, new BreederSpeciesEvolution(SpeciesId.HITMONLEE, SECOND_STAGE_EVOLUTION_WAVE)],
-  [Species.TYROGUE, new BreederSpeciesEvolution(Species.HITMONCHAN, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.TYROGUE, new BreederSpeciesEvolution(SpeciesId.HITMONCHAN, SECOND_STAGE_EVOLUTION_WAVE)],
-  [Species.TYROGUE, new BreederSpeciesEvolution(Species.HITMONTOP, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.TYROGUE, new BreederSpeciesEvolution(SpeciesId.HITMONTOP, SECOND_STAGE_EVOLUTION_WAVE)],
   [
-    Species.IGGLYBUFF,
+    SpeciesId.IGGLYBUFF,
-    new BreederSpeciesEvolution(Species.JIGGLYPUFF, FIRST_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.JIGGLYPUFF, FIRST_STAGE_EVOLUTION_WAVE),
-    new BreederSpeciesEvolution(Species.WIGGLYTUFF, FINAL_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.WIGGLYTUFF, FINAL_STAGE_EVOLUTION_WAVE),
   ],
   [
-    Species.AZURILL,
+    SpeciesId.AZURILL,
-    new BreederSpeciesEvolution(Species.MARILL, FIRST_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.MARILL, FIRST_STAGE_EVOLUTION_WAVE),
-    new BreederSpeciesEvolution(Species.AZUMARILL, FINAL_STAGE_EVOLUTION_WAVE),
+    new BreederSpeciesEvolution(SpeciesId.AZUMARILL, FINAL_STAGE_EVOLUTION_WAVE),
   ],
-  [Species.WYNAUT, new BreederSpeciesEvolution(Species.WOBBUFFET, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.WYNAUT, new BreederSpeciesEvolution(SpeciesId.WOBBUFFET, SECOND_STAGE_EVOLUTION_WAVE)],
-  [Species.CHINGLING, new BreederSpeciesEvolution(Species.CHIMECHO, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.CHINGLING, new BreederSpeciesEvolution(SpeciesId.CHIMECHO, SECOND_STAGE_EVOLUTION_WAVE)],
-  [Species.BONSLY, new BreederSpeciesEvolution(Species.SUDOWOODO, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.BONSLY, new BreederSpeciesEvolution(SpeciesId.SUDOWOODO, SECOND_STAGE_EVOLUTION_WAVE)],
-  [Species.MANTYKE, new BreederSpeciesEvolution(Species.MANTINE, SECOND_STAGE_EVOLUTION_WAVE)],
+  [SpeciesId.MANTYKE, new BreederSpeciesEvolution(SpeciesId.MANTINE, SECOND_STAGE_EVOLUTION_WAVE)],
 ];
 
 /**
@@ -144,10 +144,10 @@ export const TheExpertPokemonBreederEncounter: MysteryEncounter = MysteryEncount
 
     const cleffaSpecies =
       waveIndex < FIRST_STAGE_EVOLUTION_WAVE
-        ? Species.CLEFFA
+        ? SpeciesId.CLEFFA
         : waveIndex < FINAL_STAGE_EVOLUTION_WAVE
-          ? Species.CLEFAIRY
+          ? SpeciesId.CLEFAIRY
-          : Species.CLEFABLE;
+          : SpeciesId.CLEFABLE;
     encounter.spriteConfigs = [
       {
         spriteKey: cleffaSpecies.toString(),
@@ -466,10 +466,10 @@ function getPartyConfig(): EnemyPartyConfig {
   // First mon is *always* this special cleffa
   const cleffaSpecies =
     waveIndex < FIRST_STAGE_EVOLUTION_WAVE
-      ? Species.CLEFFA
+      ? SpeciesId.CLEFFA
       : waveIndex < FINAL_STAGE_EVOLUTION_WAVE
-        ? Species.CLEFAIRY
+        ? SpeciesId.CLEFAIRY
-        : Species.CLEFABLE;
+        : SpeciesId.CLEFABLE;
   const baseConfig: EnemyPartyConfig = {
     trainerType: TrainerType.EXPERT_POKEMON_BREEDER,
     pokemonConfigs: [
@@ -482,14 +482,14 @@ function getPartyConfig(): EnemyPartyConfig {
         abilityIndex: 1, // Magic Guard
         shiny: false,
         nature: Nature.ADAMANT,
-        moveSet: [Moves.FIRE_PUNCH, Moves.ICE_PUNCH, Moves.THUNDER_PUNCH, Moves.METEOR_MASH],
+        moveSet: [MoveId.FIRE_PUNCH, MoveId.ICE_PUNCH, MoveId.THUNDER_PUNCH, MoveId.METEOR_MASH],
         ivs: [31, 31, 31, 31, 31, 31],
         tera: PokemonType.FAIRY,
       },
     ],
   };
 
-  if (globalScene.arena.biomeType === Biome.SPACE) {
+  if (globalScene.arena.biomeType === BiomeId.SPACE) {
     // All 3 members always Cleffa line, but different configs
     baseConfig.pokemonConfigs!.push(
       {
@@ -502,7 +502,7 @@ function getPartyConfig(): EnemyPartyConfig {
         shiny: true,
         variant: 1,
         nature: Nature.MODEST,
-        moveSet: [Moves.MOONBLAST, Moves.MYSTICAL_FIRE, Moves.ICE_BEAM, Moves.THUNDERBOLT],
+        moveSet: [MoveId.MOONBLAST, MoveId.MYSTICAL_FIRE, MoveId.ICE_BEAM, MoveId.THUNDERBOLT],
         ivs: [31, 31, 31, 31, 31, 31],
       },
       {
@@ -515,7 +515,7 @@ function getPartyConfig(): EnemyPartyConfig {
         shiny: true,
         variant: 2,
         nature: Nature.BOLD,
-        moveSet: [Moves.TRI_ATTACK, Moves.STORED_POWER, Moves.TAKE_HEART, Moves.MOONLIGHT],
+        moveSet: [MoveId.TRI_ATTACK, MoveId.STORED_POWER, MoveId.TAKE_HEART, MoveId.MOONLIGHT],
         ivs: [31, 31, 31, 31, 31, 31],
       },
     );
@@ -542,7 +542,7 @@ function getPartyConfig(): EnemyPartyConfig {
   return baseConfig;
 }
 
-function getSpeciesFromPool(speciesPool: (Species | BreederSpeciesEvolution)[][], waveIndex: number): Species {
+function getSpeciesFromPool(speciesPool: (SpeciesId | BreederSpeciesEvolution)[][], waveIndex: number): SpeciesId {
   const poolCopy = randSeedShuffle(speciesPool.slice(0));
   const speciesEvolutions = poolCopy.pop()!.slice(0);
   let speciesObject = speciesEvolutions.pop()!;
@@ -581,7 +581,7 @@ function calculateEggRewardsForPokemon(pokemon: PlayerPokemon): [number, number]
 }
 
 function getEggOptions(commonEggs: number, rareEggs: number) {
-  const eggDescription = i18next.t(`${namespace}:title`) + ":\n" + i18next.t(trainerNameKey);
+  const eggDescription = i18next.t(`${namespace}:title`);
   const eggOptions: IEggOptions[] = [];
 
   if (commonEggs > 0) {

src/data/mystery-encounters/encounters/the-pokemon-salesman-encounter.ts

@@ -17,7 +17,7 @@ import {
 import type PokemonSpecies from "#app/data/pokemon-species";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
 import { speciesStarterCosts } from "#app/data/balance/starters";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { PokeballType } from "#enums/pokeball";
 import type { EnemyPokemon } from "#app/field/pokemon";
 import { PlayerPokemon } from "#app/field/pokemon";
@@ -27,7 +27,7 @@ import PokemonData from "#app/system/pokemon-data";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
 import { CLASSIC_MODE_MYSTERY_ENCOUNTER_WAVES } from "#app/constants";
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 import { NON_LEGEND_PARADOX_POKEMON, NON_LEGEND_ULTRA_BEASTS } from "#app/data/balance/special-species-groups";
 import { timedEventManager } from "#app/global-event-manager";
 
@@ -81,7 +81,7 @@ export const ThePokemonSalesmanEncounter: MysteryEncounter = MysteryEncounterBui
     let tries = 0;
 
     // Reroll any species that don't have HAs
-    while ((isNullOrUndefined(species.abilityHidden) || species.abilityHidden === Abilities.NONE) && tries < 5) {
+    while ((isNullOrUndefined(species.abilityHidden) || species.abilityHidden === AbilityId.NONE) && tries < 5) {
       species = getSalesmanSpeciesOffer();
       tries++;
     }
@@ -110,15 +110,15 @@ export const ThePokemonSalesmanEncounter: MysteryEncounter = MysteryEncounterBui
      */
     if (
       r === 0 ||
-      ((isNullOrUndefined(species.abilityHidden) || species.abilityHidden === Abilities.NONE) &&
+      ((isNullOrUndefined(species.abilityHidden) || species.abilityHidden === AbilityId.NONE) &&
         validEventEncounters.length === 0)
     ) {
       // If you roll 1%, give shiny Magikarp with random variant
-      species = getPokemonSpecies(Species.MAGIKARP);
+      species = getPokemonSpecies(SpeciesId.MAGIKARP);
       pokemon = new PlayerPokemon(species, 5, 2, undefined, undefined, true);
     } else if (
       validEventEncounters.length > 0 &&
-      (r <= EVENT_THRESHOLD || isNullOrUndefined(species.abilityHidden) || species.abilityHidden === Abilities.NONE)
+      (r <= EVENT_THRESHOLD || isNullOrUndefined(species.abilityHidden) || species.abilityHidden === AbilityId.NONE)
     ) {
       tries = 0;
       do {
@@ -128,7 +128,7 @@ export const ThePokemonSalesmanEncounter: MysteryEncounter = MysteryEncounterBui
         pokemon = new PlayerPokemon(
           species,
           5,
-          species.abilityHidden === Abilities.NONE ? undefined : 2,
+          species.abilityHidden === AbilityId.NONE ? undefined : 2,
           enc.formIndex,
         );
         pokemon.trySetShinySeed();
@@ -151,7 +151,7 @@ export const ThePokemonSalesmanEncounter: MysteryEncounter = MysteryEncounterBui
           pokemon.trySetShinySeed();
         } else {
           // If there's, and this would never happen, no eligible event encounters with a hidden ability, just do Magikarp
-          species = getPokemonSpecies(Species.MAGIKARP);
+          species = getPokemonSpecies(SpeciesId.MAGIKARP);
           pokemon = new PlayerPokemon(species, 5, 2, undefined, undefined, true);
         }
       }

src/data/mystery-encounters/encounters/the-strong-stuff-encounter.ts

@@ -14,13 +14,13 @@ import { globalScene } from "#app/global-scene";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { Nature } from "#enums/nature";
 import type Pokemon from "#app/field/pokemon";
 import { PokemonMove } from "#app/field/pokemon";
 import { queueEncounterMessage, showEncounterText } from "#app/data/mystery-encounters/utils/encounter-dialogue-utils";
 import { modifyPlayerPokemonBST } from "#app/data/mystery-encounters/utils/encounter-pokemon-utils";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { BattlerIndex } from "#app/battle";
 import { BattlerTagType } from "#enums/battler-tag-type";
 import { BerryType } from "#enums/berry-type";
@@ -64,7 +64,7 @@ export const TheStrongStuffEncounter: MysteryEncounter = MysteryEncounterBuilder
       disableAnimation: true,
     },
     {
-      spriteKey: Species.SHUCKLE.toString(),
+      spriteKey: SpeciesId.SHUCKLE.toString(),
       fileRoot: "pokemon",
       hasShadow: true,
       repeat: true,
@@ -88,13 +88,13 @@ export const TheStrongStuffEncounter: MysteryEncounter = MysteryEncounterBuilder
       disableSwitch: true,
       pokemonConfigs: [
         {
-          species: getPokemonSpecies(Species.SHUCKLE),
+          species: getPokemonSpecies(SpeciesId.SHUCKLE),
           isBoss: true,
           bossSegments: 5,
           shiny: false, // Shiny lock because shiny is rolled only if the battle option is picked
           customPokemonData: new CustomPokemonData({ spriteScale: 1.25 }),
           nature: Nature.HARDY,
-          moveSet: [Moves.INFESTATION, Moves.SALT_CURE, Moves.GASTRO_ACID, Moves.HEAL_ORDER],
+          moveSet: [MoveId.INFESTATION, MoveId.SALT_CURE, MoveId.GASTRO_ACID, MoveId.HEAL_ORDER],
           modifierConfigs: [
             {
               modifier: generateModifierType(modifierTypes.BERRY, [BerryType.SITRUS]) as PokemonHeldItemModifierType,
@@ -126,9 +126,9 @@ export const TheStrongStuffEncounter: MysteryEncounter = MysteryEncounterBuilder
 
     encounter.enemyPartyConfigs = [config];
 
-    loadCustomMovesForEncounter([Moves.GASTRO_ACID, Moves.STEALTH_ROCK]);
+    loadCustomMovesForEncounter([MoveId.GASTRO_ACID, MoveId.STEALTH_ROCK]);
 
-    encounter.setDialogueToken("shuckleName", getPokemonSpecies(Species.SHUCKLE).getName());
+    encounter.setDialogueToken("shuckleName", getPokemonSpecies(SpeciesId.SHUCKLE).getName());
 
     return true;
   })
@@ -210,13 +210,13 @@ export const TheStrongStuffEncounter: MysteryEncounter = MysteryEncounterBuilder
         {
           sourceBattlerIndex: BattlerIndex.ENEMY,
           targets: [BattlerIndex.PLAYER],
-          move: new PokemonMove(Moves.GASTRO_ACID),
+          move: new PokemonMove(MoveId.GASTRO_ACID),
           ignorePp: true,
         },
         {
           sourceBattlerIndex: BattlerIndex.ENEMY,
           targets: [BattlerIndex.PLAYER],
-          move: new PokemonMove(Moves.STEALTH_ROCK),
+          move: new PokemonMove(MoveId.STEALTH_ROCK),
           ignorePp: true,
         },
       );

src/data/mystery-encounters/encounters/the-winstrate-challenge-encounter.ts

@@ -15,10 +15,10 @@ import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounte
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { TrainerType } from "#enums/trainer-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { Nature } from "#enums/nature";
 import { PokemonType } from "#enums/pokemon-type";
 import { BerryType } from "#enums/berry-type";
@@ -215,8 +215,8 @@ function endTrainerBattleAndShowDialogue(): Promise<void> {
         // Only trigger form change when Eiscue is in Noice form
         // Hardcoded Eiscue for now in case it is fused with another pokemon
         if (
-          pokemon.species.speciesId === Species.EISCUE &&
+          pokemon.species.speciesId === SpeciesId.EISCUE &&
-          pokemon.hasAbility(Abilities.ICE_FACE) &&
+          pokemon.hasAbility(AbilityId.ICE_FACE) &&
           pokemon.formIndex === 1
         ) {
           globalScene.triggerPokemonFormChange(pokemon, SpeciesFormChangeAbilityTrigger);
@@ -256,11 +256,11 @@ function getVictorTrainerConfig(): EnemyPartyConfig {
     trainerType: TrainerType.VICTOR,
     pokemonConfigs: [
       {
-        species: getPokemonSpecies(Species.SWELLOW),
+        species: getPokemonSpecies(SpeciesId.SWELLOW),
         isBoss: false,
         abilityIndex: 0, // Guts
         nature: Nature.ADAMANT,
-        moveSet: [Moves.FACADE, Moves.BRAVE_BIRD, Moves.PROTECT, Moves.QUICK_ATTACK],
+        moveSet: [MoveId.FACADE, MoveId.BRAVE_BIRD, MoveId.PROTECT, MoveId.QUICK_ATTACK],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.FLAME_ORB) as PokemonHeldItemModifierType,
@@ -274,11 +274,11 @@ function getVictorTrainerConfig(): EnemyPartyConfig {
         ],
       },
       {
-        species: getPokemonSpecies(Species.OBSTAGOON),
+        species: getPokemonSpecies(SpeciesId.OBSTAGOON),
         isBoss: false,
         abilityIndex: 1, // Guts
         nature: Nature.ADAMANT,
-        moveSet: [Moves.FACADE, Moves.OBSTRUCT, Moves.NIGHT_SLASH, Moves.FIRE_PUNCH],
+        moveSet: [MoveId.FACADE, MoveId.OBSTRUCT, MoveId.NIGHT_SLASH, MoveId.FIRE_PUNCH],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.FLAME_ORB) as PokemonHeldItemModifierType,
@@ -300,11 +300,11 @@ function getVictoriaTrainerConfig(): EnemyPartyConfig {
     trainerType: TrainerType.VICTORIA,
     pokemonConfigs: [
       {
-        species: getPokemonSpecies(Species.ROSERADE),
+        species: getPokemonSpecies(SpeciesId.ROSERADE),
         isBoss: false,
         abilityIndex: 0, // Natural Cure
         nature: Nature.CALM,
-        moveSet: [Moves.SYNTHESIS, Moves.SLUDGE_BOMB, Moves.GIGA_DRAIN, Moves.SLEEP_POWDER],
+        moveSet: [MoveId.SYNTHESIS, MoveId.SLUDGE_BOMB, MoveId.GIGA_DRAIN, MoveId.SLEEP_POWDER],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.SOUL_DEW) as PokemonHeldItemModifierType,
@@ -318,11 +318,11 @@ function getVictoriaTrainerConfig(): EnemyPartyConfig {
         ],
       },
       {
-        species: getPokemonSpecies(Species.GARDEVOIR),
+        species: getPokemonSpecies(SpeciesId.GARDEVOIR),
         isBoss: false,
         formIndex: 1,
         nature: Nature.TIMID,
-        moveSet: [Moves.PSYSHOCK, Moves.MOONBLAST, Moves.SHADOW_BALL, Moves.WILL_O_WISP],
+        moveSet: [MoveId.PSYSHOCK, MoveId.MOONBLAST, MoveId.SHADOW_BALL, MoveId.WILL_O_WISP],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.ATTACK_TYPE_BOOSTER, [
@@ -349,11 +349,11 @@ function getViviTrainerConfig(): EnemyPartyConfig {
     trainerType: TrainerType.VIVI,
     pokemonConfigs: [
       {
-        species: getPokemonSpecies(Species.SEAKING),
+        species: getPokemonSpecies(SpeciesId.SEAKING),
         isBoss: false,
         abilityIndex: 3, // Lightning Rod
         nature: Nature.ADAMANT,
-        moveSet: [Moves.WATERFALL, Moves.MEGAHORN, Moves.KNOCK_OFF, Moves.REST],
+        moveSet: [MoveId.WATERFALL, MoveId.MEGAHORN, MoveId.KNOCK_OFF, MoveId.REST],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.BERRY, [BerryType.LUM]) as PokemonHeldItemModifierType,
@@ -368,11 +368,11 @@ function getViviTrainerConfig(): EnemyPartyConfig {
         ],
       },
       {
-        species: getPokemonSpecies(Species.BRELOOM),
+        species: getPokemonSpecies(SpeciesId.BRELOOM),
         isBoss: false,
         abilityIndex: 1, // Poison Heal
         nature: Nature.JOLLY,
-        moveSet: [Moves.SPORE, Moves.SWORDS_DANCE, Moves.SEED_BOMB, Moves.DRAIN_PUNCH],
+        moveSet: [MoveId.SPORE, MoveId.SWORDS_DANCE, MoveId.SEED_BOMB, MoveId.DRAIN_PUNCH],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.BASE_STAT_BOOSTER, [Stat.HP]) as PokemonHeldItemModifierType,
@@ -386,11 +386,11 @@ function getViviTrainerConfig(): EnemyPartyConfig {
         ],
       },
       {
-        species: getPokemonSpecies(Species.CAMERUPT),
+        species: getPokemonSpecies(SpeciesId.CAMERUPT),
         isBoss: false,
         formIndex: 1,
         nature: Nature.CALM,
-        moveSet: [Moves.EARTH_POWER, Moves.FIRE_BLAST, Moves.YAWN, Moves.PROTECT],
+        moveSet: [MoveId.EARTH_POWER, MoveId.FIRE_BLAST, MoveId.YAWN, MoveId.PROTECT],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.QUICK_CLAW) as PokemonHeldItemModifierType,
@@ -408,11 +408,11 @@ function getVickyTrainerConfig(): EnemyPartyConfig {
     trainerType: TrainerType.VICKY,
     pokemonConfigs: [
       {
-        species: getPokemonSpecies(Species.MEDICHAM),
+        species: getPokemonSpecies(SpeciesId.MEDICHAM),
         isBoss: false,
         formIndex: 1,
         nature: Nature.IMPISH,
-        moveSet: [Moves.AXE_KICK, Moves.ICE_PUNCH, Moves.ZEN_HEADBUTT, Moves.BULLET_PUNCH],
+        moveSet: [MoveId.AXE_KICK, MoveId.ICE_PUNCH, MoveId.ZEN_HEADBUTT, MoveId.BULLET_PUNCH],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.SHELL_BELL) as PokemonHeldItemModifierType,
@@ -429,11 +429,11 @@ function getVitoTrainerConfig(): EnemyPartyConfig {
     trainerType: TrainerType.VITO,
     pokemonConfigs: [
       {
-        species: getPokemonSpecies(Species.HISUI_ELECTRODE),
+        species: getPokemonSpecies(SpeciesId.HISUI_ELECTRODE),
         isBoss: false,
         abilityIndex: 0, // Soundproof
         nature: Nature.MODEST,
-        moveSet: [Moves.THUNDERBOLT, Moves.GIGA_DRAIN, Moves.FOUL_PLAY, Moves.THUNDER_WAVE],
+        moveSet: [MoveId.THUNDERBOLT, MoveId.GIGA_DRAIN, MoveId.FOUL_PLAY, MoveId.THUNDER_WAVE],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.BASE_STAT_BOOSTER, [Stat.SPD]) as PokemonHeldItemModifierType,
@@ -443,11 +443,11 @@ function getVitoTrainerConfig(): EnemyPartyConfig {
         ],
       },
       {
-        species: getPokemonSpecies(Species.SWALOT),
+        species: getPokemonSpecies(SpeciesId.SWALOT),
         isBoss: false,
         abilityIndex: 2, // Gluttony
         nature: Nature.QUIET,
-        moveSet: [Moves.SLUDGE_BOMB, Moves.GIGA_DRAIN, Moves.ICE_BEAM, Moves.EARTHQUAKE],
+        moveSet: [MoveId.SLUDGE_BOMB, MoveId.GIGA_DRAIN, MoveId.ICE_BEAM, MoveId.EARTHQUAKE],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.BERRY, [BerryType.SITRUS]) as PokemonHeldItemModifierType,
@@ -496,11 +496,11 @@ function getVitoTrainerConfig(): EnemyPartyConfig {
         ],
       },
       {
-        species: getPokemonSpecies(Species.DODRIO),
+        species: getPokemonSpecies(SpeciesId.DODRIO),
         isBoss: false,
         abilityIndex: 2, // Tangled Feet
         nature: Nature.JOLLY,
-        moveSet: [Moves.DRILL_PECK, Moves.QUICK_ATTACK, Moves.THRASH, Moves.KNOCK_OFF],
+        moveSet: [MoveId.DRILL_PECK, MoveId.QUICK_ATTACK, MoveId.THRASH, MoveId.KNOCK_OFF],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.KINGS_ROCK) as PokemonHeldItemModifierType,
@@ -510,11 +510,11 @@ function getVitoTrainerConfig(): EnemyPartyConfig {
         ],
       },
       {
-        species: getPokemonSpecies(Species.ALAKAZAM),
+        species: getPokemonSpecies(SpeciesId.ALAKAZAM),
         isBoss: false,
         formIndex: 1,
         nature: Nature.BOLD,
-        moveSet: [Moves.PSYCHIC, Moves.SHADOW_BALL, Moves.FOCUS_BLAST, Moves.THUNDERBOLT],
+        moveSet: [MoveId.PSYCHIC, MoveId.SHADOW_BALL, MoveId.FOCUS_BLAST, MoveId.THUNDERBOLT],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.WIDE_LENS) as PokemonHeldItemModifierType,
@@ -524,11 +524,11 @@ function getVitoTrainerConfig(): EnemyPartyConfig {
         ],
       },
       {
-        species: getPokemonSpecies(Species.DARMANITAN),
+        species: getPokemonSpecies(SpeciesId.DARMANITAN),
         isBoss: false,
         abilityIndex: 0, // Sheer Force
         nature: Nature.IMPISH,
-        moveSet: [Moves.EARTHQUAKE, Moves.U_TURN, Moves.FLARE_BLITZ, Moves.ROCK_SLIDE],
+        moveSet: [MoveId.EARTHQUAKE, MoveId.U_TURN, MoveId.FLARE_BLITZ, MoveId.ROCK_SLIDE],
         modifierConfigs: [
           {
             modifier: generateModifierType(modifierTypes.QUICK_CLAW) as PokemonHeldItemModifierType,

src/data/mystery-encounters/encounters/trash-to-treasure-encounter.ts

@@ -16,14 +16,14 @@ import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-en
 import { MysteryEncounterOptionBuilder } from "#app/data/mystery-encounters/mystery-encounter-option";
 import { MysteryEncounterTier } from "#enums/mystery-encounter-tier";
 import { MysteryEncounterOptionMode } from "#enums/mystery-encounter-option-mode";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { HitHealModifier, PokemonHeldItemModifier, TurnHealModifier } from "#app/modifier/modifier";
 import { applyModifierTypeToPlayerPokemon } from "#app/data/mystery-encounters/utils/encounter-pokemon-utils";
 import { showEncounterText } from "#app/data/mystery-encounters/utils/encounter-dialogue-utils";
 import i18next from "#app/plugins/i18n";
 import { ModifierTier } from "#app/modifier/modifier-tier";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { BattlerIndex } from "#app/battle";
 import { PokemonMove } from "#app/field/pokemon";
 import { CLASSIC_MODE_MYSTERY_ENCOUNTER_WAVES } from "#app/constants";
@@ -51,7 +51,7 @@ export const TrashToTreasureEncounter: MysteryEncounter = MysteryEncounterBuilde
   .withFleeAllowed(false)
   .withIntroSpriteConfigs([
     {
-      spriteKey: Species.GARBODOR.toString() + "-gigantamax",
+      spriteKey: SpeciesId.GARBODOR.toString() + "-gigantamax",
       fileRoot: "pokemon",
       hasShadow: false,
       disableAnimation: true,
@@ -74,14 +74,14 @@ export const TrashToTreasureEncounter: MysteryEncounter = MysteryEncounterBuilde
     const encounter = globalScene.currentBattle.mysteryEncounter!;
 
     // Calculate boss mon (shiny locked)
-    const bossSpecies = getPokemonSpecies(Species.GARBODOR);
+    const bossSpecies = getPokemonSpecies(SpeciesId.GARBODOR);
     const pokemonConfig: EnemyPokemonConfig = {
       species: bossSpecies,
       isBoss: true,
       shiny: false, // Shiny lock because of custom intro sprite
       formIndex: 1, // Gmax
       bossSegmentModifier: 1, // +1 Segment from normal
-      moveSet: [Moves.GUNK_SHOT, Moves.STOMPING_TANTRUM, Moves.HAMMER_ARM, Moves.PAYBACK],
+      moveSet: [MoveId.GUNK_SHOT, MoveId.STOMPING_TANTRUM, MoveId.HAMMER_ARM, MoveId.PAYBACK],
       modifierConfigs: [
         {
           modifier: generateModifierType(modifierTypes.BERRY) as PokemonHeldItemModifierType,
@@ -127,7 +127,7 @@ export const TrashToTreasureEncounter: MysteryEncounter = MysteryEncounterBuilde
     encounter.enemyPartyConfigs = [config];
 
     // Load animations/sfx for Garbodor fight start moves
-    loadCustomMovesForEncounter([Moves.TOXIC, Moves.STOCKPILE]);
+    loadCustomMovesForEncounter([MoveId.TOXIC, MoveId.STOCKPILE]);
 
     globalScene.loadSe("PRSFX- Dig2", "battle_anims", "PRSFX- Dig2.wav");
     globalScene.loadSe("PRSFX- Venom Drench", "battle_anims", "PRSFX- Venom Drench.wav");
@@ -206,13 +206,13 @@ export const TrashToTreasureEncounter: MysteryEncounter = MysteryEncounterBuilde
           {
             sourceBattlerIndex: BattlerIndex.ENEMY,
             targets: [BattlerIndex.PLAYER],
-            move: new PokemonMove(Moves.TOXIC),
+            move: new PokemonMove(MoveId.TOXIC),
             ignorePp: true,
           },
           {
             sourceBattlerIndex: BattlerIndex.ENEMY,
             targets: [BattlerIndex.ENEMY],
-            move: new PokemonMove(Moves.STOCKPILE),
+            move: new PokemonMove(MoveId.STOCKPILE),
             ignorePp: true,
           },
         );

src/data/mystery-encounters/encounters/uncommon-breed-encounter.ts

@@ -28,7 +28,7 @@ import {
 } from "#app/data/mystery-encounters/utils/encounter-pokemon-utils";
 import PokemonData from "#app/system/pokemon-data";
 import { isNullOrUndefined, randSeedInt } from "#app/utils/common";
-import type { Moves } from "#enums/moves";
+import type { MoveId } from "#enums/move-id";
 import { BattlerIndex } from "#app/battle";
 import { SelfStatusMove } from "#app/data/moves/move";
 import { PokeballType } from "#enums/pokeball";
@@ -73,7 +73,7 @@ export const UncommonBreedEncounter: MysteryEncounter = MysteryEncounterBuilder.
     const eggMoves = pokemon.getEggMoves();
     if (eggMoves) {
       const eggMoveIndex = randSeedInt(4);
-      const randomEggMove: Moves = eggMoves[eggMoveIndex];
+      const randomEggMove: MoveId = eggMoves[eggMoveIndex];
       encounter.misc = {
         eggMove: randomEggMove,
         pokemon: pokemon,
@@ -270,10 +270,10 @@ export const UncommonBreedEncounter: MysteryEncounter = MysteryEncounterBuilder.
   )
   .build();
 
-function givePokemonExtraEggMove(pokemon: EnemyPokemon, previousEggMove: Moves) {
+function givePokemonExtraEggMove(pokemon: EnemyPokemon, previousEggMove: MoveId) {
   const eggMoves = pokemon.getEggMoves();
   if (eggMoves) {
-    let randomEggMove: Moves = eggMoves[randSeedInt(4)];
+    let randomEggMove: MoveId = eggMoves[randSeedInt(4)];
     while (randomEggMove === previousEggMove) {
       randomEggMove = eggMoves[randSeedInt(4)];
     }

src/data/mystery-encounters/encounters/weird-dream-encounter.ts

@@ -1,6 +1,6 @@
 import { PokemonType } from "#enums/pokemon-type";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { globalScene } from "#app/global-scene";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
 import { MysteryEncounterBuilder } from "#app/data/mystery-encounters/mystery-encounter";
@@ -49,55 +49,55 @@ const namespace = "mysteryEncounters/weirdDream";
 
 /** Exclude Ultra Beasts, Paradox, Eternatus, and all legendary/mythical/trio pokemon that are below 570 BST */
 const EXCLUDED_TRANSFORMATION_SPECIES = [
-  Species.ETERNATUS,
+  SpeciesId.ETERNATUS,
   /** UBs */
-  Species.NIHILEGO,
+  SpeciesId.NIHILEGO,
-  Species.BUZZWOLE,
+  SpeciesId.BUZZWOLE,
-  Species.PHEROMOSA,
+  SpeciesId.PHEROMOSA,
-  Species.XURKITREE,
+  SpeciesId.XURKITREE,
-  Species.CELESTEELA,
+  SpeciesId.CELESTEELA,
-  Species.KARTANA,
+  SpeciesId.KARTANA,
-  Species.GUZZLORD,
+  SpeciesId.GUZZLORD,
-  Species.POIPOLE,
+  SpeciesId.POIPOLE,
-  Species.NAGANADEL,
+  SpeciesId.NAGANADEL,
-  Species.STAKATAKA,
+  SpeciesId.STAKATAKA,
-  Species.BLACEPHALON,
+  SpeciesId.BLACEPHALON,
   /** Paradox */
-  Species.GREAT_TUSK,
+  SpeciesId.GREAT_TUSK,
-  Species.SCREAM_TAIL,
+  SpeciesId.SCREAM_TAIL,
-  Species.BRUTE_BONNET,
+  SpeciesId.BRUTE_BONNET,
-  Species.FLUTTER_MANE,
+  SpeciesId.FLUTTER_MANE,
-  Species.SLITHER_WING,
+  SpeciesId.SLITHER_WING,
-  Species.SANDY_SHOCKS,
+  SpeciesId.SANDY_SHOCKS,
-  Species.ROARING_MOON,
+  SpeciesId.ROARING_MOON,
-  Species.WALKING_WAKE,
+  SpeciesId.WALKING_WAKE,
-  Species.GOUGING_FIRE,
+  SpeciesId.GOUGING_FIRE,
-  Species.RAGING_BOLT,
+  SpeciesId.RAGING_BOLT,
-  Species.IRON_TREADS,
+  SpeciesId.IRON_TREADS,
-  Species.IRON_BUNDLE,
+  SpeciesId.IRON_BUNDLE,
-  Species.IRON_HANDS,
+  SpeciesId.IRON_HANDS,
-  Species.IRON_JUGULIS,
+  SpeciesId.IRON_JUGULIS,
-  Species.IRON_MOTH,
+  SpeciesId.IRON_MOTH,
-  Species.IRON_THORNS,
+  SpeciesId.IRON_THORNS,
-  Species.IRON_VALIANT,
+  SpeciesId.IRON_VALIANT,
-  Species.IRON_LEAVES,
+  SpeciesId.IRON_LEAVES,
-  Species.IRON_BOULDER,
+  SpeciesId.IRON_BOULDER,
-  Species.IRON_CROWN,
+  SpeciesId.IRON_CROWN,
   /** These are banned so they don't appear in the < 570 BST pool */
-  Species.COSMOG,
+  SpeciesId.COSMOG,
-  Species.MELTAN,
+  SpeciesId.MELTAN,
-  Species.KUBFU,
+  SpeciesId.KUBFU,
-  Species.COSMOEM,
+  SpeciesId.COSMOEM,
-  Species.POIPOLE,
+  SpeciesId.POIPOLE,
-  Species.TERAPAGOS,
+  SpeciesId.TERAPAGOS,
-  Species.TYPE_NULL,
+  SpeciesId.TYPE_NULL,
-  Species.CALYREX,
+  SpeciesId.CALYREX,
-  Species.NAGANADEL,
+  SpeciesId.NAGANADEL,
-  Species.URSHIFU,
+  SpeciesId.URSHIFU,
-  Species.OGERPON,
+  SpeciesId.OGERPON,
-  Species.OKIDOGI,
+  SpeciesId.OKIDOGI,
-  Species.MUNKIDORI,
+  SpeciesId.MUNKIDORI,
-  Species.FEZANDIPITI,
+  SpeciesId.FEZANDIPITI,
 ];
 
 const SUPER_LEGENDARY_BST_THRESHOLD = 600;
@@ -500,7 +500,7 @@ async function doNewTeamPostProcess(transformations: PokemonTransformation[]) {
 async function postProcessTransformedPokemon(
   previousPokemon: PlayerPokemon,
   newPokemon: PlayerPokemon,
-  speciesRootForm: Species,
+  speciesRootForm: SpeciesId,
   forBattle = false,
 ): Promise<boolean> {
   let isNewStarter = false;
@@ -768,7 +768,7 @@ function doSideBySideTransformations(transformations: PokemonTransformation[]) {
  */
 async function addEggMoveToNewPokemonMoveset(
   newPokemon: PlayerPokemon,
-  speciesRootForm: Species,
+  speciesRootForm: SpeciesId,
   forBattle = false,
 ): Promise<number | null> {
   let eggMoveIndex: null | number = null;

src/data/mystery-encounters/mystery-encounter-option.ts

@@ -1,5 +1,5 @@
 import type { OptionTextDisplay } from "#app/data/mystery-encounters/mystery-encounter-dialogue";
-import type { Moves } from "#app/enums/moves";
+import type { MoveId } from "#enums/move-id";
 import type { PlayerPokemon } from "#app/field/pokemon";
 import type Pokemon from "#app/field/pokemon";
 import { globalScene } from "#app/global-scene";
@@ -300,7 +300,7 @@ export class MysteryEncounterOptionBuilder implements Partial<IMysteryEncounterO
    * @param options see {@linkcode CanLearnMoveRequirementOptions}
    * @returns
    */
-  withPokemonCanLearnMoveRequirement(move: Moves | Moves[], options?: CanLearnMoveRequirementOptions) {
+  withPokemonCanLearnMoveRequirement(move: MoveId | MoveId[], options?: CanLearnMoveRequirementOptions) {
     return this.withPrimaryPokemonRequirement(new CanLearnMoveRequirement(move, options));
   }
 

src/data/mystery-encounters/mystery-encounter-requirements.ts

@@ -10,10 +10,10 @@ import type { PlayerPokemon } from "#app/field/pokemon";
 import { AttackTypeBoosterModifier } from "#app/modifier/modifier";
 import type { AttackTypeBoosterModifierType } from "#app/modifier/modifier-type";
 import { isNullOrUndefined } from "#app/utils/common";
-import type { Abilities } from "#enums/abilities";
+import type { AbilityId } from "#enums/ability-id";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import type { MysteryEncounterType } from "#enums/mystery-encounter-type";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { SpeciesFormKey } from "#enums/species-form-key";
 import { TimeOfDay } from "#enums/time-of-day";
 
@@ -424,11 +424,11 @@ export class MoneyRequirement extends EncounterSceneRequirement {
 }
 
 export class SpeciesRequirement extends EncounterPokemonRequirement {
-  requiredSpecies: Species[];
+  requiredSpecies: SpeciesId[];
   minNumberOfPokemon: number;
   invertQuery: boolean;
 
-  constructor(species: Species | Species[], minNumberOfPokemon = 1, invertQuery = false) {
+  constructor(species: SpeciesId | SpeciesId[], minNumberOfPokemon = 1, invertQuery = false) {
     super();
     this.minNumberOfPokemon = minNumberOfPokemon;
     this.invertQuery = invertQuery;
@@ -457,7 +457,7 @@ export class SpeciesRequirement extends EncounterPokemonRequirement {
 
   override getDialogueToken(pokemon?: PlayerPokemon): [string, string] {
     if (pokemon?.species.speciesId && this.requiredSpecies.includes(pokemon.species.speciesId)) {
-      return ["species", Species[pokemon.species.speciesId]];
+      return ["species", SpeciesId[pokemon.species.speciesId]];
     }
     return ["species", ""];
   }
@@ -549,12 +549,17 @@ export class TypeRequirement extends EncounterPokemonRequirement {
 }
 
 export class MoveRequirement extends EncounterPokemonRequirement {
-  requiredMoves: Moves[] = [];
+  requiredMoves: MoveId[] = [];
   minNumberOfPokemon: number;
   invertQuery: boolean;
   excludeDisallowedPokemon: boolean;
 
-  constructor(moves: Moves | Moves[], excludeDisallowedPokemon: boolean, minNumberOfPokemon = 1, invertQuery = false) {
+  constructor(
+    moves: MoveId | MoveId[],
+    excludeDisallowedPokemon: boolean,
+    minNumberOfPokemon = 1,
+    invertQuery = false,
+  ) {
     super();
     this.excludeDisallowedPokemon = excludeDisallowedPokemon;
     this.minNumberOfPokemon = minNumberOfPokemon;
@@ -602,11 +607,11 @@ export class MoveRequirement extends EncounterPokemonRequirement {
  * NOTE: If the Pokemon already knows the move, this requirement will fail, since it's not technically learnable.
  */
 export class CompatibleMoveRequirement extends EncounterPokemonRequirement {
-  requiredMoves: Moves[];
+  requiredMoves: MoveId[];
   minNumberOfPokemon: number;
   invertQuery: boolean;
 
-  constructor(learnableMove: Moves | Moves[], minNumberOfPokemon = 1, invertQuery = false) {
+  constructor(learnableMove: MoveId | MoveId[], minNumberOfPokemon = 1, invertQuery = false) {
     super();
     this.minNumberOfPokemon = minNumberOfPokemon;
     this.invertQuery = invertQuery;
@@ -644,20 +649,20 @@ export class CompatibleMoveRequirement extends EncounterPokemonRequirement {
       pokemon?.compatibleTms.filter(tm => !pokemon.moveset.find(m => m.moveId === tm)).includes(reqMove),
     );
     if (includedCompatMoves.length > 0) {
-      return ["compatibleMove", Moves[includedCompatMoves[0]]];
+      return ["compatibleMove", MoveId[includedCompatMoves[0]]];
     }
     return ["compatibleMove", ""];
   }
 }
 
 export class AbilityRequirement extends EncounterPokemonRequirement {
-  requiredAbilities: Abilities[];
+  requiredAbilities: AbilityId[];
   minNumberOfPokemon: number;
   invertQuery: boolean;
   excludeDisallowedPokemon: boolean;
 
   constructor(
-    abilities: Abilities | Abilities[],
+    abilities: AbilityId | AbilityId[],
     excludeDisallowedPokemon: boolean,
     minNumberOfPokemon = 1,
     invertQuery = false,

src/data/mystery-encounters/mystery-encounters.ts

@@ -1,4 +1,4 @@
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
 import { MysteryEncounterType } from "#enums/mystery-encounter-type";
 import { DarkDealEncounter } from "./encounters/dark-deal-encounter";
 import { DepartmentStoreSaleEncounter } from "./encounters/department-store-sale-encounter";
@@ -71,44 +71,44 @@ export const AVERAGE_ENCOUNTERS_PER_RUN_TARGET = 12;
 export const ANTI_VARIANCE_WEIGHT_MODIFIER = 15;
 
 export const EXTREME_ENCOUNTER_BIOMES = [
-  Biome.SEA,
+  BiomeId.SEA,
-  Biome.SEABED,
+  BiomeId.SEABED,
-  Biome.BADLANDS,
+  BiomeId.BADLANDS,
-  Biome.DESERT,
+  BiomeId.DESERT,
-  Biome.ICE_CAVE,
+  BiomeId.ICE_CAVE,
-  Biome.VOLCANO,
+  BiomeId.VOLCANO,
-  Biome.WASTELAND,
+  BiomeId.WASTELAND,
-  Biome.ABYSS,
+  BiomeId.ABYSS,
-  Biome.SPACE,
+  BiomeId.SPACE,
-  Biome.END,
+  BiomeId.END,
 ];
 
 export const NON_EXTREME_ENCOUNTER_BIOMES = [
-  Biome.TOWN,
+  BiomeId.TOWN,
-  Biome.PLAINS,
+  BiomeId.PLAINS,
-  Biome.GRASS,
+  BiomeId.GRASS,
-  Biome.TALL_GRASS,
+  BiomeId.TALL_GRASS,
-  Biome.METROPOLIS,
+  BiomeId.METROPOLIS,
-  Biome.FOREST,
+  BiomeId.FOREST,
-  Biome.SWAMP,
+  BiomeId.SWAMP,
-  Biome.BEACH,
+  BiomeId.BEACH,
-  Biome.LAKE,
+  BiomeId.LAKE,
-  Biome.MOUNTAIN,
+  BiomeId.MOUNTAIN,
-  Biome.CAVE,
+  BiomeId.CAVE,
-  Biome.MEADOW,
+  BiomeId.MEADOW,
-  Biome.POWER_PLANT,
+  BiomeId.POWER_PLANT,
-  Biome.GRAVEYARD,
+  BiomeId.GRAVEYARD,
-  Biome.DOJO,
+  BiomeId.DOJO,
-  Biome.FACTORY,
+  BiomeId.FACTORY,
-  Biome.RUINS,
+  BiomeId.RUINS,
-  Biome.CONSTRUCTION_SITE,
+  BiomeId.CONSTRUCTION_SITE,
-  Biome.JUNGLE,
+  BiomeId.JUNGLE,
-  Biome.FAIRY_CAVE,
+  BiomeId.FAIRY_CAVE,
-  Biome.TEMPLE,
+  BiomeId.TEMPLE,
-  Biome.SLUM,
+  BiomeId.SLUM,
-  Biome.SNOWY_FOREST,
+  BiomeId.SNOWY_FOREST,
-  Biome.ISLAND,
+  BiomeId.ISLAND,
-  Biome.LABORATORY,
+  BiomeId.LABORATORY,
 ];
 
 /**
@@ -120,55 +120,55 @@ export const NON_EXTREME_ENCOUNTER_BIOMES = [
  * + ICE_CAVE
  */
 export const HUMAN_TRANSITABLE_BIOMES = [
-  Biome.TOWN,
+  BiomeId.TOWN,
-  Biome.PLAINS,
+  BiomeId.PLAINS,
-  Biome.GRASS,
+  BiomeId.GRASS,
-  Biome.TALL_GRASS,
+  BiomeId.TALL_GRASS,
-  Biome.METROPOLIS,
+  BiomeId.METROPOLIS,
-  Biome.FOREST,
+  BiomeId.FOREST,
-  Biome.SWAMP,
+  BiomeId.SWAMP,
-  Biome.BEACH,
+  BiomeId.BEACH,
-  Biome.LAKE,
+  BiomeId.LAKE,
-  Biome.MOUNTAIN,
+  BiomeId.MOUNTAIN,
-  Biome.BADLANDS,
+  BiomeId.BADLANDS,
-  Biome.CAVE,
+  BiomeId.CAVE,
-  Biome.DESERT,
+  BiomeId.DESERT,
-  Biome.ICE_CAVE,
+  BiomeId.ICE_CAVE,
-  Biome.MEADOW,
+  BiomeId.MEADOW,
-  Biome.POWER_PLANT,
+  BiomeId.POWER_PLANT,
-  Biome.GRAVEYARD,
+  BiomeId.GRAVEYARD,
-  Biome.DOJO,
+  BiomeId.DOJO,
-  Biome.FACTORY,
+  BiomeId.FACTORY,
-  Biome.RUINS,
+  BiomeId.RUINS,
-  Biome.CONSTRUCTION_SITE,
+  BiomeId.CONSTRUCTION_SITE,
-  Biome.JUNGLE,
+  BiomeId.JUNGLE,
-  Biome.FAIRY_CAVE,
+  BiomeId.FAIRY_CAVE,
-  Biome.TEMPLE,
+  BiomeId.TEMPLE,
-  Biome.SLUM,
+  BiomeId.SLUM,
-  Biome.SNOWY_FOREST,
+  BiomeId.SNOWY_FOREST,
-  Biome.ISLAND,
+  BiomeId.ISLAND,
-  Biome.LABORATORY,
+  BiomeId.LABORATORY,
 ];
 
 /**
  * Places where you could expect a town or city, some form of large civilization
  */
 export const CIVILIZATION_ENCOUNTER_BIOMES = [
-  Biome.TOWN,
+  BiomeId.TOWN,
-  Biome.PLAINS,
+  BiomeId.PLAINS,
-  Biome.GRASS,
+  BiomeId.GRASS,
-  Biome.TALL_GRASS,
+  BiomeId.TALL_GRASS,
-  Biome.METROPOLIS,
+  BiomeId.METROPOLIS,
-  Biome.BEACH,
+  BiomeId.BEACH,
-  Biome.LAKE,
+  BiomeId.LAKE,
-  Biome.MEADOW,
+  BiomeId.MEADOW,
-  Biome.POWER_PLANT,
+  BiomeId.POWER_PLANT,
-  Biome.GRAVEYARD,
+  BiomeId.GRAVEYARD,
-  Biome.DOJO,
+  BiomeId.DOJO,
-  Biome.FACTORY,
+  BiomeId.FACTORY,
-  Biome.CONSTRUCTION_SITE,
+  BiomeId.CONSTRUCTION_SITE,
-  Biome.SLUM,
+  BiomeId.SLUM,
-  Biome.ISLAND,
+  BiomeId.ISLAND,
 ];
 
 export const allMysteryEncounters: {
@@ -224,41 +224,41 @@ const anyBiomeEncounters: MysteryEncounterType[] = [
  * Adding specific Encounters to the mysteryEncountersByBiome map is for specific cases and special circumstances
  * that biome groups do not cover
  */
-export const mysteryEncountersByBiome = new Map<Biome, MysteryEncounterType[]>([
+export const mysteryEncountersByBiome = new Map<BiomeId, MysteryEncounterType[]>([
-  [Biome.TOWN, []],
+  [BiomeId.TOWN, []],
-  [Biome.PLAINS, [MysteryEncounterType.SLUMBERING_SNORLAX]],
+  [BiomeId.PLAINS, [MysteryEncounterType.SLUMBERING_SNORLAX]],
-  [Biome.GRASS, [MysteryEncounterType.SLUMBERING_SNORLAX, MysteryEncounterType.ABSOLUTE_AVARICE]],
+  [BiomeId.GRASS, [MysteryEncounterType.SLUMBERING_SNORLAX, MysteryEncounterType.ABSOLUTE_AVARICE]],
-  [Biome.TALL_GRASS, [MysteryEncounterType.SLUMBERING_SNORLAX, MysteryEncounterType.ABSOLUTE_AVARICE]],
+  [BiomeId.TALL_GRASS, [MysteryEncounterType.SLUMBERING_SNORLAX, MysteryEncounterType.ABSOLUTE_AVARICE]],
-  [Biome.METROPOLIS, []],
+  [BiomeId.METROPOLIS, []],
-  [Biome.FOREST, [MysteryEncounterType.SAFARI_ZONE, MysteryEncounterType.ABSOLUTE_AVARICE]],
+  [BiomeId.FOREST, [MysteryEncounterType.SAFARI_ZONE, MysteryEncounterType.ABSOLUTE_AVARICE]],
-  [Biome.SEA, [MysteryEncounterType.LOST_AT_SEA]],
+  [BiomeId.SEA, [MysteryEncounterType.LOST_AT_SEA]],
-  [Biome.SWAMP, [MysteryEncounterType.SAFARI_ZONE]],
+  [BiomeId.SWAMP, [MysteryEncounterType.SAFARI_ZONE]],
-  [Biome.BEACH, []],
+  [BiomeId.BEACH, []],
-  [Biome.LAKE, []],
+  [BiomeId.LAKE, []],
-  [Biome.SEABED, []],
+  [BiomeId.SEABED, []],
-  [Biome.MOUNTAIN, []],
+  [BiomeId.MOUNTAIN, []],
-  [Biome.BADLANDS, [MysteryEncounterType.DANCING_LESSONS]],
+  [BiomeId.BADLANDS, [MysteryEncounterType.DANCING_LESSONS]],
-  [Biome.CAVE, [MysteryEncounterType.THE_STRONG_STUFF]],
+  [BiomeId.CAVE, [MysteryEncounterType.THE_STRONG_STUFF]],
-  [Biome.DESERT, [MysteryEncounterType.DANCING_LESSONS]],
+  [BiomeId.DESERT, [MysteryEncounterType.DANCING_LESSONS]],
-  [Biome.ICE_CAVE, []],
+  [BiomeId.ICE_CAVE, []],
-  [Biome.MEADOW, []],
+  [BiomeId.MEADOW, []],
-  [Biome.POWER_PLANT, []],
+  [BiomeId.POWER_PLANT, []],
-  [Biome.VOLCANO, [MysteryEncounterType.FIERY_FALLOUT, MysteryEncounterType.DANCING_LESSONS]],
+  [BiomeId.VOLCANO, [MysteryEncounterType.FIERY_FALLOUT, MysteryEncounterType.DANCING_LESSONS]],
-  [Biome.GRAVEYARD, []],
+  [BiomeId.GRAVEYARD, []],
-  [Biome.DOJO, []],
+  [BiomeId.DOJO, []],
-  [Biome.FACTORY, []],
+  [BiomeId.FACTORY, []],
-  [Biome.RUINS, []],
+  [BiomeId.RUINS, []],
-  [Biome.WASTELAND, [MysteryEncounterType.DANCING_LESSONS]],
+  [BiomeId.WASTELAND, [MysteryEncounterType.DANCING_LESSONS]],
-  [Biome.ABYSS, [MysteryEncounterType.DANCING_LESSONS]],
+  [BiomeId.ABYSS, [MysteryEncounterType.DANCING_LESSONS]],
-  [Biome.SPACE, [MysteryEncounterType.THE_EXPERT_POKEMON_BREEDER]],
+  [BiomeId.SPACE, [MysteryEncounterType.THE_EXPERT_POKEMON_BREEDER]],
-  [Biome.CONSTRUCTION_SITE, []],
+  [BiomeId.CONSTRUCTION_SITE, []],
-  [Biome.JUNGLE, [MysteryEncounterType.SAFARI_ZONE]],
+  [BiomeId.JUNGLE, [MysteryEncounterType.SAFARI_ZONE]],
-  [Biome.FAIRY_CAVE, []],
+  [BiomeId.FAIRY_CAVE, []],
-  [Biome.TEMPLE, []],
+  [BiomeId.TEMPLE, []],
-  [Biome.SLUM, []],
+  [BiomeId.SLUM, []],
-  [Biome.SNOWY_FOREST, []],
+  [BiomeId.SNOWY_FOREST, []],
-  [Biome.ISLAND, []],
+  [BiomeId.ISLAND, []],
-  [Biome.LABORATORY, []],
+  [BiomeId.LABORATORY, []],
 ]);
 
 export function initMysteryEncounters() {

src/data/mystery-encounters/requirements/can-learn-move-requirement.ts

@@ -1,4 +1,4 @@
-import type { Moves } from "#app/enums/moves";
+import type { MoveId } from "#enums/move-id";
 import type { PlayerPokemon } from "#app/field/pokemon";
 import { PokemonMove } from "#app/field/pokemon";
 import { isNullOrUndefined } from "#app/utils/common";
@@ -21,13 +21,13 @@ export interface CanLearnMoveRequirementOptions {
  * Requires that a pokemon can learn a specific move/moveset.
  */
 export class CanLearnMoveRequirement extends EncounterPokemonRequirement {
-  private readonly requiredMoves: Moves[];
+  private readonly requiredMoves: MoveId[];
   private readonly excludeLevelMoves?: boolean;
   private readonly excludeTmMoves?: boolean;
   private readonly excludeEggMoves?: boolean;
   private readonly includeFainted?: boolean;
 
-  constructor(requiredMoves: Moves | Moves[], options: CanLearnMoveRequirementOptions = {}) {
+  constructor(requiredMoves: MoveId | MoveId[], options: CanLearnMoveRequirementOptions = {}) {
     super();
     this.requiredMoves = Array.isArray(requiredMoves) ? requiredMoves : [requiredMoves];
 
@@ -69,12 +69,12 @@ export class CanLearnMoveRequirement extends EncounterPokemonRequirement {
     return ["requiredMoves", this.requiredMoves.map(m => new PokemonMove(m).getName()).join(", ")];
   }
 
-  private getPokemonLevelMoves(pkm: PlayerPokemon): Moves[] {
+  private getPokemonLevelMoves(pkm: PlayerPokemon): MoveId[] {
     return pkm.getLevelMoves().map(([_level, move]) => move);
   }
 
-  private getAllPokemonMoves(pkm: PlayerPokemon): Moves[] {
+  private getAllPokemonMoves(pkm: PlayerPokemon): MoveId[] {
-    const allPokemonMoves: Moves[] = [];
+    const allPokemonMoves: MoveId[] = [];
 
     if (!this.excludeLevelMoves) {
       allPokemonMoves.push(...(this.getPokemonLevelMoves(pkm) ?? []));

src/data/mystery-encounters/requirements/requirement-groups.ts

@@ -1,130 +1,137 @@
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 
 /**
  * Moves that "steal" things
  */
-export const STEALING_MOVES = [Moves.PLUCK, Moves.COVET, Moves.KNOCK_OFF, Moves.THIEF, Moves.TRICK, Moves.SWITCHEROO];
+export const STEALING_MOVES = [
+  MoveId.PLUCK,
+  MoveId.COVET,
+  MoveId.KNOCK_OFF,
+  MoveId.THIEF,
+  MoveId.TRICK,
+  MoveId.SWITCHEROO,
+];
 
 /**
  * Moves that "charm" someone
  */
 export const CHARMING_MOVES = [
-  Moves.CHARM,
+  MoveId.CHARM,
-  Moves.FLATTER,
+  MoveId.FLATTER,
-  Moves.DRAGON_CHEER,
+  MoveId.DRAGON_CHEER,
-  Moves.ALLURING_VOICE,
+  MoveId.ALLURING_VOICE,
-  Moves.ATTRACT,
+  MoveId.ATTRACT,
-  Moves.SWEET_SCENT,
+  MoveId.SWEET_SCENT,
-  Moves.CAPTIVATE,
+  MoveId.CAPTIVATE,
-  Moves.AROMATIC_MIST,
+  MoveId.AROMATIC_MIST,
 ];
 
 /**
  * Moves for the Dancer ability
  */
 export const DANCING_MOVES = [
-  Moves.AQUA_STEP,
+  MoveId.AQUA_STEP,
-  Moves.CLANGOROUS_SOUL,
+  MoveId.CLANGOROUS_SOUL,
-  Moves.DRAGON_DANCE,
+  MoveId.DRAGON_DANCE,
-  Moves.FEATHER_DANCE,
+  MoveId.FEATHER_DANCE,
-  Moves.FIERY_DANCE,
+  MoveId.FIERY_DANCE,
-  Moves.LUNAR_DANCE,
+  MoveId.LUNAR_DANCE,
-  Moves.PETAL_DANCE,
+  MoveId.PETAL_DANCE,
-  Moves.REVELATION_DANCE,
+  MoveId.REVELATION_DANCE,
-  Moves.QUIVER_DANCE,
+  MoveId.QUIVER_DANCE,
-  Moves.SWORDS_DANCE,
+  MoveId.SWORDS_DANCE,
-  Moves.TEETER_DANCE,
+  MoveId.TEETER_DANCE,
-  Moves.VICTORY_DANCE,
+  MoveId.VICTORY_DANCE,
 ];
 
 /**
  * Moves that can distract someone/something
  */
 export const DISTRACTION_MOVES = [
-  Moves.FAKE_OUT,
+  MoveId.FAKE_OUT,
-  Moves.FOLLOW_ME,
+  MoveId.FOLLOW_ME,
-  Moves.TAUNT,
+  MoveId.TAUNT,
-  Moves.ROAR,
+  MoveId.ROAR,
-  Moves.TELEPORT,
+  MoveId.TELEPORT,
-  Moves.CHARM,
+  MoveId.CHARM,
-  Moves.FAKE_TEARS,
+  MoveId.FAKE_TEARS,
-  Moves.TICKLE,
+  MoveId.TICKLE,
-  Moves.CAPTIVATE,
+  MoveId.CAPTIVATE,
-  Moves.RAGE_POWDER,
+  MoveId.RAGE_POWDER,
-  Moves.SUBSTITUTE,
+  MoveId.SUBSTITUTE,
-  Moves.SHED_TAIL,
+  MoveId.SHED_TAIL,
 ];
 
 /**
  * Moves that protect in some way
  */
 export const PROTECTING_MOVES = [
-  Moves.PROTECT,
+  MoveId.PROTECT,
-  Moves.WIDE_GUARD,
+  MoveId.WIDE_GUARD,
-  Moves.MAX_GUARD,
+  MoveId.MAX_GUARD,
-  Moves.SAFEGUARD,
+  MoveId.SAFEGUARD,
-  Moves.REFLECT,
+  MoveId.REFLECT,
-  Moves.BARRIER,
+  MoveId.BARRIER,
-  Moves.QUICK_GUARD,
+  MoveId.QUICK_GUARD,
-  Moves.FLOWER_SHIELD,
+  MoveId.FLOWER_SHIELD,
-  Moves.KINGS_SHIELD,
+  MoveId.KINGS_SHIELD,
-  Moves.CRAFTY_SHIELD,
+  MoveId.CRAFTY_SHIELD,
-  Moves.SPIKY_SHIELD,
+  MoveId.SPIKY_SHIELD,
-  Moves.OBSTRUCT,
+  MoveId.OBSTRUCT,
-  Moves.DETECT,
+  MoveId.DETECT,
 ];
 
 /**
  * Moves that (loosely) can be used to trap/rob someone
  */
 export const EXTORTION_MOVES = [
-  Moves.BIND,
+  MoveId.BIND,
-  Moves.CLAMP,
+  MoveId.CLAMP,
-  Moves.INFESTATION,
+  MoveId.INFESTATION,
-  Moves.SAND_TOMB,
+  MoveId.SAND_TOMB,
-  Moves.SNAP_TRAP,
+  MoveId.SNAP_TRAP,
-  Moves.THUNDER_CAGE,
+  MoveId.THUNDER_CAGE,
-  Moves.WRAP,
+  MoveId.WRAP,
-  Moves.SPIRIT_SHACKLE,
+  MoveId.SPIRIT_SHACKLE,
-  Moves.MEAN_LOOK,
+  MoveId.MEAN_LOOK,
-  Moves.JAW_LOCK,
+  MoveId.JAW_LOCK,
-  Moves.BLOCK,
+  MoveId.BLOCK,
-  Moves.SPIDER_WEB,
+  MoveId.SPIDER_WEB,
-  Moves.ANCHOR_SHOT,
+  MoveId.ANCHOR_SHOT,
-  Moves.OCTOLOCK,
+  MoveId.OCTOLOCK,
-  Moves.PURSUIT,
+  MoveId.PURSUIT,
-  Moves.CONSTRICT,
+  MoveId.CONSTRICT,
-  Moves.BEAT_UP,
+  MoveId.BEAT_UP,
-  Moves.COIL,
+  MoveId.COIL,
-  Moves.WRING_OUT,
+  MoveId.WRING_OUT,
-  Moves.STRING_SHOT,
+  MoveId.STRING_SHOT,
 ];
 
 /**
  * Abilities that (loosely) can be used to trap/rob someone
  */
 export const EXTORTION_ABILITIES = [
-  Abilities.INTIMIDATE,
+  AbilityId.INTIMIDATE,
-  Abilities.ARENA_TRAP,
+  AbilityId.ARENA_TRAP,
-  Abilities.SHADOW_TAG,
+  AbilityId.SHADOW_TAG,
-  Abilities.SUCTION_CUPS,
+  AbilityId.SUCTION_CUPS,
-  Abilities.STICKY_HOLD,
+  AbilityId.STICKY_HOLD,
 ];
 
 /**
  * Abilities that signify resistance to fire
  */
 export const FIRE_RESISTANT_ABILITIES = [
-  Abilities.FLAME_BODY,
+  AbilityId.FLAME_BODY,
-  Abilities.FLASH_FIRE,
+  AbilityId.FLASH_FIRE,
-  Abilities.WELL_BAKED_BODY,
+  AbilityId.WELL_BAKED_BODY,
-  Abilities.HEATPROOF,
+  AbilityId.HEATPROOF,
-  Abilities.THERMAL_EXCHANGE,
+  AbilityId.THERMAL_EXCHANGE,
-  Abilities.THICK_FAT,
+  AbilityId.THICK_FAT,
-  Abilities.WATER_BUBBLE,
+  AbilityId.WATER_BUBBLE,
-  Abilities.MAGMA_ARMOR,
+  AbilityId.MAGMA_ARMOR,
-  Abilities.WATER_VEIL,
+  AbilityId.WATER_VEIL,
-  Abilities.STEAM_ENGINE,
+  AbilityId.STEAM_ENGINE,
-  Abilities.PRIMORDIAL_SEA,
+  AbilityId.PRIMORDIAL_SEA,
 ];

src/data/mystery-encounters/utils/encounter-phase-utils.ts

@@ -33,13 +33,13 @@ import { PartyUiMode } from "#app/ui/party-ui-handler";
 import { UiMode } from "#enums/ui-mode";
 import { isNullOrUndefined, randSeedInt, randomString, randSeedItem } from "#app/utils/common";
 import type { BattlerTagType } from "#enums/battler-tag-type";
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
 import type { TrainerType } from "#enums/trainer-type";
 import i18next from "i18next";
 import Trainer, { TrainerVariant } from "#app/field/trainer";
 import type { Gender } from "#app/data/gender";
 import type { Nature } from "#enums/nature";
-import type { Moves } from "#enums/moves";
+import type { MoveId } from "#enums/move-id";
 import { initMoveAnim, loadMoveAnimAssets } from "#app/data/battle-anims";
 import { MysteryEncounterMode } from "#enums/mystery-encounter-mode";
 import { Status } from "#app/data/status-effect";
@@ -106,7 +106,7 @@ export interface EnemyPokemonConfig {
   level?: number;
   gender?: Gender;
   passive?: boolean;
-  moveSet?: Moves[];
+  moveSet?: MoveId[];
   nature?: Nature;
   ivs?: [number, number, number, number, number, number];
   shiny?: boolean;
@@ -460,7 +460,7 @@ export async function initBattleWithEnemyConfig(partyConfig: EnemyPartyConfig):
  * This promise does not need to be awaited on if called in an encounter onInit (will just load lazily)
  * @param moves
  */
-export function loadCustomMovesForEncounter(moves: Moves | Moves[]) {
+export function loadCustomMovesForEncounter(moves: MoveId | MoveId[]) {
   moves = Array.isArray(moves) ? moves : [moves];
   return Promise.all(moves.map(move => initMoveAnim(move))).then(() => loadMoveAnimAssets(moves));
 }
@@ -1088,16 +1088,16 @@ export function getRandomEncounterSpecies(level: number, isBoss = false, rerollH
 export function calculateMEAggregateStats(baseSpawnWeight: number) {
   const numRuns = 1000;
   let run = 0;
-  const biomes = Object.keys(Biome).filter(key => Number.isNaN(Number(key)));
+  const biomes = Object.keys(BiomeId).filter(key => Number.isNaN(Number(key)));
   const alwaysPickTheseBiomes = [
-    Biome.ISLAND,
+    BiomeId.ISLAND,
-    Biome.ABYSS,
+    BiomeId.ABYSS,
-    Biome.WASTELAND,
+    BiomeId.WASTELAND,
-    Biome.FAIRY_CAVE,
+    BiomeId.FAIRY_CAVE,
-    Biome.TEMPLE,
+    BiomeId.TEMPLE,
-    Biome.LABORATORY,
+    BiomeId.LABORATORY,
-    Biome.SPACE,
+    BiomeId.SPACE,
-    Biome.WASTELAND,
+    BiomeId.WASTELAND,
   ];
 
   const calculateNumEncounters = (): any[] => {
@@ -1106,7 +1106,7 @@ export function calculateMEAggregateStats(baseSpawnWeight: number) {
     let mostRecentEncounterWave = 0;
     const encountersByBiome = new Map<string, number>(biomes.map(b => [b, 0]));
     const validMEfloorsByBiome = new Map<string, number>(biomes.map(b => [b, 0]));
-    let currentBiome = Biome.TOWN;
+    let currentBiome = BiomeId.TOWN;
     let currentArena = globalScene.newArena(currentBiome);
     globalScene.setSeed(randomString(24));
     globalScene.resetSeed();
@@ -1119,9 +1119,9 @@ export function calculateMEAggregateStats(baseSpawnWeight: number) {
       // New biome
       if (i % 10 === 1) {
         if (Array.isArray(biomeLinks[currentBiome])) {
-          let biomes: Biome[];
+          let biomes: BiomeId[];
           globalScene.executeWithSeedOffset(() => {
-            biomes = (biomeLinks[currentBiome] as (Biome | [Biome, number])[])
+            biomes = (biomeLinks[currentBiome] as (BiomeId | [BiomeId, number])[])
               .filter(b => {
                 return !Array.isArray(b) || !randSeedInt(b[1]);
               })
@@ -1136,10 +1136,10 @@ export function calculateMEAggregateStats(baseSpawnWeight: number) {
             }
           }
         } else if (biomeLinks.hasOwnProperty(currentBiome)) {
-          currentBiome = biomeLinks[currentBiome] as Biome;
+          currentBiome = biomeLinks[currentBiome] as BiomeId;
         } else {
           if (!(i % 50)) {
-            currentBiome = Biome.END;
+            currentBiome = BiomeId.END;
           } else {
             currentBiome = globalScene.generateRandomBiome(i);
           }
@@ -1161,7 +1161,7 @@ export function calculateMEAggregateStats(baseSpawnWeight: number) {
       // Otherwise, roll encounter
 
       const roll = randSeedInt(256);
-      validMEfloorsByBiome.set(Biome[currentBiome], (validMEfloorsByBiome.get(Biome[currentBiome]) ?? 0) + 1);
+      validMEfloorsByBiome.set(BiomeId[currentBiome], (validMEfloorsByBiome.get(BiomeId[currentBiome]) ?? 0) + 1);
 
       // If total number of encounters is lower than expected for the run, slightly favor a new encounter
       // Do the reverse as well
@@ -1197,7 +1197,7 @@ export function calculateMEAggregateStats(baseSpawnWeight: number) {
             : tierValue > rareThreshold
               ? ++numEncounters[2]
               : ++numEncounters[3];
-        encountersByBiome.set(Biome[currentBiome], (encountersByBiome.get(Biome[currentBiome]) ?? 0) + 1);
+        encountersByBiome.set(BiomeId[currentBiome], (encountersByBiome.get(BiomeId[currentBiome]) ?? 0) + 1);
       } else {
         encounterRate += WEIGHT_INCREMENT_ON_SPAWN_MISS;
       }

src/data/mystery-encounters/utils/encounter-pokemon-utils.ts

@@ -17,7 +17,7 @@ import { achvs } from "#app/system/achv";
 import { UiMode } from "#enums/ui-mode";
 import type { PartyOption } from "#app/ui/party-ui-handler";
 import { PartyUiMode } from "#app/ui/party-ui-handler";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import type { PokemonType } from "#enums/pokemon-type";
 import type PokemonSpecies from "#app/data/pokemon-species";
 import { getPokemonSpecies } from "#app/data/pokemon-species";
@@ -35,7 +35,7 @@ import type { PermanentStat } from "#enums/stat";
 import { VictoryPhase } from "#app/phases/victory-phase";
 import { SummaryUiMode } from "#app/ui/summary-ui-handler";
 import { CustomPokemonData } from "#app/data/custom-pokemon-data";
-import type { Abilities } from "#enums/abilities";
+import type { AbilityId } from "#enums/ability-id";
 import type { PokeballType } from "#enums/pokeball";
 import { StatusEffect } from "#enums/status-effect";
 
@@ -51,7 +51,7 @@ export const STANDARD_ENCOUNTER_BOOSTED_LEVEL_MODIFIER = 1;
  * @param variant
  */
 export function getSpriteKeysFromSpecies(
-  species: Species,
+  species: SpeciesId,
   female?: boolean,
   formIndex?: number,
   shiny?: boolean,
@@ -247,17 +247,17 @@ export function getHighestStatTotalPlayerPokemon(isAllowed = false, isFainted =
  */
 export function getRandomSpeciesByStarterCost(
   starterTiers: number | [number, number],
-  excludedSpecies?: Species[],
+  excludedSpecies?: SpeciesId[],
   types?: PokemonType[],
   allowSubLegendary = true,
   allowLegendary = true,
   allowMythical = true,
-): Species {
+): SpeciesId {
   let min = Array.isArray(starterTiers) ? starterTiers[0] : starterTiers;
   let max = Array.isArray(starterTiers) ? starterTiers[1] : starterTiers;
 
   let filteredSpecies: [PokemonSpecies, number][] = Object.keys(speciesStarterCosts)
-    .map(s => [Number.parseInt(s) as Species, speciesStarterCosts[s] as number])
+    .map(s => [Number.parseInt(s) as SpeciesId, speciesStarterCosts[s] as number])
     .filter(s => {
       const pokemonSpecies = getPokemonSpecies(s[0]);
       return (
@@ -294,7 +294,7 @@ export function getRandomSpeciesByStarterCost(
     return Phaser.Math.RND.shuffle(tryFilterStarterTiers)[index][0].speciesId;
   }
 
-  return Species.BULBASAUR;
+  return SpeciesId.BULBASAUR;
 }
 
 /**
@@ -903,34 +903,34 @@ export function doPlayerFlee(pokemon: EnemyPokemon): Promise<void> {
 /**
  * Bug Species and their corresponding weights
  */
-const GOLDEN_BUG_NET_SPECIES_POOL: [Species, number][] = [
+const GOLDEN_BUG_NET_SPECIES_POOL: [SpeciesId, number][] = [
-  [Species.SCYTHER, 40],
+  [SpeciesId.SCYTHER, 40],
-  [Species.SCIZOR, 40],
+  [SpeciesId.SCIZOR, 40],
-  [Species.KLEAVOR, 40],
+  [SpeciesId.KLEAVOR, 40],
-  [Species.PINSIR, 40],
+  [SpeciesId.PINSIR, 40],
-  [Species.HERACROSS, 40],
+  [SpeciesId.HERACROSS, 40],
-  [Species.YANMA, 40],
+  [SpeciesId.YANMA, 40],
-  [Species.YANMEGA, 40],
+  [SpeciesId.YANMEGA, 40],
-  [Species.SHUCKLE, 40],
+  [SpeciesId.SHUCKLE, 40],
-  [Species.ANORITH, 40],
+  [SpeciesId.ANORITH, 40],
-  [Species.ARMALDO, 40],
+  [SpeciesId.ARMALDO, 40],
-  [Species.ESCAVALIER, 40],
+  [SpeciesId.ESCAVALIER, 40],
-  [Species.ACCELGOR, 40],
+  [SpeciesId.ACCELGOR, 40],
-  [Species.JOLTIK, 40],
+  [SpeciesId.JOLTIK, 40],
-  [Species.GALVANTULA, 40],
+  [SpeciesId.GALVANTULA, 40],
-  [Species.DURANT, 40],
+  [SpeciesId.DURANT, 40],
-  [Species.LARVESTA, 40],
+  [SpeciesId.LARVESTA, 40],
-  [Species.VOLCARONA, 40],
+  [SpeciesId.VOLCARONA, 40],
-  [Species.DEWPIDER, 40],
+  [SpeciesId.DEWPIDER, 40],
-  [Species.ARAQUANID, 40],
+  [SpeciesId.ARAQUANID, 40],
-  [Species.WIMPOD, 40],
+  [SpeciesId.WIMPOD, 40],
-  [Species.GOLISOPOD, 40],
+  [SpeciesId.GOLISOPOD, 40],
-  [Species.SIZZLIPEDE, 40],
+  [SpeciesId.SIZZLIPEDE, 40],
-  [Species.CENTISKORCH, 40],
+  [SpeciesId.CENTISKORCH, 40],
-  [Species.NYMBLE, 40],
+  [SpeciesId.NYMBLE, 40],
-  [Species.LOKIX, 40],
+  [SpeciesId.LOKIX, 40],
-  [Species.BUZZWOLE, 1],
+  [SpeciesId.BUZZWOLE, 1],
-  [Species.PHEROMOSA, 1],
+  [SpeciesId.PHEROMOSA, 1],
 ];
 
 /**
@@ -951,7 +951,7 @@ export function getGoldenBugNetSpecies(level: number): PokemonSpecies {
   }
 
   // Defaults to Scyther
-  return getPokemonSpecies(Species.SCYTHER);
+  return getPokemonSpecies(SpeciesId.SCYTHER);
 }
 
 /**
@@ -1024,7 +1024,7 @@ export function isPokemonValidForEncounterOptionSelection(
  * Permanently overrides the ability (not passive) of a pokemon.
  * If the pokemon is a fusion, instead overrides the fused pokemon's ability.
  */
-export function applyAbilityOverrideToPokemon(pokemon: Pokemon, ability: Abilities) {
+export function applyAbilityOverrideToPokemon(pokemon: Pokemon, ability: AbilityId) {
   if (pokemon.isFusion()) {
     if (!pokemon.fusionCustomPokemonData) {
       pokemon.fusionCustomPokemonData = new CustomPokemonData();

src/data/trainers/evil-admin-trainer-pools.ts

@@ -1,438 +1,443 @@
 import type { TrainerTierPools } from "#app/data/trainers/typedefs";
 import { TrainerPoolTier } from "#enums/trainer-pool-tier";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 
 /** Team Rocket's admin trainer pool. */
 const ROCKET: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.RATTATA,
+    SpeciesId.RATTATA,
-    Species.SPEAROW,
+    SpeciesId.SPEAROW,
-    Species.EKANS,
+    SpeciesId.EKANS,
-    Species.VILEPLUME,
+    SpeciesId.VILEPLUME,
-    Species.DIGLETT,
+    SpeciesId.DIGLETT,
-    Species.GROWLITHE,
+    SpeciesId.GROWLITHE,
-    Species.GRIMER,
+    SpeciesId.GRIMER,
-    Species.DROWZEE,
+    SpeciesId.DROWZEE,
-    Species.VOLTORB,
+    SpeciesId.VOLTORB,
-    Species.EXEGGCUTE,
+    SpeciesId.EXEGGCUTE,
-    Species.CUBONE,
+    SpeciesId.CUBONE,
-    Species.KOFFING,
+    SpeciesId.KOFFING,
-    Species.MAGIKARP,
+    SpeciesId.MAGIKARP,
-    Species.ZUBAT,
+    SpeciesId.ZUBAT,
-    Species.ONIX,
+    SpeciesId.ONIX,
-    Species.HOUNDOUR,
+    SpeciesId.HOUNDOUR,
-    Species.MURKROW,
+    SpeciesId.MURKROW,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.ABRA,
+    SpeciesId.ABRA,
-    Species.GASTLY,
+    SpeciesId.GASTLY,
-    Species.OMANYTE,
+    SpeciesId.OMANYTE,
-    Species.KABUTO,
+    SpeciesId.KABUTO,
-    Species.PORYGON,
+    SpeciesId.PORYGON,
-    Species.MANKEY,
+    SpeciesId.MANKEY,
-    Species.SCYTHER,
+    SpeciesId.SCYTHER,
-    Species.ELEKID,
+    SpeciesId.ELEKID,
-    Species.MAGBY,
+    SpeciesId.MAGBY,
-    Species.ALOLA_SANDSHREW,
+    SpeciesId.ALOLA_SANDSHREW,
-    Species.ALOLA_MEOWTH,
+    SpeciesId.ALOLA_MEOWTH,
-    Species.ALOLA_GEODUDE,
+    SpeciesId.ALOLA_GEODUDE,
-    Species.ALOLA_GRIMER,
+    SpeciesId.ALOLA_GRIMER,
-    Species.PALDEA_TAUROS,
+    SpeciesId.PALDEA_TAUROS,
   ],
-  [TrainerPoolTier.RARE]: [Species.DRATINI, Species.LARVITAR],
+  [TrainerPoolTier.RARE]: [SpeciesId.DRATINI, SpeciesId.LARVITAR],
 };
 
 /** Team Magma's admin trainer pool */
 const MAGMA: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.DIGLETT,
+    SpeciesId.DIGLETT,
-    Species.GROWLITHE,
+    SpeciesId.GROWLITHE,
-    Species.VULPIX,
+    SpeciesId.VULPIX,
-    Species.KOFFING,
+    SpeciesId.KOFFING,
-    Species.RHYHORN,
+    SpeciesId.RHYHORN,
-    Species.SLUGMA,
+    SpeciesId.SLUGMA,
-    Species.HOUNDOUR,
+    SpeciesId.HOUNDOUR,
-    Species.POOCHYENA,
+    SpeciesId.POOCHYENA,
-    Species.TORKOAL,
+    SpeciesId.TORKOAL,
-    Species.ZANGOOSE,
+    SpeciesId.ZANGOOSE,
-    Species.SOLROCK,
+    SpeciesId.SOLROCK,
-    Species.BALTOY,
+    SpeciesId.BALTOY,
-    Species.ROLYCOLY,
+    SpeciesId.ROLYCOLY,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.MAGBY,
+    SpeciesId.MAGBY,
-    Species.TRAPINCH,
+    SpeciesId.TRAPINCH,
-    Species.LILEEP,
+    SpeciesId.LILEEP,
-    Species.ANORITH,
+    SpeciesId.ANORITH,
-    Species.GOLETT,
+    SpeciesId.GOLETT,
-    Species.FLETCHLING,
+    SpeciesId.FLETCHLING,
-    Species.SALANDIT,
+    SpeciesId.SALANDIT,
-    Species.TURTONATOR,
+    SpeciesId.TURTONATOR,
-    Species.TOEDSCOOL,
+    SpeciesId.TOEDSCOOL,
-    Species.CAPSAKID,
+    SpeciesId.CAPSAKID,
-    Species.HISUI_GROWLITHE,
+    SpeciesId.HISUI_GROWLITHE,
   ],
-  [TrainerPoolTier.RARE]: [Species.CHARCADET, Species.ARON],
+  [TrainerPoolTier.RARE]: [SpeciesId.CHARCADET, SpeciesId.ARON],
 };
 
 const AQUA: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.TENTACOOL,
+    SpeciesId.TENTACOOL,
-    Species.GRIMER,
+    SpeciesId.GRIMER,
-    Species.AZURILL,
+    SpeciesId.AZURILL,
-    Species.CHINCHOU,
+    SpeciesId.CHINCHOU,
-    Species.REMORAID,
+    SpeciesId.REMORAID,
-    Species.POOCHYENA,
+    SpeciesId.POOCHYENA,
-    Species.LOTAD,
+    SpeciesId.LOTAD,
-    Species.WINGULL,
+    SpeciesId.WINGULL,
-    Species.WAILMER,
+    SpeciesId.WAILMER,
-    Species.SEVIPER,
+    SpeciesId.SEVIPER,
-    Species.BARBOACH,
+    SpeciesId.BARBOACH,
-    Species.CORPHISH,
+    SpeciesId.CORPHISH,
-    Species.SPHEAL,
+    SpeciesId.SPHEAL,
-    Species.CLAMPERL,
+    SpeciesId.CLAMPERL,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.MANTYKE,
+    SpeciesId.MANTYKE,
-    Species.HORSEA,
+    SpeciesId.HORSEA,
-    Species.FEEBAS,
+    SpeciesId.FEEBAS,
-    Species.TYMPOLE,
+    SpeciesId.TYMPOLE,
-    Species.SKRELP,
+    SpeciesId.SKRELP,
-    Species.WIMPOD,
+    SpeciesId.WIMPOD,
-    Species.DHELMISE,
+    SpeciesId.DHELMISE,
-    Species.ARROKUDA,
+    SpeciesId.ARROKUDA,
-    Species.CLOBBOPUS,
+    SpeciesId.CLOBBOPUS,
-    Species.HISUI_QWILFISH,
+    SpeciesId.HISUI_QWILFISH,
-    Species.WIGLETT,
+    SpeciesId.WIGLETT,
   ],
-  [TrainerPoolTier.RARE]: [Species.BASCULEGION, Species.DONDOZO],
+  [TrainerPoolTier.RARE]: [SpeciesId.BASCULEGION, SpeciesId.DONDOZO],
 };
 
 const GALACTIC: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.ZUBAT,
+    SpeciesId.ZUBAT,
-    Species.MAGNEMITE,
+    SpeciesId.MAGNEMITE,
-    Species.RHYHORN,
+    SpeciesId.RHYHORN,
-    Species.TANGELA,
+    SpeciesId.TANGELA,
-    Species.LICKITUNG,
+    SpeciesId.LICKITUNG,
-    Species.MAGIKARP,
+    SpeciesId.MAGIKARP,
-    Species.YANMA,
+    SpeciesId.YANMA,
-    Species.MURKROW,
+    SpeciesId.MURKROW,
-    Species.SWINUB,
+    SpeciesId.SWINUB,
-    Species.ELEKID,
+    SpeciesId.ELEKID,
-    Species.MAGBY,
+    SpeciesId.MAGBY,
-    Species.BRONZOR,
+    SpeciesId.BRONZOR,
-    Species.SKORUPI,
+    SpeciesId.SKORUPI,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.ABRA,
+    SpeciesId.ABRA,
-    Species.GLIGAR,
+    SpeciesId.GLIGAR,
-    Species.SNEASEL,
+    SpeciesId.SNEASEL,
-    Species.DUSKULL,
+    SpeciesId.DUSKULL,
-    Species.DRIFLOON,
+    SpeciesId.DRIFLOON,
-    Species.CRANIDOS,
+    SpeciesId.CRANIDOS,
-    Species.SHIELDON,
+    SpeciesId.SHIELDON,
-    Species.ROTOM,
+    SpeciesId.ROTOM,
-    Species.HISUI_QWILFISH,
+    SpeciesId.HISUI_QWILFISH,
+  ],
+  [TrainerPoolTier.RARE]: [
+    SpeciesId.SPIRITOMB,
+    SpeciesId.TEDDIURSA,
+    SpeciesId.HISUI_SNEASEL,
+    SpeciesId.HISUI_LILLIGANT,
   ],
-  [TrainerPoolTier.RARE]: [Species.SPIRITOMB, Species.TEDDIURSA, Species.HISUI_SNEASEL, Species.HISUI_LILLIGANT],
 };
 
 const PLASMA_ZINZOLIN: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.SNEASEL,
+    SpeciesId.SNEASEL,
-    Species.SWINUB,
+    SpeciesId.SWINUB,
-    Species.SNORUNT,
+    SpeciesId.SNORUNT,
-    Species.SNOVER,
+    SpeciesId.SNOVER,
-    Species.TIMBURR,
+    SpeciesId.TIMBURR,
-    Species.TYMPOLE,
+    SpeciesId.TYMPOLE,
-    Species.SANDILE,
+    SpeciesId.SANDILE,
-    Species.DARUMAKA,
+    SpeciesId.DARUMAKA,
-    Species.VANILLITE,
+    SpeciesId.VANILLITE,
-    Species.FOONGUS,
+    SpeciesId.FOONGUS,
-    Species.FRILLISH,
+    SpeciesId.FRILLISH,
-    Species.JOLTIK,
+    SpeciesId.JOLTIK,
-    Species.FERROSEED,
+    SpeciesId.FERROSEED,
-    Species.CUBCHOO,
+    SpeciesId.CUBCHOO,
-    Species.GALAR_DARUMAKA,
+    SpeciesId.GALAR_DARUMAKA,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.SPHEAL,
+    SpeciesId.SPHEAL,
-    Species.DRILBUR,
+    SpeciesId.DRILBUR,
-    Species.SIGILYPH,
+    SpeciesId.SIGILYPH,
-    Species.YAMASK,
+    SpeciesId.YAMASK,
-    Species.ZORUA,
+    SpeciesId.ZORUA,
-    Species.TYNAMO,
+    SpeciesId.TYNAMO,
-    Species.MIENFOO,
+    SpeciesId.MIENFOO,
-    Species.GOLETT,
+    SpeciesId.GOLETT,
-    Species.PAWNIARD,
+    SpeciesId.PAWNIARD,
-    Species.VULLABY,
+    SpeciesId.VULLABY,
-    Species.DURANT,
+    SpeciesId.DURANT,
-    Species.BERGMITE,
+    SpeciesId.BERGMITE,
-    Species.EISCUE,
+    SpeciesId.EISCUE,
-    Species.ALOLA_SANDSHREW,
+    SpeciesId.ALOLA_SANDSHREW,
-    Species.HISUI_ZORUA,
+    SpeciesId.HISUI_ZORUA,
   ],
-  [TrainerPoolTier.RARE]: [Species.DEINO, Species.FRIGIBAX, Species.HISUI_BRAVIARY],
+  [TrainerPoolTier.RARE]: [SpeciesId.DEINO, SpeciesId.FRIGIBAX, SpeciesId.HISUI_BRAVIARY],
 };
 
 const PLASMA_COLRESS: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.MAGNEMITE,
+    SpeciesId.MAGNEMITE,
-    Species.GRIMER,
+    SpeciesId.GRIMER,
-    Species.VOLTORB,
+    SpeciesId.VOLTORB,
-    Species.PORYGON,
+    SpeciesId.PORYGON,
-    Species.BRONZOR,
+    SpeciesId.BRONZOR,
-    Species.ROTOM,
+    SpeciesId.ROTOM,
-    Species.MUNNA,
+    SpeciesId.MUNNA,
-    Species.DWEBBLE,
+    SpeciesId.DWEBBLE,
-    Species.FERROSEED,
+    SpeciesId.FERROSEED,
-    Species.ELGYEM,
+    SpeciesId.ELGYEM,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.BELDUM,
+    SpeciesId.BELDUM,
-    Species.SIGILYPH,
+    SpeciesId.SIGILYPH,
-    Species.TIRTOUGA,
+    SpeciesId.TIRTOUGA,
-    Species.ARCHEN,
+    SpeciesId.ARCHEN,
-    Species.TYNAMO,
+    SpeciesId.TYNAMO,
-    Species.GOLETT,
+    SpeciesId.GOLETT,
-    Species.BLIPBUG,
+    SpeciesId.BLIPBUG,
-    Species.VAROOM,
+    SpeciesId.VAROOM,
-    Species.ALOLA_GRIMER,
+    SpeciesId.ALOLA_GRIMER,
-    Species.HISUI_VOLTORB,
+    SpeciesId.HISUI_VOLTORB,
   ],
-  [TrainerPoolTier.RARE]: [Species.ELEKID, Species.MAGBY, Species.PAWNIARD, Species.DURALUDON],
+  [TrainerPoolTier.RARE]: [SpeciesId.ELEKID, SpeciesId.MAGBY, SpeciesId.PAWNIARD, SpeciesId.DURALUDON],
 };
 
 const FLARE: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.ELECTRIKE,
+    SpeciesId.ELECTRIKE,
-    Species.SKORUPI,
+    SpeciesId.SKORUPI,
-    Species.PURRLOIN,
+    SpeciesId.PURRLOIN,
-    Species.FOONGUS,
+    SpeciesId.FOONGUS,
-    Species.BUNNELBY,
+    SpeciesId.BUNNELBY,
-    Species.FLETCHLING,
+    SpeciesId.FLETCHLING,
-    Species.LITLEO,
+    SpeciesId.LITLEO,
-    Species.PANGORO,
+    SpeciesId.PANGORO,
-    Species.ESPURR,
+    SpeciesId.ESPURR,
-    Species.INKAY,
+    SpeciesId.INKAY,
-    Species.CLAUNCHER,
+    SpeciesId.CLAUNCHER,
-    Species.HELIOPTILE,
+    SpeciesId.HELIOPTILE,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.HOUNDOUR,
+    SpeciesId.HOUNDOUR,
-    Species.SNEASEL,
+    SpeciesId.SNEASEL,
-    Species.LITWICK,
+    SpeciesId.LITWICK,
-    Species.HONEDGE,
+    SpeciesId.HONEDGE,
-    Species.BINACLE,
+    SpeciesId.BINACLE,
-    Species.SKRELP,
+    SpeciesId.SKRELP,
-    Species.NOIBAT,
+    SpeciesId.NOIBAT,
-    Species.PHANTUMP,
+    SpeciesId.PHANTUMP,
-    Species.PUMPKABOO,
+    SpeciesId.PUMPKABOO,
   ],
-  [TrainerPoolTier.RARE]: [Species.GOOMY, Species.HISUI_AVALUGG],
+  [TrainerPoolTier.RARE]: [SpeciesId.GOOMY, SpeciesId.HISUI_AVALUGG],
 };
 
 const AETHER: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.ABRA,
+    SpeciesId.ABRA,
-    Species.SLOWPOKE,
+    SpeciesId.SLOWPOKE,
-    Species.MAGNEMITE,
+    SpeciesId.MAGNEMITE,
-    Species.EXEGGUTOR,
+    SpeciesId.EXEGGUTOR,
-    Species.NATU,
+    SpeciesId.NATU,
-    Species.BALTOY,
+    SpeciesId.BALTOY,
-    Species.MIME_JR,
+    SpeciesId.MIME_JR,
-    Species.ELGYEM,
+    SpeciesId.ELGYEM,
-    Species.INKAY,
+    SpeciesId.INKAY,
-    Species.BRUXISH,
+    SpeciesId.BRUXISH,
-    Species.BLIPBUG,
+    SpeciesId.BLIPBUG,
-    Species.ALOLA_RAICHU,
+    SpeciesId.ALOLA_RAICHU,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.RALTS,
+    SpeciesId.RALTS,
-    Species.MEDITITE,
+    SpeciesId.MEDITITE,
-    Species.BELDUM,
+    SpeciesId.BELDUM,
-    Species.SOLOSIS,
+    SpeciesId.SOLOSIS,
-    Species.HATENNA,
+    SpeciesId.HATENNA,
-    Species.STANTLER,
+    SpeciesId.STANTLER,
-    Species.GIRAFARIG,
+    SpeciesId.GIRAFARIG,
-    Species.ALOLA_GRIMER,
+    SpeciesId.ALOLA_GRIMER,
-    Species.GALAR_SLOWPOKE,
+    SpeciesId.GALAR_SLOWPOKE,
   ],
-  [TrainerPoolTier.RARE]: [Species.PORYGON, Species.ARMAROUGE],
+  [TrainerPoolTier.RARE]: [SpeciesId.PORYGON, SpeciesId.ARMAROUGE],
 };
 
 const SKULL: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.GASTLY,
+    SpeciesId.GASTLY,
-    Species.KOFFING,
+    SpeciesId.KOFFING,
-    Species.ZUBAT,
+    SpeciesId.ZUBAT,
-    Species.VENONAT,
+    SpeciesId.VENONAT,
-    Species.STUNKY,
+    SpeciesId.STUNKY,
-    Species.CROAGUNK,
+    SpeciesId.CROAGUNK,
-    Species.VENIPEDE,
+    SpeciesId.VENIPEDE,
-    Species.SCRAGGY,
+    SpeciesId.SCRAGGY,
-    Species.MAREANIE,
+    SpeciesId.MAREANIE,
-    Species.FOMANTIS,
+    SpeciesId.FOMANTIS,
-    Species.ALOLA_GRIMER,
+    SpeciesId.ALOLA_GRIMER,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.NIDORAN_F,
+    SpeciesId.NIDORAN_F,
-    Species.SKORUPI,
+    SpeciesId.SKORUPI,
-    Species.PAWNIARD,
+    SpeciesId.PAWNIARD,
-    Species.VULLABY,
+    SpeciesId.VULLABY,
-    Species.TOXEL,
+    SpeciesId.TOXEL,
-    Species.GLIMMET,
+    SpeciesId.GLIMMET,
-    Species.PALDEA_WOOPER,
+    SpeciesId.PALDEA_WOOPER,
-    Species.GALAR_SLOWPOKE,
+    SpeciesId.GALAR_SLOWPOKE,
   ],
-  [TrainerPoolTier.RARE]: [Species.SKRELP, Species.HISUI_SNEASEL],
+  [TrainerPoolTier.RARE]: [SpeciesId.SKRELP, SpeciesId.HISUI_SNEASEL],
 };
 
 const MACRO_COSMOS: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.VULPIX,
+    SpeciesId.VULPIX,
-    Species.FEEBAS,
+    SpeciesId.FEEBAS,
-    Species.MAWILE,
+    SpeciesId.MAWILE,
-    Species.FROSLASS,
+    SpeciesId.FROSLASS,
-    Species.GOTHITA,
+    SpeciesId.GOTHITA,
-    Species.FLABEBE,
+    SpeciesId.FLABEBE,
-    Species.SALANDIT,
+    SpeciesId.SALANDIT,
-    Species.TSAREENA,
+    SpeciesId.TSAREENA,
-    Species.SINISTEA,
+    SpeciesId.SINISTEA,
-    Species.HATENNA,
+    SpeciesId.HATENNA,
-    Species.INDEEDEE,
+    SpeciesId.INDEEDEE,
-    Species.GALAR_PONYTA,
+    SpeciesId.GALAR_PONYTA,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.TOGEPI,
+    SpeciesId.TOGEPI,
-    Species.VULLABY,
+    SpeciesId.VULLABY,
-    Species.MAREANIE,
+    SpeciesId.MAREANIE,
-    Species.CUFANT,
+    SpeciesId.CUFANT,
-    Species.TINKATINK,
+    SpeciesId.TINKATINK,
-    Species.ALOLA_VULPIX,
+    SpeciesId.ALOLA_VULPIX,
-    Species.GALAR_CORSOLA,
+    SpeciesId.GALAR_CORSOLA,
   ],
-  [TrainerPoolTier.RARE]: [Species.APPLIN, Species.HISUI_LILLIGANT],
+  [TrainerPoolTier.RARE]: [SpeciesId.APPLIN, SpeciesId.HISUI_LILLIGANT],
 };
 
 const STAR_DARK: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.MURKROW,
+    SpeciesId.MURKROW,
-    Species.SEEDOT,
+    SpeciesId.SEEDOT,
-    Species.SABLEYE,
+    SpeciesId.SABLEYE,
-    Species.CACNEA,
+    SpeciesId.CACNEA,
-    Species.STUNKY,
+    SpeciesId.STUNKY,
-    Species.SANDILE,
+    SpeciesId.SANDILE,
-    Species.INKAY,
+    SpeciesId.INKAY,
-    Species.NYMBLE,
+    SpeciesId.NYMBLE,
-    Species.MASCHIFF,
+    SpeciesId.MASCHIFF,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.UMBREON,
+    SpeciesId.UMBREON,
-    Species.CORPHISH,
+    SpeciesId.CORPHISH,
-    Species.SNEASEL,
+    SpeciesId.SNEASEL,
-    Species.ZORUA,
+    SpeciesId.ZORUA,
-    Species.IMPIDIMP,
+    SpeciesId.IMPIDIMP,
-    Species.BOMBIRDIER,
+    SpeciesId.BOMBIRDIER,
-    Species.GALAR_ZIGZAGOON,
+    SpeciesId.GALAR_ZIGZAGOON,
   ],
-  [TrainerPoolTier.RARE]: [Species.DEINO, Species.SPRIGATITO],
+  [TrainerPoolTier.RARE]: [SpeciesId.DEINO, SpeciesId.SPRIGATITO],
 };
 
 const STAR_FIRE: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.GROWLITHE,
+    SpeciesId.GROWLITHE,
-    Species.HOUNDOUR,
+    SpeciesId.HOUNDOUR,
-    Species.NUMEL,
+    SpeciesId.NUMEL,
-    Species.TORKOAL,
+    SpeciesId.TORKOAL,
-    Species.FLETCHLING,
+    SpeciesId.FLETCHLING,
-    Species.LITLEO,
+    SpeciesId.LITLEO,
-    Species.SIZZLIPEDE,
+    SpeciesId.SIZZLIPEDE,
-    Species.ROLYCOLY,
+    SpeciesId.ROLYCOLY,
-    Species.CAPSAKID,
+    SpeciesId.CAPSAKID,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.PONYTA,
+    SpeciesId.PONYTA,
-    Species.FLAREON,
+    SpeciesId.FLAREON,
-    Species.MAGBY,
+    SpeciesId.MAGBY,
-    Species.DARUMAKA,
+    SpeciesId.DARUMAKA,
-    Species.LITWICK,
+    SpeciesId.LITWICK,
-    Species.SALANDIT,
+    SpeciesId.SALANDIT,
-    Species.TURTONATOR,
+    SpeciesId.TURTONATOR,
   ],
-  [TrainerPoolTier.RARE]: [Species.LARVESTA, Species.FUECOCO],
+  [TrainerPoolTier.RARE]: [SpeciesId.LARVESTA, SpeciesId.FUECOCO],
 };
 
 const STAR_POISON: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.GRIMER,
+    SpeciesId.GRIMER,
-    Species.VENONAT,
+    SpeciesId.VENONAT,
-    Species.SEVIPER,
+    SpeciesId.SEVIPER,
-    Species.STUNKY,
+    SpeciesId.STUNKY,
-    Species.FOONGUS,
+    SpeciesId.FOONGUS,
-    Species.MAREANIE,
+    SpeciesId.MAREANIE,
-    Species.TOXEL,
+    SpeciesId.TOXEL,
-    Species.GRAFAIAI,
+    SpeciesId.GRAFAIAI,
-    Species.PALDEA_WOOPER,
+    SpeciesId.PALDEA_WOOPER,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.ZUBAT,
+    SpeciesId.ZUBAT,
-    Species.GASTLY,
+    SpeciesId.GASTLY,
-    Species.SKRELP,
+    SpeciesId.SKRELP,
-    Species.OVERQWIL,
+    SpeciesId.OVERQWIL,
-    Species.ALOLA_GRIMER,
+    SpeciesId.ALOLA_GRIMER,
-    Species.GALAR_SLOWPOKE,
+    SpeciesId.GALAR_SLOWPOKE,
   ],
-  [TrainerPoolTier.RARE]: [Species.GLIMMET, Species.BULBASAUR],
+  [TrainerPoolTier.RARE]: [SpeciesId.GLIMMET, SpeciesId.BULBASAUR],
 };
 
 const STAR_FAIRY: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.IGGLYBUFF,
+    SpeciesId.IGGLYBUFF,
-    Species.AZURILL,
+    SpeciesId.AZURILL,
-    Species.COTTONEE,
+    SpeciesId.COTTONEE,
-    Species.FLABEBE,
+    SpeciesId.FLABEBE,
-    Species.KLEFKI,
+    SpeciesId.KLEFKI,
-    Species.CUTIEFLY,
+    SpeciesId.CUTIEFLY,
-    Species.HATENNA,
+    SpeciesId.HATENNA,
-    Species.TINKATINK,
+    SpeciesId.TINKATINK,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.CLEFFA,
+    SpeciesId.CLEFFA,
-    Species.TOGEPI,
+    SpeciesId.TOGEPI,
-    Species.GARDEVOIR,
+    SpeciesId.GARDEVOIR,
-    Species.SYLVEON,
+    SpeciesId.SYLVEON,
-    Species.MIMIKYU,
+    SpeciesId.MIMIKYU,
-    Species.IMPIDIMP,
+    SpeciesId.IMPIDIMP,
-    Species.ALOLA_VULPIX,
+    SpeciesId.ALOLA_VULPIX,
   ],
-  [TrainerPoolTier.RARE]: [Species.GALAR_PONYTA, Species.POPPLIO],
+  [TrainerPoolTier.RARE]: [SpeciesId.GALAR_PONYTA, SpeciesId.POPPLIO],
 };
 
 const STAR_FIGHTING: TrainerTierPools = {
   [TrainerPoolTier.COMMON]: [
-    Species.TYROGUE,
+    SpeciesId.TYROGUE,
-    Species.SHROOMISH,
+    SpeciesId.SHROOMISH,
-    Species.MAKUHITA,
+    SpeciesId.MAKUHITA,
-    Species.RIOLU,
+    SpeciesId.RIOLU,
-    Species.CROAGUNK,
+    SpeciesId.CROAGUNK,
-    Species.SCRAGGY,
+    SpeciesId.SCRAGGY,
-    Species.MIENFOO,
+    SpeciesId.MIENFOO,
-    Species.PASSIMIAN,
+    SpeciesId.PASSIMIAN,
-    Species.PAWMI,
+    SpeciesId.PAWMI,
   ],
   [TrainerPoolTier.UNCOMMON]: [
-    Species.MEDITITE,
+    SpeciesId.MEDITITE,
-    Species.GALLADE,
+    SpeciesId.GALLADE,
-    Species.TIMBURR,
+    SpeciesId.TIMBURR,
-    Species.HAWLUCHA,
+    SpeciesId.HAWLUCHA,
-    Species.STUFFUL,
+    SpeciesId.STUFFUL,
-    Species.FALINKS,
+    SpeciesId.FALINKS,
-    Species.FLAMIGO,
+    SpeciesId.FLAMIGO,
-    Species.PALDEA_TAUROS,
+    SpeciesId.PALDEA_TAUROS,
   ],
-  [TrainerPoolTier.RARE]: [Species.JANGMO_O, Species.QUAXLY],
+  [TrainerPoolTier.RARE]: [SpeciesId.JANGMO_O, SpeciesId.QUAXLY],
 };
 
 export type EvilTeam =

src/data/trainers/typedefs.ts

@@ -1,7 +1,7 @@
 import type { EnemyPokemon } from "#app/field/pokemon";
 import type { PersistentModifier } from "#app/modifier/modifier";
 import type { PartyMemberStrength } from "#enums/party-member-strength";
-import type { Species } from "#enums/species";
+import type { SpeciesId } from "#enums/species-id";
 import type { TrainerConfig } from "./trainer-config";
 import type { TrainerPartyTemplate } from "./TrainerPartyTemplate";
 
@@ -11,7 +11,7 @@ export type GenModifiersFunc = (party: EnemyPokemon[]) => PersistentModifier[];
 export type GenAIFunc = (party: EnemyPokemon[]) => void;
 
 export interface TrainerTierPools {
-  [key: number]: Species[];
+  [key: number]: SpeciesId[];
 }
 export interface TrainerConfigs {
   [key: number]: TrainerConfig;

src/data/weather.ts

@@ -1,4 +1,4 @@
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
 import { WeatherType } from "#enums/weather-type";
 import { getPokemonNameWithAffix } from "../messages";
 import type Pokemon from "../field/pokemon";
@@ -289,13 +289,13 @@ export function getRandomWeatherType(arena: Arena): WeatherType {
   let weatherPool: WeatherPoolEntry[] = [];
   const hasSun = arena.getTimeOfDay() < 2;
   switch (arena.biomeType) {
-    case Biome.GRASS:
+    case BiomeId.GRASS:
       weatherPool = [{ weatherType: WeatherType.NONE, weight: 7 }];
       if (hasSun) {
         weatherPool.push({ weatherType: WeatherType.SUNNY, weight: 3 });
       }
       break;
-    case Biome.TALL_GRASS:
+    case BiomeId.TALL_GRASS:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 8 },
         { weatherType: WeatherType.RAIN, weight: 5 },
@@ -304,26 +304,26 @@ export function getRandomWeatherType(arena: Arena): WeatherType {
         weatherPool.push({ weatherType: WeatherType.SUNNY, weight: 8 });
       }
       break;
-    case Biome.FOREST:
+    case BiomeId.FOREST:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 8 },
         { weatherType: WeatherType.RAIN, weight: 5 },
       ];
       break;
-    case Biome.SEA:
+    case BiomeId.SEA:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 3 },
         { weatherType: WeatherType.RAIN, weight: 12 },
       ];
       break;
-    case Biome.SWAMP:
+    case BiomeId.SWAMP:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 3 },
         { weatherType: WeatherType.RAIN, weight: 4 },
         { weatherType: WeatherType.FOG, weight: 1 },
       ];
       break;
-    case Biome.BEACH:
+    case BiomeId.BEACH:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 8 },
         { weatherType: WeatherType.RAIN, weight: 3 },
@@ -332,17 +332,17 @@ export function getRandomWeatherType(arena: Arena): WeatherType {
         weatherPool.push({ weatherType: WeatherType.SUNNY, weight: 5 });
       }
       break;
-    case Biome.LAKE:
+    case BiomeId.LAKE:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 10 },
         { weatherType: WeatherType.RAIN, weight: 5 },
         { weatherType: WeatherType.FOG, weight: 1 },
       ];
       break;
-    case Biome.SEABED:
+    case BiomeId.SEABED:
       weatherPool = [{ weatherType: WeatherType.RAIN, weight: 1 }];
       break;
-    case Biome.BADLANDS:
+    case BiomeId.BADLANDS:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 8 },
         { weatherType: WeatherType.SANDSTORM, weight: 2 },
@@ -351,26 +351,26 @@ export function getRandomWeatherType(arena: Arena): WeatherType {
         weatherPool.push({ weatherType: WeatherType.SUNNY, weight: 5 });
       }
       break;
-    case Biome.DESERT:
+    case BiomeId.DESERT:
       weatherPool = [{ weatherType: WeatherType.SANDSTORM, weight: 2 }];
       if (hasSun) {
         weatherPool.push({ weatherType: WeatherType.SUNNY, weight: 2 });
       }
       break;
-    case Biome.ICE_CAVE:
+    case BiomeId.ICE_CAVE:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 3 },
         { weatherType: WeatherType.SNOW, weight: 4 },
         { weatherType: WeatherType.HAIL, weight: 1 },
       ];
       break;
-    case Biome.MEADOW:
+    case BiomeId.MEADOW:
       weatherPool = [{ weatherType: WeatherType.NONE, weight: 2 }];
       if (hasSun) {
         weatherPool.push({ weatherType: WeatherType.SUNNY, weight: 2 });
       }
       break;
-    case Biome.VOLCANO:
+    case BiomeId.VOLCANO:
       weatherPool = [
         {
           weatherType: hasSun ? WeatherType.SUNNY : WeatherType.NONE,
@@ -378,25 +378,25 @@ export function getRandomWeatherType(arena: Arena): WeatherType {
         },
       ];
       break;
-    case Biome.GRAVEYARD:
+    case BiomeId.GRAVEYARD:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 3 },
         { weatherType: WeatherType.FOG, weight: 1 },
       ];
       break;
-    case Biome.JUNGLE:
+    case BiomeId.JUNGLE:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 8 },
         { weatherType: WeatherType.RAIN, weight: 2 },
       ];
       break;
-    case Biome.SNOWY_FOREST:
+    case BiomeId.SNOWY_FOREST:
       weatherPool = [
         { weatherType: WeatherType.SNOW, weight: 7 },
         { weatherType: WeatherType.HAIL, weight: 1 },
       ];
       break;
-    case Biome.ISLAND:
+    case BiomeId.ISLAND:
       weatherPool = [
         { weatherType: WeatherType.NONE, weight: 5 },
         { weatherType: WeatherType.RAIN, weight: 1 },
@@ -407,7 +407,7 @@ export function getRandomWeatherType(arena: Arena): WeatherType {
       break;
   }
 
-  if (arena.biomeType === Biome.TOWN && timedEventManager.isEventActive()) {
+  if (arena.biomeType === BiomeId.TOWN && timedEventManager.isEventActive()) {
     timedEventManager.getWeather()?.map(w => weatherPool.push(w));
   }
 

src/enums/MoveFlags.ts

@@ -4,11 +4,11 @@ export enum MoveFlags {
   IGNORE_PROTECT = 1 << 1,
   /**
    * Sound-based moves have the following effects:
-   * - Pokemon with the {@linkcode Abilities.SOUNDPROOF Soundproof Ability} are unaffected by other Pokemon's sound-based moves.
+   * - Pokemon with the {@linkcode AbilityId.SOUNDPROOF Soundproof Ability} are unaffected by other Pokemon's sound-based moves.
-   * - Pokemon affected by {@linkcode Moves.THROAT_CHOP Throat Chop} cannot use sound-based moves for two turns.
+   * - Pokemon affected by {@linkcode MoveId.THROAT_CHOP Throat Chop} cannot use sound-based moves for two turns.
-   * - Sound-based moves used by a Pokemon with {@linkcode Abilities.LIQUID_VOICE Liquid Voice} become Water-type moves.
+   * - Sound-based moves used by a Pokemon with {@linkcode AbilityId.LIQUID_VOICE Liquid Voice} become Water-type moves.
-   * - Sound-based moves used by a Pokemon with {@linkcode Abilities.PUNK_ROCK Punk Rock} are boosted by 30%. Pokemon with Punk Rock also take half damage from sound-based moves.
+   * - Sound-based moves used by a Pokemon with {@linkcode AbilityId.PUNK_ROCK Punk Rock} are boosted by 30%. Pokemon with Punk Rock also take half damage from sound-based moves.
-   * - All sound-based moves (except Howl) can hit Pokemon behind an active {@linkcode Moves.SUBSTITUTE Substitute}.
+   * - All sound-based moves (except Howl) can hit Pokemon behind an active {@linkcode MoveId.SUBSTITUTE Substitute}.
    *
    * cf https://bulbapedia.bulbagarden.net/wiki/Sound-based_move
    */
@@ -20,19 +20,19 @@ export enum MoveFlags {
   PUNCHING_MOVE = 1 << 7,
   SLICING_MOVE = 1 << 8,
   /**
-   * Indicates a move should be affected by {@linkcode Abilities.RECKLESS}
+   * Indicates a move should be affected by {@linkcode AbilityId.RECKLESS}
    * @see {@linkcode Move.recklessMove()}
    */
   RECKLESS_MOVE = 1 << 9,
-  /** Indicates a move should be affected by {@linkcode Abilities.BULLETPROOF} */
+  /** Indicates a move should be affected by {@linkcode AbilityId.BULLETPROOF} */
   BALLBOMB_MOVE = 1 << 10,
-  /** Grass types and pokemon with {@linkcode Abilities.OVERCOAT} are immune to powder moves */
+  /** Grass types and pokemon with {@linkcode AbilityId.OVERCOAT} are immune to powder moves */
   POWDER_MOVE = 1 << 11,
-  /** Indicates a move should trigger {@linkcode Abilities.DANCER} */
+  /** Indicates a move should trigger {@linkcode AbilityId.DANCER} */
   DANCE_MOVE = 1 << 12,
-  /** Indicates a move should trigger {@linkcode Abilities.WIND_RIDER} */
+  /** Indicates a move should trigger {@linkcode AbilityId.WIND_RIDER} */
   WIND_MOVE = 1 << 13,
-  /** Indicates a move should trigger {@linkcode Abilities.TRIAGE} */
+  /** Indicates a move should trigger {@linkcode AbilityId.TRIAGE} */
   TRIAGE_MOVE = 1 << 14,
   IGNORE_ABILITIES = 1 << 15,
   /** Enables all hits of a multi-hit move to be accuracy checked individually */
@@ -41,6 +41,6 @@ export enum MoveFlags {
   IGNORE_SUBSTITUTE = 1 << 17,
   /** Indicates a move is able to be redirected to allies in a double battle if the attacker faints */
   REDIRECT_COUNTER = 1 << 18,
-  /** Indicates a move is able to be reflected by {@linkcode Abilities.MAGIC_BOUNCE} and {@linkcode Moves.MAGIC_COAT} */
+  /** Indicates a move is able to be reflected by {@linkcode AbilityId.MAGIC_BOUNCE} and {@linkcode MoveId.MAGIC_COAT} */
   REFLECTABLE = 1 << 19
 }

src/enums/ability-id.ts

@@ -1,4 +1,4 @@
-export enum Abilities {
+export enum AbilityId {
   /**{@link https://bulbapedia.bulbagarden.net/wiki/None_(ability) | Source} */
   NONE,
   /**{@link https://bulbapedia.bulbagarden.net/wiki/Stench_(ability) | Source} */

src/enums/biome-id.ts

@@ -1,4 +1,4 @@
-export enum Biome {
+export enum BiomeId {
   // TODO: Should -1 be part of the enum signature (for "unknown place")
   TOWN,
   PLAINS,

src/enums/drop-down-column.ts

@@ -0,0 +1,9 @@
+export enum DropDownColumn {
+  GEN,
+  TYPES,
+  BIOME,
+  CAUGHT,
+  UNLOCKS,
+  MISC,
+  SORT
+}

src/enums/move-id.ts

@@ -1,4 +1,4 @@
-export enum Moves {
+export enum MoveId {
   /**{@link https://bulbapedia.bulbagarden.net/wiki/None_(move) | Source} */
   NONE,
   /**{@link https://bulbapedia.bulbagarden.net/wiki/Pound_(move) | Source} */

src/enums/species-id.ts

@@ -1,4 +1,4 @@
-export enum Species {
+export enum SpeciesId {
   /**{@link https://bulbapedia.bulbagarden.net/wiki/Bulbasaur_(Pokémon) | Source} */
   BULBASAUR = 1,
   /**{@link https://bulbapedia.bulbagarden.net/wiki/Ivysaur_(Pokémon) | Source} */

src/field/arena.ts

@@ -31,19 +31,19 @@ import type Pokemon from "#app/field/pokemon";
 import Overrides from "#app/overrides";
 import { TagAddedEvent, TagRemovedEvent, TerrainChangedEvent, WeatherChangedEvent } from "#app/events/arena";
 import type { ArenaTagType } from "#enums/arena-tag-type";
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
-import type { Moves } from "#enums/moves";
+import type { MoveId } from "#enums/move-id";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { TimeOfDay } from "#enums/time-of-day";
 import { TrainerType } from "#enums/trainer-type";
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 import { SpeciesFormChangeRevertWeatherFormTrigger, SpeciesFormChangeWeatherTrigger } from "#app/data/pokemon-forms";
 import { CommonAnimPhase } from "#app/phases/common-anim-phase";
 import { WeatherType } from "#enums/weather-type";
 import { FieldEffectModifier } from "#app/modifier/modifier";
 
 export class Arena {
-  public biomeType: Biome;
+  public biomeType: BiomeId;
   public weather: Weather | null;
   public terrain: Terrain | null;
   public tags: ArenaTag[];
@@ -64,7 +64,7 @@ export class Arena {
 
   public readonly eventTarget: EventTarget = new EventTarget();
 
-  constructor(biome: Biome, bgm: string, playerFaints = 0) {
+  constructor(biome: BiomeId, bgm: string, playerFaints = 0) {
     this.biomeType = biome;
     this.tags = [];
     this.bgm = bgm;
@@ -116,7 +116,7 @@ export class Arena {
     const isBossSpecies =
       !!globalScene.getEncounterBossSegments(waveIndex, level) &&
       !!this.pokemonPool[BiomePoolTier.BOSS].length &&
-      (this.biomeType !== Biome.END || globalScene.gameMode.isClassic || globalScene.gameMode.isWaveFinal(waveIndex));
+      (this.biomeType !== BiomeId.END || globalScene.gameMode.isClassic || globalScene.gameMode.isWaveFinal(waveIndex));
     const randVal = isBossSpecies ? 64 : 512;
     // luck influences encounter rarity
     let luckModifier = 0;
@@ -153,9 +153,9 @@ export class Arena {
       ret = globalScene.randomSpecies(waveIndex, level);
     } else {
       const entry = tierPool[randSeedInt(tierPool.length)];
-      let species: Species;
+      let species: SpeciesId;
       if (typeof entry === "number") {
-        species = entry as Species;
+        species = entry as SpeciesId;
       } else {
         const levelThresholds = Object.keys(entry);
         for (let l = levelThresholds.length - 1; l >= 0; l--) {
@@ -199,7 +199,7 @@ export class Arena {
 
     const newSpeciesId = ret.getWildSpeciesForLevel(level, true, isBoss ?? isBossSpecies, globalScene.gameMode);
     if (newSpeciesId !== ret.speciesId) {
-      console.log("Replaced", Species[ret.speciesId], "with", Species[newSpeciesId]);
+      console.log("Replaced", SpeciesId[ret.speciesId], "with", SpeciesId[newSpeciesId]);
       ret = getPokemonSpecies(newSpeciesId);
     }
     return ret;
@@ -239,30 +239,30 @@ export class Arena {
 
   getSpeciesFormIndex(species: PokemonSpecies): number {
     switch (species.speciesId) {
-      case Species.BURMY:
+      case SpeciesId.BURMY:
-      case Species.WORMADAM:
+      case SpeciesId.WORMADAM:
         switch (this.biomeType) {
-          case Biome.BEACH:
+          case BiomeId.BEACH:
             return 1;
-          case Biome.SLUM:
+          case BiomeId.SLUM:
             return 2;
         }
         break;
-      case Species.ROTOM:
+      case SpeciesId.ROTOM:
         switch (this.biomeType) {
-          case Biome.VOLCANO:
+          case BiomeId.VOLCANO:
             return 1;
-          case Biome.SEA:
+          case BiomeId.SEA:
             return 2;
-          case Biome.ICE_CAVE:
+          case BiomeId.ICE_CAVE:
             return 3;
-          case Biome.MOUNTAIN:
+          case BiomeId.MOUNTAIN:
             return 4;
-          case Biome.TALL_GRASS:
+          case BiomeId.TALL_GRASS:
             return 5;
         }
         break;
-      case Species.LYCANROC:
+      case SpeciesId.LYCANROC:
         const timeOfDay = this.getTimeOfDay();
         switch (timeOfDay) {
           case TimeOfDay.DAY:
@@ -281,9 +281,9 @@ export class Arena {
 
   getBgTerrainColorRatioForBiome(): number {
     switch (this.biomeType) {
-      case Biome.SPACE:
+      case BiomeId.SPACE:
         return 1;
-      case Biome.END:
+      case BiomeId.END:
         return 0;
     }
 
@@ -372,8 +372,8 @@ export class Arena {
    */
   triggerWeatherBasedFormChanges(): void {
     globalScene.getField(true).forEach(p => {
-      const isCastformWithForecast = p.hasAbility(Abilities.FORECAST) && p.species.speciesId === Species.CASTFORM;
+      const isCastformWithForecast = p.hasAbility(AbilityId.FORECAST) && p.species.speciesId === SpeciesId.CASTFORM;
-      const isCherrimWithFlowerGift = p.hasAbility(Abilities.FLOWER_GIFT) && p.species.speciesId === Species.CHERRIM;
+      const isCherrimWithFlowerGift = p.hasAbility(AbilityId.FLOWER_GIFT) && p.species.speciesId === SpeciesId.CHERRIM;
 
       if (isCastformWithForecast || isCherrimWithFlowerGift) {
         globalScene.triggerPokemonFormChange(p, SpeciesFormChangeWeatherTrigger);
@@ -387,9 +387,9 @@ export class Arena {
   triggerWeatherBasedFormChangesToNormal(): void {
     globalScene.getField(true).forEach(p => {
       const isCastformWithForecast =
-        p.hasAbility(Abilities.FORECAST, false, true) && p.species.speciesId === Species.CASTFORM;
+        p.hasAbility(AbilityId.FORECAST, false, true) && p.species.speciesId === SpeciesId.CASTFORM;
       const isCherrimWithFlowerGift =
-        p.hasAbility(Abilities.FLOWER_GIFT, false, true) && p.species.speciesId === Species.CHERRIM;
+        p.hasAbility(AbilityId.FLOWER_GIFT, false, true) && p.species.speciesId === SpeciesId.CHERRIM;
 
       if (isCastformWithForecast || isCherrimWithFlowerGift) {
         return globalScene.triggerPokemonFormChange(p, SpeciesFormChangeRevertWeatherFormTrigger);
@@ -488,42 +488,42 @@ export class Arena {
    */
   getTrainerChance(): number {
     switch (this.biomeType) {
-      case Biome.METROPOLIS:
+      case BiomeId.METROPOLIS:
         return 2;
-      case Biome.SLUM:
+      case BiomeId.SLUM:
-      case Biome.BEACH:
+      case BiomeId.BEACH:
-      case Biome.DOJO:
+      case BiomeId.DOJO:
-      case Biome.CONSTRUCTION_SITE:
+      case BiomeId.CONSTRUCTION_SITE:
         return 4;
-      case Biome.PLAINS:
+      case BiomeId.PLAINS:
-      case Biome.GRASS:
+      case BiomeId.GRASS:
-      case Biome.LAKE:
+      case BiomeId.LAKE:
-      case Biome.CAVE:
+      case BiomeId.CAVE:
         return 6;
-      case Biome.TALL_GRASS:
+      case BiomeId.TALL_GRASS:
-      case Biome.FOREST:
+      case BiomeId.FOREST:
-      case Biome.SEA:
+      case BiomeId.SEA:
-      case Biome.SWAMP:
+      case BiomeId.SWAMP:
-      case Biome.MOUNTAIN:
+      case BiomeId.MOUNTAIN:
-      case Biome.BADLANDS:
+      case BiomeId.BADLANDS:
-      case Biome.DESERT:
+      case BiomeId.DESERT:
-      case Biome.MEADOW:
+      case BiomeId.MEADOW:
-      case Biome.POWER_PLANT:
+      case BiomeId.POWER_PLANT:
-      case Biome.GRAVEYARD:
+      case BiomeId.GRAVEYARD:
-      case Biome.FACTORY:
+      case BiomeId.FACTORY:
-      case Biome.SNOWY_FOREST:
+      case BiomeId.SNOWY_FOREST:
         return 8;
-      case Biome.ICE_CAVE:
+      case BiomeId.ICE_CAVE:
-      case Biome.VOLCANO:
+      case BiomeId.VOLCANO:
-      case Biome.RUINS:
+      case BiomeId.RUINS:
-      case Biome.WASTELAND:
+      case BiomeId.WASTELAND:
-      case Biome.JUNGLE:
+      case BiomeId.JUNGLE:
-      case Biome.FAIRY_CAVE:
+      case BiomeId.FAIRY_CAVE:
         return 12;
-      case Biome.SEABED:
+      case BiomeId.SEABED:
-      case Biome.ABYSS:
+      case BiomeId.ABYSS:
-      case Biome.SPACE:
+      case BiomeId.SPACE:
-      case Biome.TEMPLE:
+      case BiomeId.TEMPLE:
         return 16;
       default:
         return 0;
@@ -532,7 +532,7 @@ export class Arena {
 
   getTimeOfDay(): TimeOfDay {
     switch (this.biomeType) {
-      case Biome.ABYSS:
+      case BiomeId.ABYSS:
         return TimeOfDay.NIGHT;
     }
 
@@ -555,16 +555,16 @@ export class Arena {
 
   isOutside(): boolean {
     switch (this.biomeType) {
-      case Biome.SEABED:
+      case BiomeId.SEABED:
-      case Biome.CAVE:
+      case BiomeId.CAVE:
-      case Biome.ICE_CAVE:
+      case BiomeId.ICE_CAVE:
-      case Biome.POWER_PLANT:
+      case BiomeId.POWER_PLANT:
-      case Biome.DOJO:
+      case BiomeId.DOJO:
-      case Biome.FACTORY:
+      case BiomeId.FACTORY:
-      case Biome.ABYSS:
+      case BiomeId.ABYSS:
-      case Biome.FAIRY_CAVE:
+      case BiomeId.FAIRY_CAVE:
-      case Biome.TEMPLE:
+      case BiomeId.TEMPLE:
-      case Biome.LABORATORY:
+      case BiomeId.LABORATORY:
         return false;
       default:
         return true;
@@ -589,7 +589,7 @@ export class Arena {
       return this.overrideTint();
     }
     switch (this.biomeType) {
-      case Biome.ABYSS:
+      case BiomeId.ABYSS:
         return [64, 64, 64];
       default:
         return [128, 128, 128];
@@ -615,9 +615,9 @@ export class Arena {
       return this.overrideTint();
     }
     switch (this.biomeType) {
-      case Biome.ABYSS:
+      case BiomeId.ABYSS:
-      case Biome.SPACE:
+      case BiomeId.SPACE:
-      case Biome.END:
+      case BiomeId.END:
         return this.getDayTint();
     }
 
@@ -674,7 +674,7 @@ export class Arena {
    * Adds a new tag to the arena
    * @param tagType {@linkcode ArenaTagType} the tag being added
    * @param turnCount How many turns the tag lasts
-   * @param sourceMove {@linkcode Moves} the move the tag came from, or `undefined` if not from a move
+   * @param sourceMove {@linkcode MoveId} the move the tag came from, or `undefined` if not from a move
    * @param sourceId The ID of the pokemon in play the tag came from (see {@linkcode BattleScene.getPokemonById})
    * @param side {@linkcode ArenaTagSide} which side(s) the tag applies to
    * @param quiet If a message should be queued on screen to announce the tag being added
@@ -684,7 +684,7 @@ export class Arena {
   addTag(
     tagType: ArenaTagType,
     turnCount: number,
-    sourceMove: Moves | undefined,
+    sourceMove: MoveId | undefined,
     sourceId: number,
     side: ArenaTagSide = ArenaTagSide.BOTH,
     quiet = false,
@@ -835,78 +835,78 @@ export class Arena {
   /** The loop point of any given biome track, read as seconds and milliseconds. */
   getBgmLoopPoint(): number {
     switch (this.biomeType) {
-      case Biome.TOWN:
+      case BiomeId.TOWN:
         return 7.288;
-      case Biome.PLAINS:
+      case BiomeId.PLAINS:
         return 17.485;
-      case Biome.GRASS:
+      case BiomeId.GRASS:
         return 1.995;
-      case Biome.TALL_GRASS:
+      case BiomeId.TALL_GRASS:
         return 9.608;
-      case Biome.METROPOLIS:
+      case BiomeId.METROPOLIS:
         return 141.47;
-      case Biome.FOREST:
+      case BiomeId.FOREST:
         return 0.341;
-      case Biome.SEA:
+      case BiomeId.SEA:
         return 0.024;
-      case Biome.SWAMP:
+      case BiomeId.SWAMP:
         return 4.461;
-      case Biome.BEACH:
+      case BiomeId.BEACH:
         return 3.462;
-      case Biome.LAKE:
+      case BiomeId.LAKE:
         return 7.215;
-      case Biome.SEABED:
+      case BiomeId.SEABED:
         return 2.6;
-      case Biome.MOUNTAIN:
+      case BiomeId.MOUNTAIN:
         return 4.018;
-      case Biome.BADLANDS:
+      case BiomeId.BADLANDS:
         return 17.79;
-      case Biome.CAVE:
+      case BiomeId.CAVE:
         return 14.24;
-      case Biome.DESERT:
+      case BiomeId.DESERT:
         return 1.143;
-      case Biome.ICE_CAVE:
+      case BiomeId.ICE_CAVE:
         return 0.0;
-      case Biome.MEADOW:
+      case BiomeId.MEADOW:
         return 3.891;
-      case Biome.POWER_PLANT:
+      case BiomeId.POWER_PLANT:
         return 9.447;
-      case Biome.VOLCANO:
+      case BiomeId.VOLCANO:
         return 17.637;
-      case Biome.GRAVEYARD:
+      case BiomeId.GRAVEYARD:
         return 13.711;
-      case Biome.DOJO:
+      case BiomeId.DOJO:
         return 6.205;
-      case Biome.FACTORY:
+      case BiomeId.FACTORY:
         return 4.985;
-      case Biome.RUINS:
+      case BiomeId.RUINS:
         return 0.0;
-      case Biome.WASTELAND:
+      case BiomeId.WASTELAND:
         return 6.336;
-      case Biome.ABYSS:
+      case BiomeId.ABYSS:
         return 5.13;
-      case Biome.SPACE:
+      case BiomeId.SPACE:
         return 20.036;
-      case Biome.CONSTRUCTION_SITE:
+      case BiomeId.CONSTRUCTION_SITE:
         return 1.222;
-      case Biome.JUNGLE:
+      case BiomeId.JUNGLE:
         return 0.0;
-      case Biome.FAIRY_CAVE:
+      case BiomeId.FAIRY_CAVE:
         return 4.542;
-      case Biome.TEMPLE:
+      case BiomeId.TEMPLE:
         return 2.547;
-      case Biome.ISLAND:
+      case BiomeId.ISLAND:
         return 2.751;
-      case Biome.LABORATORY:
+      case BiomeId.LABORATORY:
         return 114.862;
-      case Biome.SLUM:
+      case BiomeId.SLUM:
         return 0.0;
-      case Biome.SNOWY_FOREST:
+      case BiomeId.SNOWY_FOREST:
         return 3.047;
-      case Biome.END:
+      case BiomeId.END:
         return 17.153;
       default:
-        console.warn(`missing bgm loop-point for biome "${Biome[this.biomeType]}" (=${this.biomeType})`);
+        console.warn(`missing bgm loop-point for biome "${BiomeId[this.biomeType]}" (=${this.biomeType})`);
         return 0;
     }
   }
@@ -916,37 +916,37 @@ export class Arena {
   }
 }
 
-export function getBiomeKey(biome: Biome): string {
+export function getBiomeKey(biome: BiomeId): string {
-  return Biome[biome].toLowerCase();
+  return BiomeId[biome].toLowerCase();
 }
 
-export function getBiomeHasProps(biomeType: Biome): boolean {
+export function getBiomeHasProps(biomeType: BiomeId): boolean {
   switch (biomeType) {
-    case Biome.METROPOLIS:
+    case BiomeId.METROPOLIS:
-    case Biome.BEACH:
+    case BiomeId.BEACH:
-    case Biome.LAKE:
+    case BiomeId.LAKE:
-    case Biome.SEABED:
+    case BiomeId.SEABED:
-    case Biome.MOUNTAIN:
+    case BiomeId.MOUNTAIN:
-    case Biome.BADLANDS:
+    case BiomeId.BADLANDS:
-    case Biome.CAVE:
+    case BiomeId.CAVE:
-    case Biome.DESERT:
+    case BiomeId.DESERT:
-    case Biome.ICE_CAVE:
+    case BiomeId.ICE_CAVE:
-    case Biome.MEADOW:
+    case BiomeId.MEADOW:
-    case Biome.POWER_PLANT:
+    case BiomeId.POWER_PLANT:
-    case Biome.VOLCANO:
+    case BiomeId.VOLCANO:
-    case Biome.GRAVEYARD:
+    case BiomeId.GRAVEYARD:
-    case Biome.FACTORY:
+    case BiomeId.FACTORY:
-    case Biome.RUINS:
+    case BiomeId.RUINS:
-    case Biome.WASTELAND:
+    case BiomeId.WASTELAND:
-    case Biome.ABYSS:
+    case BiomeId.ABYSS:
-    case Biome.CONSTRUCTION_SITE:
+    case BiomeId.CONSTRUCTION_SITE:
-    case Biome.JUNGLE:
+    case BiomeId.JUNGLE:
-    case Biome.FAIRY_CAVE:
+    case BiomeId.FAIRY_CAVE:
-    case Biome.TEMPLE:
+    case BiomeId.TEMPLE:
-    case Biome.SNOWY_FOREST:
+    case BiomeId.SNOWY_FOREST:
-    case Biome.ISLAND:
+    case BiomeId.ISLAND:
-    case Biome.LABORATORY:
+    case BiomeId.LABORATORY:
-    case Biome.END:
+    case BiomeId.END:
       return true;
   }
 
@@ -955,7 +955,7 @@ export function getBiomeHasProps(biomeType: Biome): boolean {
 
 export class ArenaBase extends Phaser.GameObjects.Container {
   public player: boolean;
-  public biome: Biome;
+  public biome: BiomeId;
   public propValue: number;
   public base: Phaser.GameObjects.Sprite;
   public props: Phaser.GameObjects.Sprite[];
@@ -978,7 +978,7 @@ export class ArenaBase extends Phaser.GameObjects.Container {
       : [];
   }
 
-  setBiome(biome: Biome, propValue?: number): void {
+  setBiome(biome: BiomeId, propValue?: number): void {
     const hasProps = getBiomeHasProps(biome);
     const biomeKey = getBiomeKey(biome);
     const baseKey = `${biomeKey}_${this.player ? "a" : "b"}`;

src/field/mystery-encounter-intro.ts

@@ -1,13 +1,13 @@
 import type { GameObjects } from "phaser";
 import { globalScene } from "#app/global-scene";
 import type MysteryEncounter from "#app/data/mystery-encounters/mystery-encounter";
-import type { Species } from "#enums/species";
+import type { SpeciesId } from "#enums/species-id";
 import { isNullOrUndefined } from "#app/utils/common";
 import { getSpriteKeysFromSpecies } from "#app/data/mystery-encounters/utils/encounter-pokemon-utils";
 import type { Variant } from "#app/sprites/variant";
 import { doShinySparkleAnim } from "#app/field/anims";
-import PlayAnimationConfig = Phaser.Types.Animations.PlayAnimationConfig;
 import { loadPokemonVariantAssets } from "#app/sprites/pokemon-sprite";
+import PlayAnimationConfig = Phaser.Types.Animations.PlayAnimationConfig;
 
 type KnownFileRoot =
   | "arenas"
@@ -39,7 +39,7 @@ export class MysteryEncounterSpriteConfig {
   /** Refer to [/public/images](../../public/images) directorty for all folder names */
   fileRoot: (KnownFileRoot & string) | string;
   /** Optional replacement for `spriteKey`/`fileRoot`. Just know this defaults to male/genderless, form 0, no shiny */
-  species?: Species;
+  species?: SpeciesId;
   /** Enable shadow. Defaults to `false` */
   hasShadow?: boolean = false;
   /** Disable animation. Defaults to `false` */

src/field/pokemon.ts

@@ -220,14 +220,14 @@ import i18next from "i18next";
 import { speciesEggMoves } from "#app/data/balance/egg-moves";
 import { ModifierTier } from "#app/modifier/modifier-tier";
 import { applyChallenges, ChallengeType } from "#app/data/challenge";
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 import { ArenaTagType } from "#enums/arena-tag-type";
 import { BattleSpec } from "#enums/battle-spec";
 import { BattlerTagType } from "#enums/battler-tag-type";
 import type { BerryType } from "#enums/berry-type";
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { getPokemonNameWithAffix } from "#app/messages";
 import { DamageAnimPhase } from "#app/phases/damage-anim-phase";
 import { FaintPhase } from "#app/phases/faint-phase";
@@ -333,8 +333,8 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
   public status: Status | null;
   public friendship: number;
   public metLevel: number;
-  public metBiome: Biome | -1;
+  public metBiome: BiomeId | -1;
-  public metSpecies: Species;
+  public metSpecies: SpeciesId;
   public metWave: number;
   public luck: number;
   public pauseEvolutions: boolean;
@@ -381,7 +381,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
   public maskEnabled: boolean;
   public maskSprite: Phaser.GameObjects.Sprite | null;
 
-  public usedTMs: Moves[];
+  public usedTMs: MoveId[];
 
   private shinySparkle: Phaser.GameObjects.Sprite;
 
@@ -1123,7 +1123,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
 
   /**
    * Get this {@linkcode Pokemon}'s {@linkcode PokemonSpeciesForm}.
-   * @param ignoreOverride - Whether to ignore overridden species from {@linkcode Moves.TRANSFORM}, default `false`.
+   * @param ignoreOverride - Whether to ignore overridden species from {@linkcode MoveId.TRANSFORM}, default `false`.
    * This overrides `useIllusion` if `true`.
    * @param useIllusion - `true` to use the speciesForm of the illusion; default `false`.
    */
@@ -1571,7 +1571,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
         if (this.status && this.status.effect === StatusEffect.PARALYSIS) {
           ret >>= 1;
         }
-        if (this.getTag(BattlerTagType.UNBURDEN) && this.hasAbility(Abilities.UNBURDEN)) {
+        if (this.getTag(BattlerTagType.UNBURDEN) && this.hasAbility(AbilityId.UNBURDEN)) {
           ret *= 2;
         }
         break;
@@ -1601,7 +1601,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       if (s === Stat.HP) {
         statHolder.value = statHolder.value + this.level + 10;
         globalScene.applyModifier(PokemonIncrementingStatModifier, this.isPlayer(), this, s, statHolder);
-        if (this.hasAbility(Abilities.WONDER_GUARD, false, true)) {
+        if (this.hasAbility(AbilityId.WONDER_GUARD, false, true)) {
           statHolder.value = 1;
         }
         if (this.hp > statHolder.value || this.hp === undefined) {
@@ -1817,21 +1817,21 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
   }
 
   /**
-   * Checks if the {@linkcode Pokemon} has a fusion with the specified {@linkcode Species}.
+   * Checks if the {@linkcode Pokemon} has a fusion with the specified {@linkcode SpeciesId}.
-   * @param species the pokemon {@linkcode Species} to check
+   * @param species the pokemon {@linkcode SpeciesId} to check
-   * @returns `true` if the {@linkcode Pokemon} has a fusion with the specified {@linkcode Species}, `false` otherwise
+   * @returns `true` if the {@linkcode Pokemon} has a fusion with the specified {@linkcode SpeciesId}, `false` otherwise
    */
-  hasFusionSpecies(species: Species): boolean {
+  hasFusionSpecies(species: SpeciesId): boolean {
     return this.fusionSpecies?.speciesId === species;
   }
 
   /**
-   * Checks if the {@linkcode Pokemon} has is the specified {@linkcode Species} or is fused with it.
+   * Checks if the {@linkcode Pokemon} has is the specified {@linkcode SpeciesId} or is fused with it.
-   * @param species the pokemon {@linkcode Species} to check
+   * @param species the pokemon {@linkcode SpeciesId} to check
    * @param formKey If provided, requires the species to be in that form
    * @returns `true` if the pokemon is the species or is fused with it, `false` otherwise
    */
-  hasSpecies(species: Species, formKey?: string): boolean {
+  hasSpecies(species: SpeciesId, formKey?: string): boolean {
     if (isNullOrUndefined(formKey)) {
       return this.species.speciesId === species || this.fusionSpecies?.speciesId === species;
     }
@@ -1848,7 +1848,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     const ret = !ignoreOverride && this.summonData.moveset ? this.summonData.moveset : this.moveset;
 
     // Overrides moveset based on arrays specified in overrides.ts
-    let overrideArray: Moves | Array<Moves> = this.isPlayer()
+    let overrideArray: MoveId | Array<MoveId> = this.isPlayer()
       ? Overrides.MOVESET_OVERRIDE
       : Overrides.OPP_MOVESET_OVERRIDE;
     if (!Array.isArray(overrideArray)) {
@@ -1858,7 +1858,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       if (!this.isPlayer()) {
         this.moveset = [];
       }
-      overrideArray.forEach((move: Moves, index: number) => {
+      overrideArray.forEach((move: MoveId, index: number) => {
         const ppUsed = this.moveset[index]?.ppUsed ?? 0;
         this.moveset[index] = new PokemonMove(move, Math.min(ppUsed, allMoves[move].pp));
       });
@@ -1871,11 +1871,11 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    * Checks which egg moves have been unlocked for the {@linkcode Pokemon} based
    * on the species it was met at or by the first {@linkcode Pokemon} in its evolution
    * line that can act as a starter and provides those egg moves.
-   * @returns an array of {@linkcode Moves}, the length of which is determined by how many
+   * @returns an array of {@linkcode MoveId}, the length of which is determined by how many
    * egg moves are unlocked for that species.
    */
-  getUnlockedEggMoves(): Moves[] {
+  getUnlockedEggMoves(): MoveId[] {
-    const moves: Moves[] = [];
+    const moves: MoveId[] = [];
     const species =
       this.metSpecies in speciesEggMoves ? this.metSpecies : this.getSpeciesForm(true).getRootSpeciesId(true);
     if (species in speciesEggMoves) {
@@ -1894,10 +1894,10 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    *
    * Available egg moves are only included if the {@linkcode Pokemon} was
    * in the starting party of the run and if Fresh Start is not active.
-   * @returns an array of {@linkcode Moves}, the length of which is determined
+   * @returns an array of {@linkcode MoveId}, the length of which is determined
    * by how many learnable moves there are for the {@linkcode Pokemon}.
    */
-  public getLearnableLevelMoves(): Moves[] {
+  public getLearnableLevelMoves(): MoveId[] {
     let levelMoves = this.getLevelMoves(1, true, false, true).map(lm => lm[1]);
     if (this.metBiome === -1 && !globalScene.gameMode.isFreshStartChallenge() && !globalScene.gameMode.isDaily) {
       levelMoves = this.getUnlockedEggMoves().concat(levelMoves);
@@ -2071,7 +2071,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       return allAbilities[this.customPokemonData.ability];
     }
     let abilityId = this.getSpeciesForm(ignoreOverride).getAbility(this.abilityIndex);
-    if (abilityId === Abilities.NONE) {
+    if (abilityId === AbilityId.NONE) {
       abilityId = this.species.ability1;
     }
     return allAbilities[abilityId];
@@ -2165,9 +2165,9 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       return false;
     }
     if (
-      ((Overrides.PASSIVE_ABILITY_OVERRIDE !== Abilities.NONE || Overrides.HAS_PASSIVE_ABILITY_OVERRIDE) &&
+      ((Overrides.PASSIVE_ABILITY_OVERRIDE !== AbilityId.NONE || Overrides.HAS_PASSIVE_ABILITY_OVERRIDE) &&
         this.isPlayer()) ||
-      ((Overrides.OPP_PASSIVE_ABILITY_OVERRIDE !== Abilities.NONE || Overrides.OPP_HAS_PASSIVE_ABILITY_OVERRIDE) &&
+      ((Overrides.OPP_PASSIVE_ABILITY_OVERRIDE !== AbilityId.NONE || Overrides.OPP_HAS_PASSIVE_ABILITY_OVERRIDE) &&
         !this.isPlayer())
     ) {
       return true;
@@ -2238,7 +2238,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    * @param ignoreOverride Whether to ignore ability changing effects; default `false`
    * @returns `true` if the ability is present and active
    */
-  public hasAbility(ability: Abilities, canApply = true, ignoreOverride = false): boolean {
+  public hasAbility(ability: AbilityId, canApply = true, ignoreOverride = false): boolean {
     if (this.getAbility(ignoreOverride).id === ability && (!canApply || this.canApplyAbility())) {
       return true;
     }
@@ -2291,11 +2291,11 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    * @returns the pokemon's current tera {@linkcode PokemonType}
    */
   getTeraType(): PokemonType {
-    if (this.hasSpecies(Species.TERAPAGOS)) {
+    if (this.hasSpecies(SpeciesId.TERAPAGOS)) {
       return PokemonType.STELLAR;
     }
-    if (this.hasSpecies(Species.OGERPON)) {
+    if (this.hasSpecies(SpeciesId.OGERPON)) {
-      const ogerponForm = this.species.speciesId === Species.OGERPON ? this.formIndex : this.fusionFormIndex;
+      const ogerponForm = this.species.speciesId === SpeciesId.OGERPON ? this.formIndex : this.fusionFormIndex;
       switch (ogerponForm) {
         case 0:
         case 4:
@@ -2311,7 +2311,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
           return PokemonType.ROCK;
       }
     }
-    if (this.hasSpecies(Species.SHEDINJA)) {
+    if (this.hasSpecies(SpeciesId.SHEDINJA)) {
       return PokemonType.BUG;
     }
     return this.teraType;
@@ -2321,7 +2321,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     return (
       !!this.getTag(GroundedTag) ||
       (!this.isOfType(PokemonType.FLYING, true, true) &&
-        !this.hasAbility(Abilities.LEVITATE) &&
+        !this.hasAbility(AbilityId.LEVITATE) &&
         !this.getTag(BattlerTagType.FLOATING) &&
         !this.getTag(SemiInvulnerableTag))
     );
@@ -2382,8 +2382,8 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     // then bypass the check for ion deluge and electrify
     if (
       this.isTerastallized &&
-      (move.id === Moves.TERA_BLAST ||
+      (move.id === MoveId.TERA_BLAST ||
-        (move.id === Moves.TERA_STARSTORM && moveTypeHolder.value === PokemonType.STELLAR))
+        (move.id === MoveId.TERA_STARSTORM && moveTypeHolder.value === PokemonType.STELLAR))
     ) {
       return moveTypeHolder.value as PokemonType;
     }
@@ -2780,7 +2780,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    * @param ret the output array to be pushed into.
    */
   private getUniqueMoves(levelMoves: LevelMoves, ret: LevelMoves): void {
-    const uniqueMoves: Moves[] = [];
+    const uniqueMoves: MoveId[] = [];
     for (const lm of levelMoves) {
       if (!uniqueMoves.find(m => m === lm[1])) {
         uniqueMoves.push(lm[1]);
@@ -2794,12 +2794,12 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    *
    * @returns list of egg moves
    */
-  getEggMoves(): Moves[] | undefined {
+  getEggMoves(): MoveId[] | undefined {
     return speciesEggMoves[this.getSpeciesForm().getRootSpeciesId()];
   }
 
-  setMove(moveIndex: number, moveId: Moves): void {
+  setMove(moveIndex: number, moveId: MoveId): void {
-    if (moveId === Moves.NONE) {
+    if (moveId === MoveId.NONE) {
       return;
     }
     const move = new PokemonMove(moveId);
@@ -2822,7 +2822,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    */
   trySetShiny(thresholdOverride?: number): boolean {
     // Shiny Pokemon should not spawn in the end biome in endless
-    if (globalScene.gameMode.isEndless && globalScene.arena.biomeType === Biome.END) {
+    if (globalScene.gameMode.isEndless && globalScene.arena.biomeType === BiomeId.END) {
       return false;
     }
 
@@ -2987,7 +2987,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
             !species.mythical &&
             !species.isTrainerForbidden() &&
             species.speciesId !== this.species.speciesId &&
-            species.speciesId !== Species.DITTO
+            species.speciesId !== SpeciesId.DITTO
           );
         };
 
@@ -3050,7 +3050,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
   /** Generates a semi-random moveset for a Pokemon */
   public generateAndPopulateMoveset(): void {
     this.moveset = [];
-    let movePool: [Moves, number][] = [];
+    let movePool: [MoveId, number][] = [];
     const allLevelMoves = this.getLevelMoves(1, true, true);
     if (!allLevelMoves) {
       console.warn("Error encountered trying to generate moveset for:", this.species.name);
@@ -3079,7 +3079,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     if (this.hasTrainer()) {
       const tms = Object.keys(tmSpecies);
       for (const tm of tms) {
-        const moveId = Number.parseInt(tm) as Moves;
+        const moveId = Number.parseInt(tm) as MoveId;
         let compatible = false;
         for (const p of tmSpecies[tm]) {
           if (Array.isArray(p)) {
@@ -3202,7 +3202,10 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     if (this.isBoss()) {
       weightMultiplier += 0.4;
     }
-    const baseWeights: [Moves, number][] = movePool.map(m => [m[0], Math.ceil(Math.pow(m[1], weightMultiplier) * 100)]);
+    const baseWeights: [MoveId, number][] = movePool.map(m => [
+      m[0],
+      Math.ceil(Math.pow(m[1], weightMultiplier) * 100),
+    ]);
 
     // All Pokemon force a STAB move first
     const stabMovePool = baseWeights.filter(
@@ -3656,7 +3659,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     if (
       source.isTerastallized &&
       source.getTeraType() === PokemonType.STELLAR &&
-      (!source.stellarTypesBoosted.includes(moveType) || source.hasSpecies(Species.TERAPAGOS))
+      (!source.stellarTypesBoosted.includes(moveType) || source.hasSpecies(SpeciesId.TERAPAGOS))
     ) {
       stabMultiplier.value += matchesSourceType ? 0.5 : 0.2;
     }
@@ -3724,7 +3727,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     if (cancelled.value || isTypeImmune) {
       return {
         cancelled: cancelled.value,
-        result: move.id === Moves.SHEER_COLD ? HitResult.IMMUNE : HitResult.NO_EFFECT,
+        result: move.id === MoveId.SHEER_COLD ? HitResult.IMMUNE : HitResult.NO_EFFECT,
         damage: 0,
       };
     }
@@ -4131,7 +4134,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     return !cancelled.value;
   }
 
-  addTag(tagType: BattlerTagType, turnCount = 0, sourceMove?: Moves, sourceId?: number): boolean {
+  addTag(tagType: BattlerTagType, turnCount = 0, sourceMove?: MoveId, sourceId?: number): boolean {
     const existingTag = this.getTag(tagType);
     if (existingTag) {
       existingTag.onOverlap(this);
@@ -4281,7 +4284,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
       if (
         !tag.isBatonPassable ||
         (tag.tagType === BattlerTagType.TELEKINESIS &&
-          this.species.speciesId === Species.GENGAR &&
+          this.species.speciesId === SpeciesId.GENGAR &&
           this.getFormKey() === "mega")
       ) {
         continue;
@@ -4300,19 +4303,19 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
   /**
    * Gets whether the given move is currently disabled for this Pokemon.
    *
-   * @param moveId - The {@linkcode Moves} ID of the move to check
+   * @param moveId - The {@linkcode MoveId} ID of the move to check
    * @returns `true` if the move is disabled for this Pokemon, otherwise `false`
    *
    * @see {@linkcode MoveRestrictionBattlerTag}
    */
-  public isMoveRestricted(moveId: Moves, pokemon?: Pokemon): boolean {
+  public isMoveRestricted(moveId: MoveId, pokemon?: Pokemon): boolean {
     return this.getRestrictingTag(moveId, pokemon) !== null;
   }
 
   /**
    * Gets whether the given move is currently disabled for the user based on the player's target selection
    *
-   * @param moveId - The {@linkcode Moves} ID of the move to check
+   * @param moveId - The {@linkcode MoveId} ID of the move to check
    * @param user - The move user
    * @param target - The target of the move
    *
@@ -4320,7 +4323,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
    *
    * @see {@linkcode MoveRestrictionBattlerTag}
    */
-  isMoveTargetRestricted(moveId: Moves, user: Pokemon, target: Pokemon): boolean {
+  isMoveTargetRestricted(moveId: MoveId, user: Pokemon, target: Pokemon): boolean {
     for (const tag of this.findTags(t => t instanceof MoveRestrictionBattlerTag)) {
       if ((tag as MoveRestrictionBattlerTag).isMoveTargetRestricted(moveId, user, target)) {
         return (tag as MoveRestrictionBattlerTag) !== null;
@@ -4332,12 +4335,12 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
   /**
    * Gets the {@link MoveRestrictionBattlerTag} that is restricting a move, if it exists.
    *
-   * @param moveId - {@linkcode Moves} ID of the move to check
+   * @param moveId - {@linkcode MoveId} ID of the move to check
    * @param user - {@linkcode Pokemon} the move user, optional and used when the target is a factor in the move's restricted status
    * @param target - {@linkcode Pokemon} the target of the move, optional and used when the target is a factor in the move's restricted status
    * @returns The first tag on this Pokemon that restricts the move, or `null` if the move is not restricted.
    */
-  getRestrictingTag(moveId: Moves, user?: Pokemon, target?: Pokemon): MoveRestrictionBattlerTag | null {
+  getRestrictingTag(moveId: MoveId, user?: Pokemon, target?: Pokemon): MoveRestrictionBattlerTag | null {
     for (const tag of this.findTags(t => t instanceof MoveRestrictionBattlerTag)) {
       if ((tag as MoveRestrictionBattlerTag).isMoveRestricted(moveId, user)) {
         return tag as MoveRestrictionBattlerTag;
@@ -4899,7 +4902,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
     if (
       this.hasAbilityWithAttr(CommanderAbAttr) &&
       globalScene.currentBattle.double &&
-      this.getAlly()?.species.speciesId === Species.DONDOZO
+      this.getAlly()?.species.speciesId === SpeciesId.DONDOZO
     ) {
       this.setVisible(false);
     }
@@ -5509,7 +5512,7 @@ export default abstract class Pokemon extends Phaser.GameObjects.Container {
 
 export class PlayerPokemon extends Pokemon {
   protected battleInfo: PlayerBattleInfo;
-  public compatibleTms: Moves[];
+  public compatibleTms: MoveId[];
 
   constructor(
     species: PokemonSpecies,
@@ -5580,7 +5583,7 @@ export class PlayerPokemon extends Pokemon {
 
     const tms = Object.keys(tmSpecies);
     for (const tm of tms) {
-      const moveId = Number.parseInt(tm) as Moves;
+      const moveId = Number.parseInt(tm) as MoveId;
       let compatible = false;
       for (const p of tmSpecies[tm]) {
         if (Array.isArray(p)) {
@@ -5677,7 +5680,7 @@ export class PlayerPokemon extends Pokemon {
       }
       // Add to candy progress for this mon's starter species and its fused species (if it has one)
       starterData.forEach((sd: StarterDataEntry, i: number) => {
-        const speciesId = !i ? starterSpeciesId : (fusionStarterSpeciesId as Species);
+        const speciesId = !i ? starterSpeciesId : (fusionStarterSpeciesId as SpeciesId);
         sd.friendship = (sd.friendship || 0) + starterAmount.value;
         if (sd.friendship >= getStarterValueFriendshipCap(speciesStarterCosts[speciesId])) {
           globalScene.gameData.addStarterCandy(getPokemonSpecies(speciesId), 1);
@@ -5812,7 +5815,7 @@ export class PlayerPokemon extends Pokemon {
           this.updateInfo(true).then(() => resolve());
         });
       };
-      if (preEvolution.speciesId === Species.GIMMIGHOUL) {
+      if (preEvolution.speciesId === SpeciesId.GIMMIGHOUL) {
         const evotracker = this.getHeldItems().filter(m => m instanceof EvoTrackerModifier)[0] ?? null;
         if (evotracker) {
           globalScene.removeModifier(evotracker);
@@ -5832,7 +5835,7 @@ export class PlayerPokemon extends Pokemon {
     const isFusion = evolution instanceof FusionSpeciesFormEvolution;
 
     const evoSpecies = !isFusion ? this.species : this.fusionSpecies;
-    if (evoSpecies?.speciesId === Species.NINCADA && evolution.speciesId === Species.NINJASK) {
+    if (evoSpecies?.speciesId === SpeciesId.NINCADA && evolution.speciesId === SpeciesId.NINJASK) {
       const newEvolution = pokemonEvolutions[evoSpecies.speciesId][1];
 
       if (newEvolution.condition?.predicate(this)) {
@@ -6108,7 +6111,7 @@ export class EnemyPokemon extends Pokemon {
 
       this.luck = (this.shiny ? this.variant + 1 : 0) + (this.fusionShiny ? this.fusionVariant + 1 : 0);
 
-      let prevolution: Species;
+      let prevolution: SpeciesId;
       let speciesId = species.speciesId;
       while ((prevolution = pokemonPrevolutions[speciesId])) {
         const evolution = pokemonEvolutions[prevolution].find(
@@ -6164,30 +6167,30 @@ export class EnemyPokemon extends Pokemon {
 
   generateAndPopulateMoveset(formIndex?: number): void {
     switch (true) {
-      case this.species.speciesId === Species.SMEARGLE:
+      case this.species.speciesId === SpeciesId.SMEARGLE:
         this.moveset = [
-          new PokemonMove(Moves.SKETCH),
+          new PokemonMove(MoveId.SKETCH),
-          new PokemonMove(Moves.SKETCH),
+          new PokemonMove(MoveId.SKETCH),
-          new PokemonMove(Moves.SKETCH),
+          new PokemonMove(MoveId.SKETCH),
-          new PokemonMove(Moves.SKETCH),
+          new PokemonMove(MoveId.SKETCH),
         ];
         break;
-      case this.species.speciesId === Species.ETERNATUS:
+      case this.species.speciesId === SpeciesId.ETERNATUS:
         this.moveset = (formIndex !== undefined ? formIndex : this.formIndex)
           ? [
-              new PokemonMove(Moves.DYNAMAX_CANNON),
+              new PokemonMove(MoveId.DYNAMAX_CANNON),
-              new PokemonMove(Moves.CROSS_POISON),
+              new PokemonMove(MoveId.CROSS_POISON),
-              new PokemonMove(Moves.FLAMETHROWER),
+              new PokemonMove(MoveId.FLAMETHROWER),
-              new PokemonMove(Moves.RECOVER, 0, -4),
+              new PokemonMove(MoveId.RECOVER, 0, -4),
             ]
           : [
-              new PokemonMove(Moves.ETERNABEAM),
+              new PokemonMove(MoveId.ETERNABEAM),
-              new PokemonMove(Moves.SLUDGE_BOMB),
+              new PokemonMove(MoveId.SLUDGE_BOMB),
-              new PokemonMove(Moves.FLAMETHROWER),
+              new PokemonMove(MoveId.FLAMETHROWER),
-              new PokemonMove(Moves.COSMIC_POWER),
+              new PokemonMove(MoveId.COSMIC_POWER),
             ];
         if (globalScene.gameMode.hasChallenge(Challenges.INVERSE_BATTLE)) {
-          this.moveset[2] = new PokemonMove(Moves.THUNDERBOLT);
+          this.moveset[2] = new PokemonMove(MoveId.THUNDERBOLT);
         }
         break;
       default:
@@ -6273,7 +6276,7 @@ export class EnemyPokemon extends Pokemon {
               moveTargets.some(p => {
                 const doesNotFail =
                   move.applyConditions(this, p, move) ||
-                  [Moves.SUCKER_PUNCH, Moves.UPPER_HAND, Moves.THUNDERCLAP].includes(move.id);
+                  [MoveId.SUCKER_PUNCH, MoveId.UPPER_HAND, MoveId.THUNDERCLAP].includes(move.id);
                 return (
                   doesNotFail &&
                   p.getAttackDamage({
@@ -6332,7 +6335,7 @@ export class EnemyPokemon extends Pokemon {
                */
               if (
                 (move.name.endsWith(" (N)") || !move.applyConditions(this, target, move)) &&
-                ![Moves.SUCKER_PUNCH, Moves.UPPER_HAND, Moves.THUNDERCLAP].includes(move.id)
+                ![MoveId.SUCKER_PUNCH, MoveId.UPPER_HAND, MoveId.THUNDERCLAP].includes(move.id)
               ) {
                 targetScore = -20;
               } else if (move instanceof AttackMove) {
@@ -6417,17 +6420,17 @@ export class EnemyPokemon extends Pokemon {
     }
 
     return {
-      move: Moves.STRUGGLE,
+      move: MoveId.STRUGGLE,
-      targets: this.getNextTargets(Moves.STRUGGLE),
+      targets: this.getNextTargets(MoveId.STRUGGLE),
     };
   }
 
   /**
    * Determines the Pokemon the given move would target if used by this Pokemon
-   * @param moveId {@linkcode Moves} The move to be used
+   * @param moveId {@linkcode MoveId} The move to be used
    * @returns The indexes of the Pokemon the given move would target
    */
-  getNextTargets(moveId: Moves): BattlerIndex[] {
+  getNextTargets(moveId: MoveId): BattlerIndex[] {
     const moveTargets = getMoveTargets(this, moveId);
     const targets = globalScene.getField(true).filter(p => moveTargets.targets.indexOf(p.getBattlerIndex()) > -1);
     // If the move is multi-target, return all targets' indexes
@@ -6702,7 +6705,6 @@ export class EnemyPokemon extends Pokemon {
     return ret;
   }
 
-  
   /**
    * Show or hide the type effectiveness multiplier window
    * Passing undefined will hide the window
@@ -6735,7 +6737,7 @@ interface IllusionData {
     fusionVariant: Variant;
   };
   /** The species of the illusion */
-  species: Species;
+  species: SpeciesId;
   /** The formIndex of the illusion */
   formIndex: number;
   /** The gender of the illusion */
@@ -6753,7 +6755,7 @@ interface IllusionData {
 }
 
 export interface TurnMove {
-  move: Moves;
+  move: MoveId;
   targets: BattlerIndex[];
   result?: MoveResult;
   virtual?: boolean;
@@ -6762,7 +6764,7 @@ export interface TurnMove {
 }
 
 export interface AttackMoveResult {
-  move: Moves;
+  move: MoveId;
   result: DamageResult;
   damage: number;
   critical: boolean;
@@ -6785,8 +6787,8 @@ export class PokemonSummonData {
   // TODO: Move these into a separate class & add rage fist hit count
   public speciesForm: PokemonSpeciesForm | null = null;
   public fusionSpeciesForm: PokemonSpeciesForm | null = null;
-  public ability: Abilities | undefined;
+  public ability: AbilityId | undefined;
-  public passiveAbility: Abilities | undefined;
+  public passiveAbility: AbilityId | undefined;
   public gender: Gender | undefined;
   public fusionGender: Gender | undefined;
   public stats: number[] = [0, 0, 0, 0, 0, 0];
@@ -6800,7 +6802,7 @@ export class PokemonSummonData {
   public illusion: IllusionData | null = null;
   public illusionBroken = false;
 
-  /** Array containing all berries eaten in the last turn; used by {@linkcode Abilities.CUD_CHEW} */
+  /** Array containing all berries eaten in the last turn; used by {@linkcode AbilityId.CUD_CHEW} */
   public berriesEatenLast: BerryType[] = [];
 
   /**
@@ -6849,7 +6851,7 @@ export class PokemonTempSummonData {
    * Reset on switch and new wave, but not stored in `SummonData` to avoid being written to the save file.
 
    * Used to evaluate "first turn only" conditions such as
-   * {@linkcode Moves.FAKE_OUT | Fake Out} and {@linkcode Moves.FIRST_IMPRESSION | First Impression}).
+   * {@linkcode MoveId.FAKE_OUT | Fake Out} and {@linkcode MoveId.FIRST_IMPRESSION | First Impression}).
    */
   waveTurnCount = 1;
 }
@@ -6859,11 +6861,11 @@ export class PokemonTempSummonData {
  * Resets at the start of a new battle (but not on switch).
  */
 export class PokemonBattleData {
-  /** Counter tracking direct hits this Pokemon has received during this battle; used for {@linkcode Moves.RAGE_FIST} */
+  /** Counter tracking direct hits this Pokemon has received during this battle; used for {@linkcode MoveId.RAGE_FIST} */
   public hitCount = 0;
-  /** Whether this Pokemon has eaten a berry this battle; used for {@linkcode Moves.BELCH} */
+  /** Whether this Pokemon has eaten a berry this battle; used for {@linkcode MoveId.BELCH} */
   public hasEatenBerry = false;
-  /** Array containing all berries eaten and not yet recovered during this current battle; used by {@linkcode Abilities.HARVEST} */
+  /** Array containing all berries eaten and not yet recovered during this current battle; used by {@linkcode AbilityId.HARVEST} */
   public berriesEaten: BerryType[] = [];
 
   constructor(source?: PokemonBattleData | Partial<PokemonBattleData>) {
@@ -6886,7 +6888,7 @@ export class PokemonWaveData {
    * A set of all the abilities this {@linkcode Pokemon} has used in this wave.
    * Used to track once per battle conditions, as well as (hopefully) by the updated AI for move effectiveness.
    */
-  public abilitiesApplied: Set<Abilities> = new Set<Abilities>();
+  public abilitiesApplied: Set<AbilityId> = new Set<AbilityId>();
   /** Whether the pokemon's ability has been revealed or not */
   public abilityRevealed = false;
 }
@@ -6913,7 +6915,7 @@ export class PokemonTurnData {
   public statStagesIncreased = false;
   public statStagesDecreased = false;
   public moveEffectiveness: TypeDamageMultiplier | null = null;
-  public combiningPledge?: Moves;
+  public combiningPledge?: MoveId;
   public switchedInThisTurn = false;
   public failedRunAway = false;
   public joinedRound = false;
@@ -6924,7 +6926,7 @@ export class PokemonTurnData {
   public extraTurns = 0;
   /**
    * All berries eaten by this pokemon in this turn.
-   * Saved into {@linkcode PokemonSummonData | SummonData} by {@linkcode Abilities.CUD_CHEW} on turn end.
+   * Saved into {@linkcode PokemonSummonData | SummonData} by {@linkcode AbilityId.CUD_CHEW} on turn end.
    * @see {@linkcode PokemonSummonData.berriesEatenLast}
    */
   public berriesEaten: BerryType[] = [];
@@ -6993,7 +6995,7 @@ export interface DamageCalculationResult {
  * @see {@linkcode getName} - returns name of {@linkcode Move}.
  **/
 export class PokemonMove {
-  public moveId: Moves;
+  public moveId: MoveId;
   public ppUsed: number;
   public ppUp: number;
   public virtual: boolean;
@@ -7004,7 +7006,7 @@ export class PokemonMove {
    */
   public maxPpOverride?: number;
 
-  constructor(moveId: Moves, ppUsed = 0, ppUp = 0, virtual = false, maxPpOverride?: number) {
+  constructor(moveId: MoveId, ppUsed = 0, ppUp = 0, virtual = false, maxPpOverride?: number) {
     this.moveId = moveId;
     this.ppUsed = ppUsed;
     this.ppUp = ppUp;

src/field/trainer.ts

@@ -17,7 +17,7 @@ import { ArenaTagSide, ArenaTrapTag } from "#app/data/arena-tag";
 import { getIsInitialized, initI18n } from "#app/plugins/i18n";
 import i18next from "i18next";
 import { PartyMemberStrength } from "#enums/party-member-strength";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { TrainerType } from "#enums/trainer-type";
 import { signatureSpecies } from "#app/data/balance/signature-species";
 
@@ -358,7 +358,7 @@ export default class Trainer extends Phaser.GameObjects.Container {
         }
 
         // Create an empty species pool (which will be set to one of the species pools based on the index)
-        let newSpeciesPool: Species[] = [];
+        let newSpeciesPool: SpeciesId[] = [];
         let useNewSpeciesPool = false;
 
         // If we are in a double battle of named trainers, we need to use alternate species pools (generate half the party from each trainer)
@@ -399,9 +399,9 @@ export default class Trainer extends Phaser.GameObjects.Container {
           if (!(index % 2)) {
             // Since the only currently allowed double battle with named trainers is Tate & Liza, we need to make sure that Solrock is the first pokemon in the party for Tate and Lunatone for Liza
             if (index === 0 && TrainerType[this.config.trainerType] === TrainerType[TrainerType.TATE]) {
-              newSpeciesPool = [Species.SOLROCK];
+              newSpeciesPool = [SpeciesId.SOLROCK];
             } else if (index === 0 && TrainerType[this.config.trainerType] === TrainerType[TrainerType.LIZA]) {
-              newSpeciesPool = [Species.LUNATONE];
+              newSpeciesPool = [SpeciesId.LUNATONE];
             } else {
               newSpeciesPool = speciesPoolFiltered;
             }
@@ -409,9 +409,9 @@ export default class Trainer extends Phaser.GameObjects.Container {
             // If the index is odd, use the species pool for the partner trainer (that way he only uses his own pokemon in battle)
             // Since the only currently allowed double battle with named trainers is Tate & Liza, we need to make sure that Solrock is the first pokemon in the party for Tate and Lunatone for Liza
             if (index === 1 && TrainerType[this.config.trainerTypeDouble] === TrainerType[TrainerType.TATE]) {
-              newSpeciesPool = [Species.SOLROCK];
+              newSpeciesPool = [SpeciesId.SOLROCK];
             } else if (index === 1 && TrainerType[this.config.trainerTypeDouble] === TrainerType[TrainerType.LIZA]) {
-              newSpeciesPool = [Species.LUNATONE];
+              newSpeciesPool = [SpeciesId.LUNATONE];
             } else {
               newSpeciesPool = speciesPoolPartnerFiltered;
             }
@@ -542,10 +542,10 @@ export default class Trainer extends Phaser.GameObjects.Container {
 
   /**
    * Checks if the enemy trainer already has the Pokemon species in their party
-   * @param baseSpecies - The base {@linkcode Species} of the current Pokemon
+   * @param baseSpecies - The base {@linkcode SpeciesId} of the current Pokemon
    * @returns `true` if the species is already present in the party
    */
-  checkDuplicateSpecies(baseSpecies: Species): boolean {
+  checkDuplicateSpecies(baseSpecies: SpeciesId): boolean {
     const staticSpecies = (signatureSpecies[TrainerType[this.config.trainerType]] ?? []).flat(1).map(s => {
       let root = s;
       while (pokemonPrevolutions.hasOwnProperty(root)) {

src/game-mode.ts

@@ -8,8 +8,8 @@ import { allSpecies } from "./data/pokemon-species";
 import type { Arena } from "./field/arena";
 import Overrides from "#app/overrides";
 import { isNullOrUndefined, randSeedInt, randSeedItem } from "#app/utils/common";
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { Challenges } from "./enums/challenges";
 import { globalScene } from "#app/global-scene";
 import { getDailyStartingBiome } from "./data/daily-run";
@@ -128,7 +128,7 @@ export class GameMode implements GameModeConfig {
    * - random biome for Daily mode
    * - Town
    */
-  getStartingBiome(): Biome {
+  getStartingBiome(): BiomeId {
     if (!isNullOrUndefined(Overrides.STARTING_BIOME_OVERRIDE)) {
       return Overrides.STARTING_BIOME_OVERRIDE;
     }
@@ -137,7 +137,7 @@ export class GameMode implements GameModeConfig {
       case GameModes.DAILY:
         return getDailyStartingBiome();
       default:
-        return Biome.TOWN;
+        return BiomeId.TOWN;
     }
   }
 
@@ -202,14 +202,14 @@ export class GameMode implements GameModeConfig {
     return false;
   }
 
-  isTrainerBoss(waveIndex: number, biomeType: Biome, offsetGym: boolean): boolean {
+  isTrainerBoss(waveIndex: number, biomeType: BiomeId, offsetGym: boolean): boolean {
     switch (this.modeId) {
       case GameModes.DAILY:
         return waveIndex > 10 && waveIndex < 50 && !(waveIndex % 10);
       default:
         return (
           waveIndex % 30 === (offsetGym ? 0 : 20) &&
-          (biomeType !== Biome.END || this.isClassic || this.isWaveFinal(waveIndex))
+          (biomeType !== BiomeId.END || this.isClassic || this.isWaveFinal(waveIndex))
         );
     }
   }
@@ -220,8 +220,8 @@ export class GameMode implements GameModeConfig {
         s =>
           (s.subLegendary || s.legendary || s.mythical) &&
           s.baseTotal >= 600 &&
-          s.speciesId !== Species.ETERNATUS &&
+          s.speciesId !== SpeciesId.ETERNATUS &&
-          s.speciesId !== Species.ARCEUS,
+          s.speciesId !== SpeciesId.ARCEUS,
       );
       return randSeedItem(allFinalBossSpecies);
     }

src/loading-scene.ts

@@ -18,7 +18,7 @@ import { initChallenges } from "#app/data/challenge";
 import i18next from "i18next";
 import { initStatsKeys } from "#app/ui/game-stats-ui-handler";
 import { initVouchers } from "#app/system/voucher";
-import { Biome } from "#enums/biome";
+import { BiomeId } from "#enums/biome-id";
 import { initMysteryEncounters } from "#app/data/mystery-encounters/mystery-encounters";
 import { timedEventManager } from "./global-event-manager";
 
@@ -177,8 +177,8 @@ export class LoadingScene extends SceneBase {
 
     this.loadImage("default_bg", "arenas");
     // Load arena images
-    getEnumValues(Biome).map(bt => {
+    getEnumValues(BiomeId).map(bt => {
-      const btKey = Biome[bt].toLowerCase();
+      const btKey = BiomeId[bt].toLowerCase();
       const isBaseAnimated = btKey === "end";
       const baseAKey = `${btKey}_a`;
       const baseBKey = `${btKey}_b`;

src/modifier/modifier-type.ts

@@ -116,13 +116,13 @@ import {
   padInt,
   randSeedInt,
 } from "#app/utils/common";
-import { Abilities } from "#enums/abilities";
+import { AbilityId } from "#enums/ability-id";
 import { BattlerTagType } from "#enums/battler-tag-type";
 import { BerryType } from "#enums/berry-type";
-import { Moves } from "#enums/moves";
+import { MoveId } from "#enums/move-id";
 import { Nature } from "#enums/nature";
 import { PokeballType } from "#enums/pokeball";
-import { Species } from "#enums/species";
+import { SpeciesId } from "#enums/species-id";
 import { SpeciesFormKey } from "#enums/species-form-key";
 import type { PermanentStat, TempBattleStat } from "#enums/stat";
 import { getStatKey, Stat, TEMP_BATTLE_STATS } from "#enums/stat";
@@ -430,7 +430,7 @@ export class TerastallizeModifierType extends PokemonModifierType {
       (pokemon: PlayerPokemon) => {
         if (
           [pokemon.species.speciesId, pokemon.fusionSpecies?.speciesId].filter(
-            s => s === Species.TERAPAGOS || s === Species.OGERPON || s === Species.SHEDINJA,
+            s => s === SpeciesId.TERAPAGOS || s === SpeciesId.OGERPON || s === SpeciesId.SHEDINJA,
           ).length > 0
         ) {
           return PartyUiHandler.NoEffectMessage;
@@ -1165,9 +1165,9 @@ export class PokemonMultiHitModifierType extends PokemonHeldItemModifierType {
 }
 
 export class TmModifierType extends PokemonModifierType {
-  public moveId: Moves;
+  public moveId: MoveId;
 
-  constructor(moveId: Moves) {
+  constructor(moveId: MoveId) {
     super(
       "",
       `tm_${PokemonType[allMoves[moveId].type].toLowerCase()}`,
@@ -1439,37 +1439,37 @@ class SpeciesStatBoosterModifierTypeGenerator extends ModifierTypeGenerator {
     LIGHT_BALL: {
       stats: [Stat.ATK, Stat.SPATK],
       multiplier: 2,
-      species: [Species.PIKACHU],
+      species: [SpeciesId.PIKACHU],
       rare: true,
     },
     THICK_CLUB: {
       stats: [Stat.ATK],
       multiplier: 2,
-      species: [Species.CUBONE, Species.MAROWAK, Species.ALOLA_MAROWAK],
+      species: [SpeciesId.CUBONE, SpeciesId.MAROWAK, SpeciesId.ALOLA_MAROWAK],
       rare: true,
     },
     METAL_POWDER: {
       stats: [Stat.DEF],
       multiplier: 2,
-      species: [Species.DITTO],
+      species: [SpeciesId.DITTO],
       rare: true,
     },
     QUICK_POWDER: {
       stats: [Stat.SPD],
       multiplier: 2,
-      species: [Species.DITTO],
+      species: [SpeciesId.DITTO],
       rare: true,
     },
     DEEP_SEA_SCALE: {
       stats: [Stat.SPDEF],
       multiplier: 2,
-      species: [Species.CLAMPERL],
+      species: [SpeciesId.CLAMPERL],
       rare: false,
     },
     DEEP_SEA_TOOTH: {
       stats: [Stat.SPATK],
       multiplier: 2,
-      species: [Species.CLAMPERL],
+      species: [SpeciesId.CLAMPERL],
       rare: false,
     },
   };
@@ -1498,7 +1498,7 @@ class SpeciesStatBoosterModifierTypeGenerator extends ModifierTypeGenerator {
         const speciesId = p.getSpeciesForm(true).speciesId;
         const fusionSpeciesId = p.isFusion() ? p.getFusionSpeciesForm(true).speciesId : null;
         // TODO: Use commented boolean when Fling is implemented
-        const hasFling = false; /* p.getMoveset(true).some(m => m.moveId === Moves.FLING) */
+        const hasFling = false; /* p.getMoveset(true).some(m => m.moveId === MoveId.FLING) */
 
         for (const i in values) {
           const checkedSpecies = values[i].species;
@@ -1517,7 +1517,7 @@ class SpeciesStatBoosterModifierTypeGenerator extends ModifierTypeGenerator {
             if (checkedSpecies.includes(speciesId) || (!!fusionSpeciesId && checkedSpecies.includes(fusionSpeciesId))) {
               // Add weight if party member has a matching species or, if applicable, a matching fusion species
               weights[i]++;
-            } else if (checkedSpecies.includes(Species.PIKACHU) && hasFling) {
+            } else if (checkedSpecies.includes(SpeciesId.PIKACHU) && hasFling) {
               // Add weight to Light Ball if party member has Fling
               weights[i]++;
             }
@@ -1553,8 +1553,8 @@ class SpeciesStatBoosterModifierTypeGenerator extends ModifierTypeGenerator {
 class TmModifierTypeGenerator extends ModifierTypeGenerator {
   constructor(tier: ModifierTier) {
     super((party: Pokemon[], pregenArgs?: any[]) => {
-      if (pregenArgs && pregenArgs.length === 1 && pregenArgs[0] in Moves) {
+      if (pregenArgs && pregenArgs.length === 1 && pregenArgs[0] in MoveId) {
-        return new TmModifierType(pregenArgs[0] as Moves);
+        return new TmModifierType(pregenArgs[0] as MoveId);
       }
       const partyMemberCompatibleTms = party.map(p => {
         const previousLevelMoves = p.getLearnableLevelMoves();
@@ -1588,7 +1588,9 @@ class EvolutionItemModifierTypeGenerator extends ModifierTypeGenerator {
           .filter(
             p =>
               pokemonEvolutions.hasOwnProperty(p.species.speciesId) &&
-              (!p.pauseEvolutions || p.species.speciesId === Species.SLOWPOKE || p.species.speciesId === Species.EEVEE),
+              (!p.pauseEvolutions ||
+                p.species.speciesId === SpeciesId.SLOWPOKE ||
+                p.species.speciesId === SpeciesId.EEVEE),
           )
           .flatMap(p => {
             const evolutions = pokemonEvolutions[p.species.speciesId];
@@ -1606,8 +1608,8 @@ class EvolutionItemModifierTypeGenerator extends ModifierTypeGenerator {
               p.fusionSpecies &&
               pokemonEvolutions.hasOwnProperty(p.fusionSpecies.speciesId) &&
               (!p.pauseEvolutions ||
-                p.fusionSpecies.speciesId === Species.SLOWPOKE ||
+                p.fusionSpecies.speciesId === SpeciesId.SLOWPOKE ||
-                p.fusionSpecies.speciesId === Species.EEVEE),
+                p.fusionSpecies.speciesId === SpeciesId.EEVEE),
           )
           .flatMap(p => {
             const evolutions = pokemonEvolutions[p.fusionSpecies!.speciesId];
@@ -1671,7 +1673,7 @@ class FormChangeItemModifierTypeGenerator extends ModifierTypeGenerator {
                     ),
                 );
 
-              if (p.species.speciesId === Species.NECROZMA) {
+              if (p.species.speciesId === SpeciesId.NECROZMA) {
                 // technically we could use a simplified version and check for formChanges.length > 3, but in case any code changes later, this might break...
                 let foundULTRA_Z = false,
                   foundN_LUNA = false,
@@ -1904,7 +1906,7 @@ export type GeneratorModifierOverride = {
     }
   | {
       name: keyof Pick<typeof modifierTypes, "TM_COMMON" | "TM_GREAT" | "TM_ULTRA">;
-      type?: Moves;
+      type?: MoveId;
     }
 );
 
@@ -1932,7 +1934,7 @@ export const modifierTypes = {
     new PokemonHeldItemModifierType(
       "modifierType:ModifierType.EVOLUTION_TRACKER_GIMMIGHOUL",
       "relic_gold",
-      (type, args) => new EvoTrackerModifier(type, (args[0] as Pokemon).id, Species.GIMMIGHOUL, 10),
+      (type, args) => new EvoTrackerModifier(type, (args[0] as Pokemon).id, SpeciesId.GIMMIGHOUL, 10),
     ),
 
   MEGA_BRACELET: () =>
@@ -2046,7 +2048,9 @@ export const modifierTypes = {
       }
       const teraTypes: PokemonType[] = [];
       for (const p of party) {
-        if (!(p.hasSpecies(Species.TERAPAGOS) || p.hasSpecies(Species.OGERPON) || p.hasSpecies(Species.SHEDINJA))) {
+        if (
+          !(p.hasSpecies(SpeciesId.TERAPAGOS) || p.hasSpecies(SpeciesId.OGERPON) || p.hasSpecies(SpeciesId.SHEDINJA))
+        ) {
           teraTypes.push(p.teraType);
         }
       }
@@ -2125,9 +2129,9 @@ export const modifierTypes = {
       "leek",
       (type, args) =>
         new SpeciesCritBoosterModifier(type, (args[0] as Pokemon).id, 2, [
-          Species.FARFETCHD,
+          SpeciesId.FARFETCHD,
-          Species.GALAR_FARFETCHD,
+          SpeciesId.GALAR_FARFETCHD,
-          Species.SIRFETCHD,
+          SpeciesId.SIRFETCHD,
         ]),
     ),
 
@@ -2674,7 +2678,8 @@ const modifierPool: ModifierPool = {
     new WeightedModifierType(modifierTypes.BASE_STAT_BOOSTER, 3),
     new WeightedModifierType(modifierTypes.TERA_SHARD, (party: Pokemon[]) =>
       party.filter(
-        p => !(p.hasSpecies(Species.TERAPAGOS) || p.hasSpecies(Species.OGERPON) || p.hasSpecies(Species.SHEDINJA)),
+        p =>
+          !(p.hasSpecies(SpeciesId.TERAPAGOS) || p.hasSpecies(SpeciesId.OGERPON) || p.hasSpecies(SpeciesId.SHEDINJA)),
       ).length > 0
         ? 1
         : 0,
@@ -2744,7 +2749,7 @@ const modifierPool: ModifierPool = {
     new WeightedModifierType(
       modifierTypes.LEEK,
       (party: Pokemon[]) => {
-        const checkedSpecies = [Species.FARFETCHD, Species.GALAR_FARFETCHD, Species.SIRFETCHD];
+        const checkedSpecies = [SpeciesId.FARFETCHD, SpeciesId.GALAR_FARFETCHD, SpeciesId.SIRFETCHD];
         // If a party member doesn't already have a Leek and is one of the relevant species, Leek can appear
         return party.some(
           p =>
@@ -2771,25 +2776,25 @@ const modifierPool: ModifierPool = {
             const canSetStatus = p.canSetStatus(StatusEffect.TOXIC, true, true, null, true);
 
             // Moves that take advantage of obtaining the actual status effect
-            const hasStatusMoves = [Moves.FACADE, Moves.PSYCHO_SHIFT].some(m => moveset.includes(m));
+            const hasStatusMoves = [MoveId.FACADE, MoveId.PSYCHO_SHIFT].some(m => moveset.includes(m));
             // Moves that take advantage of being able to give the target a status orb
             // TODO: Take moves (Trick, Fling, Switcheroo) from comment when they are implemented
             const hasItemMoves = [
-              /* Moves.TRICK, Moves.FLING, Moves.SWITCHEROO */
+              /* MoveId.TRICK, MoveId.FLING, MoveId.SWITCHEROO */
             ].some(m => moveset.includes(m));
 
             if (canSetStatus) {
               // Abilities that take advantage of obtaining the actual status effect, separated based on specificity to the orb
               const hasGeneralAbility = [
-                Abilities.QUICK_FEET,
+                AbilityId.QUICK_FEET,
-                Abilities.GUTS,
+                AbilityId.GUTS,
-                Abilities.MARVEL_SCALE,
+                AbilityId.MARVEL_SCALE,
-                Abilities.MAGIC_GUARD,
+                AbilityId.MAGIC_GUARD,
               ].some(a => p.hasAbility(a, false, true));
-              const hasSpecificAbility = [Abilities.TOXIC_BOOST, Abilities.POISON_HEAL].some(a =>
+              const hasSpecificAbility = [AbilityId.TOXIC_BOOST, AbilityId.POISON_HEAL].some(a =>
                 p.hasAbility(a, false, true),
               );
-              const hasOppositeAbility = [Abilities.FLARE_BOOST].some(a => p.hasAbility(a, false, true));
+              const hasOppositeAbility = [AbilityId.FLARE_BOOST].some(a => p.hasAbility(a, false, true));
 
               return hasSpecificAbility || (hasGeneralAbility && !hasOppositeAbility) || hasStatusMoves;
             }
@@ -2817,23 +2822,23 @@ const modifierPool: ModifierPool = {
             const canSetStatus = p.canSetStatus(StatusEffect.BURN, true, true, null, true);
 
             // Moves that take advantage of obtaining the actual status effect
-            const hasStatusMoves = [Moves.FACADE, Moves.PSYCHO_SHIFT].some(m => moveset.includes(m));
+            const hasStatusMoves = [MoveId.FACADE, MoveId.PSYCHO_SHIFT].some(m => moveset.includes(m));
             // Moves that take advantage of being able to give the target a status orb
             // TODO: Take moves (Trick, Fling, Switcheroo) from comment when they are implemented
             const hasItemMoves = [
-              /* Moves.TRICK, Moves.FLING, Moves.SWITCHEROO */
+              /* MoveId.TRICK, MoveId.FLING, MoveId.SWITCHEROO */
             ].some(m => moveset.includes(m));
 
             if (canSetStatus) {
               // Abilities that take advantage of obtaining the actual status effect, separated based on specificity to the orb
               const hasGeneralAbility = [
-                Abilities.QUICK_FEET,
+                AbilityId.QUICK_FEET,
-                Abilities.GUTS,
+                AbilityId.GUTS,
-                Abilities.MARVEL_SCALE,
+                AbilityId.MARVEL_SCALE,
-                Abilities.MAGIC_GUARD,
+                AbilityId.MAGIC_GUARD,
               ].some(a => p.hasAbility(a, false, true));
-              const hasSpecificAbility = [Abilities.FLARE_BOOST].some(a => p.hasAbility(a, false, true));
+              const hasSpecificAbility = [AbilityId.FLARE_BOOST].some(a => p.hasAbility(a, false, true));
-              const hasOppositeAbility = [Abilities.TOXIC_BOOST, Abilities.POISON_HEAL].some(a =>
+              const hasOppositeAbility = [AbilityId.TOXIC_BOOST, AbilityId.POISON_HEAL].some(a =>
                 p.hasAbility(a, false, true),
               );
 
@@ -2865,31 +2870,31 @@ const modifierPool: ModifierPool = {
             const moveset = p.getMoveset(true).map(m => m.moveId);
 
             const hasAbility = [
-              Abilities.DROUGHT,
+              AbilityId.DROUGHT,
-              Abilities.ORICHALCUM_PULSE,
+              AbilityId.ORICHALCUM_PULSE,
-              Abilities.DRIZZLE,
+              AbilityId.DRIZZLE,
-              Abilities.SAND_STREAM,
+              AbilityId.SAND_STREAM,
-              Abilities.SAND_SPIT,
+              AbilityId.SAND_SPIT,
-              Abilities.SNOW_WARNING,
+              AbilityId.SNOW_WARNING,
-              Abilities.ELECTRIC_SURGE,
+              AbilityId.ELECTRIC_SURGE,
-              Abilities.HADRON_ENGINE,
+              AbilityId.HADRON_ENGINE,
-              Abilities.PSYCHIC_SURGE,
+              AbilityId.PSYCHIC_SURGE,
-              Abilities.GRASSY_SURGE,
+              AbilityId.GRASSY_SURGE,
-              Abilities.SEED_SOWER,
+              AbilityId.SEED_SOWER,
-              Abilities.MISTY_SURGE,
+              AbilityId.MISTY_SURGE,
             ].some(a => p.hasAbility(a, false, true));
 
             const hasMoves = [
-              Moves.SUNNY_DAY,
+              MoveId.SUNNY_DAY,
-              Moves.RAIN_DANCE,
+              MoveId.RAIN_DANCE,
-              Moves.SANDSTORM,
+              MoveId.SANDSTORM,
-              Moves.SNOWSCAPE,
+              MoveId.SNOWSCAPE,
-              Moves.HAIL,
+              MoveId.HAIL,
-              Moves.CHILLY_RECEPTION,
+              MoveId.CHILLY_RECEPTION,
-              Moves.ELECTRIC_TERRAIN,
+              MoveId.ELECTRIC_TERRAIN,
-              Moves.PSYCHIC_TERRAIN,
+              MoveId.PSYCHIC_TERRAIN,
-              Moves.GRASSY_TERRAIN,
+              MoveId.GRASSY_TERRAIN,
-              Moves.MISTY_TERRAIN,
+              MoveId.MISTY_TERRAIN,
             ].some(m => moveset.includes(m));
 
             return hasAbility || hasMoves;