Merge e420b976cf into f42237d415

* Enforced a few usages of `toCamelCase`

* Removed `map(x => x)`

* Removed more maps and sufff

* Update test/mystery-encounter/encounters/weird-dream-encounter.test.ts

* Update game-data.ts types to work

.github/workflows/github-pages.yml

@@ -62,8 +62,15 @@ jobs:
         working-directory: ${{env.api-dir}}
         run: |
           cd pokerogue_docs
+          pnpm typedoc
           pnpm exec typedoc --out /tmp/docs --githubPages false --entryPoints ./src/
 
+      - name: Typecheck Node.js Scripts
+        working-directory: ${{env.api-dir}}
+        run: |
+          cd pokerogue_docs
+          pnpm typecheck:scripts
+
       - name: Commit & Push docs
         if: github.event_name == 'push'
         run: |

biome.jsonc

@@ -19,6 +19,7 @@
     // and having to verify whether each individual file is ignored
     "includes": [
       "**",
+      "!**/*.d.ts",
       "!**/dist/**/*",
       "!**/build/**/*",
       "!**/coverage/**/*",
@@ -177,9 +178,10 @@
     },
 
     // Overrides to prevent unused import removal inside `overrides.ts` and enums files (for TSDoc linkcodes),
-    // as well as in all TS files in `scripts/` (which are assumed to be boilerplate templates).
+    // as well as inside script boilerplate files.
     {
-      "includes": ["**/src/overrides.ts", "**/src/enums/**/*", "**/scripts/**/*.ts", "**/*.d.ts"],
+      // TODO: Rename existing boilerplates in the folder and remove this last alias
+      "includes": ["**/src/overrides.ts", "**/src/enums/**/*", "scripts/**/*.boilerplate.ts", "**/boilerplates/*.ts"],
       "linter": {
         "rules": {
           "correctness": {
@@ -189,7 +191,7 @@
       }
     },
     {
-      "includes": ["**/src/overrides.ts", "**/scripts/**/*.ts"],
+      "includes": ["**/src/overrides.ts"],
       "linter": {
         "rules": {
           "style": {

docs/localization.md

@@ -90,9 +90,13 @@ If this feature requires new text, the text should be integrated into the code w
   - For any feature pulled from the mainline Pokémon games (e.g. a Move or Ability implementation), it's best practice to include a source link for any added text.  
   [Poké Corpus](https://abcboy101.github.io/poke-corpus/) is a great resource for finding text from the mainline games; otherwise, a video/picture showing the text being displayed should suffice.
   - You should also [notify the current Head of Translation](#notifying-translation) to ensure a fast response.
-3. At this point, you may begin [testing locales integration in your main PR](#documenting-locales-changes).
-4. The Translation Team will approve the locale PR (after corrections, if necessary), then merge it into `pokerogue-locales`.
-5. The Dev Team will approve your main PR for your feature, then merge it into PokéRogue's beta environment.
+3. Your locales should use the following format:
+  - File names should be in `kebab-case`. Example: `trainer-names.json`
+  - Key names should be in `camelCase`. Example: `aceTrainer`
+    - If you make use of i18next's inbuilt [context support](https://www.i18next.com/translation-function/context), you need to use `snake_case` for the context key. Example: `aceTrainer_male`
+4. At this point, you may begin [testing locales integration in your main PR](#documenting-locales-changes).
+5. The Translation Team will approve the locale PR (after corrections, if necessary), then merge it into `pokerogue-locales`.
+6. The Dev Team will approve your main PR for your feature, then merge it into PokéRogue's beta environment.
 
 [^2]: For those wondering, the reason for choosing English specifically is due to it being the master language set in Pontoon (the program used by the Translation Team to perform locale updates).
 If a key is present in any language _except_ the master language, it won't appear anywhere else in the translation tool, rendering missing English keys quite a hassle.

package.json

@@ -14,7 +14,9 @@
     "test:watch": "vitest watch --coverage --no-isolate",
     "test:silent": "vitest run --silent='passed-only' --no-isolate",
     "test:create": "node scripts/create-test/create-test.js",
+    "eggMoves:parse": "node scripts/parse-egg-moves/main.js",
     "typecheck": "tsc --noEmit",
+    "typecheck:scripts": "tsc -p scripts/jsconfig.json",
     "eslint": "eslint --fix .",
     "eslint-ci": "eslint .",
     "biome": "biome check --write --changed --no-errors-on-unmatched --diagnostic-level=error",
@@ -29,6 +31,7 @@
   "devDependencies": {
     "@biomejs/biome": "2.0.0",
     "@ls-lint/ls-lint": "2.3.1",
+    "@types/crypto-js": "^4.2.2",
     "@types/jsdom": "^21.1.7",
     "@types/node": "^22.16.5",
     "@vitest/coverage-istanbul": "^3.2.4",

pnpm-lock.yaml

@@ -48,6 +48,9 @@ importers:
       '@ls-lint/ls-lint':
         specifier: 2.3.1
         version: 2.3.1
+      '@types/crypto-js':
+        specifier: ^4.2.2
+        version: 4.2.2
       '@types/jsdom':
         specifier: ^21.1.7
         version: 21.1.7
@@ -718,6 +721,9 @@ packages:
   '@types/cookie@0.6.0':
     resolution: {integrity: sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==}
 
+  '@types/crypto-js@4.2.2':
+    resolution: {integrity: sha512-sDOLlVbHhXpAUAL0YHDUUwDZf3iN4Bwi4W6a0W0b+QcAezUbRtH4FVb+9J4h+XFPW7l/gQ9F8qC7P+Ec4k8QVQ==}
+
   '@types/deep-eql@4.0.2':
     resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
 
@@ -2525,6 +2531,8 @@ snapshots:
 
   '@types/cookie@0.6.0': {}
 
+  '@types/crypto-js@4.2.2': {}
+
   '@types/deep-eql@4.0.2': {}
 
   '@types/estree@1.0.8': {}

scripts/create-test/create-test.js

@@ -156,7 +156,7 @@ async function runInteractive() {
     console.log(chalk.green.bold(`✔ File created at: test/${localDir}/${fileName}.test.ts\n`));
     console.groupEnd();
   } catch (err) {
-    console.error(chalk.red("✗ Error: ", err.message));
+    console.error(chalk.red("✗ Error: ", err));
   }
 }
 

scripts/decrypt-save.js

@@ -1,7 +1,6 @@
 // Usage: node decrypt-save.js <encrypted-file> [save-file]
 
-// biome-ignore lint/performance/noNamespaceImport: This is how you import fs from node
-import * as fs from "node:fs";
+import fs from "node:fs";
 import crypto_js from "crypto-js";
 
 const { AES, enc } = crypto_js;
@@ -60,6 +59,11 @@ function decryptSave(path) {
   try {
     fileData = fs.readFileSync(path, "utf8");
   } catch (e) {
+    if (!(e instanceof Error)) {
+      console.error(`Unrecognized error: ${e}`);
+      process.exit(1);
+    }
+    // @ts-expect-error: TODO fix
     switch (e.code) {
       case "ENOENT":
         console.error(`File not found: ${path}`);
@@ -104,6 +108,13 @@ function writeToFile(filePath, data) {
   try {
     fs.writeFileSync(filePath, data);
   } catch (e) {
+    if (!(e instanceof Error)) {
+      console.error("Unknown error detected: ", e);
+      process.exitCode = 1;
+      return;
+    }
+
+    // @ts-expect-error - e is usually a SystemError (all of which have codes)
     switch (e.code) {
       case "EACCES":
         console.error(`Could not open ${filePath}: Permission denied`);
@@ -114,7 +125,8 @@ function writeToFile(filePath, data) {
       default:
         console.error(`Error writing file: ${e.message}`);
     }
-    process.exit(1);
+    process.exitCode = 1;
+    return;
   }
 }
 

scripts/jsconfig.json

@@ -0,0 +1,17 @@
+{
+  "include": ["**/*.js"],
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+    "rootDir": ".",
+    "target": "esnext",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "erasableSyntaxOnly": true,
+    "strict": true,
+    "noEmit": true,
+    // Forcibly disable `node_modules` recursion to prevent TSC from typechecking random JS files.
+    // This is disabled by default in `tsconfig.json`, but needs to be explicitly disabled from the default of `2`
+    "maxNodeModuleJsDepth": 0
+  }
+}

scripts/parse-egg-moves/egg-move-template.boilerplate.ts

@@ -0,0 +1,10 @@
+//! DO NOT EDIT THIS FILE - CREATED BY THE `eggMoves:parse` script automatically
+import { MoveId } from "#enums/move-id";
+import { SpeciesId } from "#enums/species-id";
+
+/**
+ * An object mapping all base form {@linkcode SpeciesId}s to an array of {@linkcode MoveId}s corresponding
+ * to their current egg moves.
+ * Generated by the `eggMoves:parse` script using a CSV sourced from the current Balance Team spreadsheet.
+ */
+export const speciesEggMoves = "{{table}}";

scripts/parse-egg-moves/help-message.js

@@ -0,0 +1,17 @@
+import chalk from "chalk";
+
+/** Show help/usage text for the `eggMoves:parse` CLI. */
+export function showHelpText() {
+  console.log(`
+Usage: ${chalk.cyan("pnpm eggMoves:parse [options]")}
+If given no options, assumes ${chalk.blue("\`--interactive\`")}.
+If given only a file path, assumes ${chalk.blue("\`--file\`")}.
+
+${chalk.hex("#ffa500")("Options:")}
+  ${chalk.blue("-h, --help")}            Show this help message.
+  ${chalk.blue("-f, --file[=PATH]")}     Specify a path to a CSV file to read, or provide one from stdin.
+  ${chalk.blue("-t, --text[=TEXT]")}
+  ${chalk.blue("-c, --console[=TEXT]")}  Specify CSV text to read, or provide it from stdin.
+  ${chalk.blue("-i, --interactive")}     Run in interactive mode (default)
+`);
+}

scripts/parse-egg-moves/interactive.js

@@ -0,0 +1,104 @@
+import fs from "fs";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { showHelpText } from "./help-message.js";
+
+/**
+ * Prompt the user to interactively select an option (console/file) to retrieve the egg move CSV.
+ * @returns {Promise<{type: "Console" | "File", value: string} | {type: "Exit"}>} The selected option with value
+ */
+export async function runInteractive() {
+  /** @type {"Console" | "File" | "Help" | "Exit"} */
+  const answer = await inquirer
+    .prompt([
+      {
+        type: "list",
+        name: "type",
+        message: "Select the method to obtain egg moves.",
+        choices: ["Console", "File", "Help", "Exit"],
+      },
+    ])
+    .then(a => a.type);
+
+  if (answer === "Exit") {
+    console.log("Exiting...");
+    process.exitCode = 1;
+    return { type: "Exit" };
+  }
+
+  if (answer === "Help") {
+    showHelpText();
+    return { type: "Exit" };
+  }
+
+  if (!["Console", "File"].includes(answer)) {
+    console.error(chalk.red("Please provide a valid type!"));
+    return await runInteractive();
+  }
+
+  return { type: answer, value: await promptForValue(answer) };
+}
+
+/**
+ * Prompt the user to give a value (either the direct CSV or the file path).
+ * @param {"Console" | "File"} type - The input method
+ * @returns {Promise<string>} A Promise resolving with the CSV/file path.
+ */
+function promptForValue(type) {
+  switch (type) {
+    case "Console":
+      return doPromptConsole();
+    case "File":
+      return getFilePath();
+  }
+}
+
+/**
+ * Prompt the user to enter a file path from the console.
+ * @returns {Promise<string>} The file path inputted by the user.
+ */
+async function getFilePath() {
+  return await inquirer
+    .prompt([
+      {
+        type: "input",
+        name: "path",
+        message: "Please enter the path to the egg move CSV file.",
+        validate: input => {
+          if (input.trim() === "") {
+            return "File path cannot be empty!";
+          }
+          if (!fs.existsSync(input)) {
+            return "File does not exist!";
+          }
+          return true;
+        },
+      },
+    ])
+    .then(answer => answer.path);
+}
+
+/**
+ * Prompt the user for CSV input from the console.
+ * @returns {Promise<string>} The CSV input from the user.
+ */
+async function doPromptConsole() {
+  return await inquirer
+    .prompt([
+      {
+        type: "input",
+        name: "csv",
+        message: "Please enter the egg move CSV text.",
+        validate: input => {
+          if (input.trim() === "") {
+            return "CSV text cannot be empty!";
+          }
+          if (!input.match(/^[^,]+(,[^,]+){4}$/gm)) {
+            return "CSV text malformed - should contain 5 consecutive comma-separated values per line!";
+          }
+          return true;
+        },
+      },
+    ])
+    .then(answer => answer.csv);
+}

scripts/parse-egg-moves/main.js

@@ -0,0 +1,168 @@
+/*
+ * This script accepts a CSV value or file path as input, parses the egg moves,
+ * and writes the output to a TypeScript file.
+ * It can be run interactively or with command line arguments.
+ * Usage: `pnpm eggMoves:parse`
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { showHelpText } from "./help-message.js";
+import { runInteractive } from "./interactive.js";
+import { parseEggMoves } from "./parse.js";
+
+const version = "1.0.0";
+
+// Get the directory name of the current module file
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.join(__dirname, "..", "..");
+const templatePath = path.join(__dirname, "egg-move-template.ts");
+// TODO: Do we want this to be configurable?
+const eggMoveTargetPath = path.join(projectRoot, "src/data/balance/egg-moves.ts");
+
+/**
+ * @typedef {{type: "Console" | "File", value: string} | {type: "Exit"}}
+ * Option
+ * An option selected by the user.
+ */
+
+/**
+ * Runs the interactive eggMoves:parse CLI.
+ * @returns {Promise<void>}
+ */
+async function start() {
+  console.log(chalk.yellow(`🥚 Egg Move Parser - v${version}`));
+
+  if (process.argv.length > 4) {
+    console.error(
+      chalk.redBright.bold(
+        `✗ Error: Too many arguments provided!\nArgs: ${chalk.hex("#7310fdff")(process.argv.slice(2).join(" "))}`,
+      ),
+    );
+    showHelpText();
+    process.exitCode = 1;
+    return;
+  }
+
+  let csv = "";
+  const inputType = await parseArguments();
+  if (process.exitCode) {
+    // If exit code is non-zero, return to allow it to propagate up the chain.
+    return;
+  }
+  switch (inputType.type) {
+    case "Console":
+      csv = inputType.value;
+      break;
+    case "File":
+      csv = await fs.promises.readFile(inputType.value, "utf-8");
+      break;
+    case "Exit":
+      // Help screen triggered; break out
+      return;
+  }
+
+  await writeToFile(parseEggMoves(csv));
+}
+
+/**
+ * Handle the arguments passed to the script and obtain the CSV input type.
+ * @returns {Promise<{type: "Console" | "File", value: string} | {type: "Exit"}>} The input method selected by the user
+ */
+async function parseArguments() {
+  const args = process.argv.slice(2); // first 2 args are node and script name (irrelevant)
+
+  /** @type {string | undefined}  */
+  const arg = args[0].split("=")[0]; // Yoink everything up to the first "=" to get the raw command
+  switch (arg) {
+    case "-f":
+    case "--file":
+      return { type: "File", value: getArgValue() };
+    case "-t":
+    case "--text":
+    case "-c":
+    case "--console":
+      return { type: "Console", value: getArgValue() };
+    case "-h":
+    case "--help":
+      showHelpText();
+      process.exitCode = 0;
+      return { type: "Exit" };
+    case "--interactive":
+    case "-i":
+    case undefined:
+      return await runInteractive();
+    default:
+      // If no arguments are found, check if it's a file path
+      if (fs.existsSync(arg)) {
+        console.log(chalk.green(`Using file path from stdin: ${chalk.blue(arg)}`));
+        return { type: "File", value: arg };
+      }
+      badArgs();
+      return { type: "Exit" };
+  }
+}
+
+/**
+ * Get the value of the argument provided.
+ * @returns {string} The CSV or file path from the arguments
+ * @throws {Error} If arguments are malformed
+ */
+function getArgValue() {
+  // If the user provided a value as argument 2, take that as the argument.
+  // Otherwise, check the 1st argument to see if it contains an `=` and extract everything afterwards.
+  /** @type {string | undefined} */
+  let filePath = process.argv[3];
+  const equalsIndex = process.argv[2].indexOf("=");
+  if (equalsIndex > -1) {
+    // If arg 3 was aleady existing and someone used `=` notation to assign a property, throw an error.
+    filePath = filePath ? undefined : process.argv[2].slice(equalsIndex + 1);
+  }
+
+  if (!filePath?.trim()) {
+    badArgs();
+    return "";
+  }
+  // NB: It doesn't really matter that this can be `undefined` - we'll always break out by lieu of setting the exit code
+  return filePath;
+}
+
+/**
+ * Write out the parsed CSV to a file.
+ * @param {string} moves - The parsed CSV
+ * @returns {Promise<void>}
+ */
+export async function writeToFile(moves) {
+  try {
+    // Read the template file, replacing the placeholder with the move table.
+    const content = fs.readFileSync(templatePath, "utf8").replace(`"{{table}}"`, moves);
+
+    if (fs.existsSync(eggMoveTargetPath)) {
+      console.warn(chalk.hex("#ffa500")("\nEgg moves file already exists, overwriting...\n"));
+    }
+
+    // Write the template content to the file
+    fs.writeFileSync(eggMoveTargetPath, content, "utf8");
+
+    console.log(chalk.green.bold(`\n✔ Egg Moves written to ${eggMoveTargetPath}`));
+    console.groupEnd();
+  } catch (err) {
+    console.error(chalk.red(`✗ Error while writing egg moves: ${err}`));
+    process.exitCode = 1;
+  }
+}
+
+/**
+ * Do logging for incorrect or malformed CLI arguments.
+ * @returns {void}
+ */
+function badArgs() {
+  chalk.red.bold(`✗ Error: Malformed arguments!\nArgs: ${chalk.hex("#7310fdff")(process.argv.slice(2).join(" "))}`);
+  showHelpText();
+  process.exitCode = 1;
+}
+
+start();

scripts/parse-egg-moves/parse.js

@@ -0,0 +1,79 @@
+import chalk from "chalk";
+
+/**
+ * A single line of the inputted CSV.
+ * @typedef {[speciesName: string, move1: string, move2: string, move3: string, move4: string]}
+ * CSVLine
+ */
+
+/**
+ * Regex to determine if a string follows the required CSV format.
+ */
+const csvRegex = /^((?:[^,]+?,){4}(?:\w|\s)+?,?\n?)+$/g;
+
+/**
+ * Given a CSV string, parse it and return a structured table ready to be inputted into code.
+ * @param {string} csv - The formatted CSV string.
+ * @returns {string} The fully formatted table.
+ */
+export function parseEggMoves(csv) {
+  console.log(chalk.grey("⚙️ Parsing egg moves..."));
+  if (!csvRegex.test(csv)) {
+    console.error(chalk.redBright("! Input was not proper CSV!"));
+    process.exitCode = 1;
+    return "";
+  }
+
+  let output = "{\n";
+
+  const lines = csv.split(/\n/g);
+
+  for (const line of lines) {
+    /**
+     * The individual CSV column for this species.
+     */
+    const cols =
+      /** @type {CSVLine} */
+      (line.split(",").slice(0, 5));
+    const speciesName = toUpperSnakeCase(cols[0]);
+
+    const eggMoves =
+      /** @type {string[]} */
+      ([]);
+
+    for (let m = 1; m < 5; m++) {
+      const moveName = cols[m].trim();
+      if (!moveName || moveName === "N/A") {
+        console.warn(`Species ${speciesName} missing ${m}th egg move!`);
+        eggMoves.push("MoveId.NONE");
+        continue;
+      }
+
+      // Remove (N) and (P) from the ends of move names before UPPER_SNAKE_CASE-ing them
+      const moveNameTitle = toUpperSnakeCase(moveName.replace(/ \([A-Z]\)$/, ""));
+      eggMoves.push("MoveId." + moveNameTitle);
+    }
+
+    if (eggMoves.every(move => move === "MoveId.NONE")) {
+      console.warn(`Species ${speciesName} could not be parsed, excluding from output...`);
+      output += `  // [SpeciesId.${speciesName}]: [ MoveId.NONE, MoveId.NONE, MoveId.NONE, MoveId.NONE ],\n`;
+    } else {
+      output += `  [SpeciesId.${speciesName}]: [ ${eggMoves.join(", ")} ],\n`;
+    }
+  }
+
+  // NB: We omit the semicolon as it is contained in the template string itself
+  return output + "} satisfies Partial<Record<SpeciesId, [MoveId, MoveId, MoveId, MoveId]>>";
+}
+
+/**
+ * Helper method to convert a string into `UPPER_SNAKE_CASE`.
+ * @param {string} str - The string being converted
+ * @returns {string} The result of converting `str` into upper snake case.
+ */
+function toUpperSnakeCase(str) {
+  return str
+    .split(/[_ -]+/g)
+    .map(word => word.toUpperCase())
+    .join("_");
+}

src/battle-scene.ts

@@ -104,6 +104,7 @@ import {
   getLuckString,
   getLuckTextTint,
   getPartyLuckValue,
+  type ModifierType,
   PokemonHeldItemModifierType,
 } from "#modifiers/modifier-type";
 import { MysteryEncounter } from "#mystery-encounters/mystery-encounter";
@@ -1203,7 +1204,9 @@ export class BattleScene extends SceneBase {
     this.updateScoreText();
     this.scoreText.setVisible(false);
 
-    [this.luckLabelText, this.luckText].map(t => t.setVisible(false));
+    [this.luckLabelText, this.luckText].forEach(t => {
+      t.setVisible(false);
+    });
 
     this.newArena(Overrides.STARTING_BIOME_OVERRIDE || BiomeId.TOWN);
 
@@ -1237,8 +1240,7 @@ export class BattleScene extends SceneBase {
             Object.values(mp)
               .flat()
               .map(mt => mt.modifierType)
-              .filter(mt => "localize" in mt)
-              .map(lpb => lpb as unknown as Localizable),
+              .filter((mt): mt is ModifierType & Localizable => "localize" in mt && typeof mt.localize === "function"),
           ),
       ];
       for (const item of localizable) {
@@ -1513,8 +1515,8 @@ export class BattleScene extends SceneBase {
     return this.currentBattle;
   }
 
-  newArena(biome: BiomeId, playerFaints?: number): Arena {
-    this.arena = new Arena(biome, BiomeId[biome].toLowerCase(), playerFaints);
+  newArena(biome: BiomeId, playerFaints = 0): Arena {
+    this.arena = new Arena(biome, playerFaints);
     this.eventTarget.dispatchEvent(new NewArenaEvent());
 
     this.arenaBg.pipelineData = {
@@ -2711,7 +2713,9 @@ export class BattleScene extends SceneBase {
           }
         }
 
-        this.party.map(p => p.updateInfo(instant));
+        this.party.forEach(p => {
+          p.updateInfo(instant);
+        });
       } else {
         const args = [this];
         if (modifier.shouldApply(...args)) {

src/data/abilities/ability.ts

@@ -74,6 +74,7 @@ import {
   randSeedItem,
   toDmgValue,
 } from "#utils/common";
+import { toCamelCase } from "#utils/strings";
 import i18next from "i18next";
 
 export class Ability implements Localizable {
@@ -109,13 +110,9 @@ export class Ability implements Localizable {
   }
 
   localize(): void {
-    const i18nKey = AbilityId[this.id]
-      .split("_")
-      .filter(f => f)
-      .map((f, i) => (i ? `${f[0]}${f.slice(1).toLowerCase()}` : f.toLowerCase()))
-      .join("") as string;
+    const i18nKey = toCamelCase(AbilityId[this.id]);
 
-    this.name = this.id ? `${i18next.t(`ability:${i18nKey}.name`) as string}${this.nameAppend}` : "";
+    this.name = this.id ? `${i18next.t(`ability:${i18nKey}.name`)}${this.nameAppend}` : "";
     this.description = this.id ? (i18next.t(`ability:${i18nKey}.description`) as string) : "";
   }
 

src/data/balance/egg-moves.ts

@@ -1,9 +1,12 @@
-import { allMoves } from "#data/data-lists";
+//! DO NOT EDIT THIS FILE - CREATED BY THE `eggMoves:parse` script automatically
 import { MoveId } from "#enums/move-id";
 import { SpeciesId } from "#enums/species-id";
-import { getEnumKeys, getEnumValues } from "#utils/enums";
-import { toTitleCase } from "#utils/strings";
 
+/**
+ * An object mapping all base form {@linkcode SpeciesId}s to an array of {@linkcode MoveId}s corresponding
+ * to their current egg moves.
+ * Generated by the `eggMoves:parse` script using a CSV sourced from the current Balance Team spreadsheet.
+ */
 export const speciesEggMoves = {
   [SpeciesId.BULBASAUR]: [ MoveId.SAPPY_SEED, MoveId.MALIGNANT_CHAIN, MoveId.EARTH_POWER, MoveId.MATCHA_GOTCHA ],
   [SpeciesId.CHARMANDER]: [ MoveId.DRAGON_DANCE, MoveId.BITTER_BLADE, MoveId.EARTH_POWER, MoveId.OBLIVION_WING ],
@@ -15,7 +18,7 @@ export const speciesEggMoves = {
   [SpeciesId.SPEAROW]: [ MoveId.FLOATY_FALL, MoveId.EXTREME_SPEED, MoveId.KNOCK_OFF, MoveId.TRIPLE_ARROWS ],
   [SpeciesId.EKANS]: [ MoveId.NOXIOUS_TORQUE, MoveId.DRAGON_DANCE, MoveId.SLACK_OFF, MoveId.SHED_TAIL ],
   [SpeciesId.SANDSHREW]: [ MoveId.HIGH_HORSEPOWER, MoveId.DIRE_CLAW, MoveId.SHORE_UP, MoveId.MIGHTY_CLEAVE ],
-  [SpeciesId.NIDORAN_F]: [ MoveId.BANEFUL_BUNKER, MoveId.MOONLIGHT, MoveId.BARB_BARRAGE, MoveId.THOUSAND_WAVES ],
+  [SpeciesId.NIDORAN_F]: [ MoveId.CALM_MIND, MoveId.MOONLIGHT, MoveId.MALIGNANT_CHAIN, MoveId.SANDSEAR_STORM ],
   [SpeciesId.NIDORAN_M]: [ MoveId.DRAGON_DANCE, MoveId.MOUNTAIN_GALE, MoveId.NOXIOUS_TORQUE, MoveId.PRECIPICE_BLADES ],
   [SpeciesId.VULPIX]: [ MoveId.MOONBLAST, MoveId.INFERNAL_PARADE, MoveId.MORNING_SUN, MoveId.TAIL_GLOW ],
   [SpeciesId.ZUBAT]: [ MoveId.FLOATY_FALL, MoveId.DIRE_CLAW, MoveId.SWORDS_DANCE, MoveId.COLLISION_COURSE ],
@@ -293,7 +296,7 @@ export const speciesEggMoves = {
   [SpeciesId.ARCHEN]: [ MoveId.ROOST, MoveId.EARTHQUAKE, MoveId.FLOATY_FALL, MoveId.MIGHTY_CLEAVE ],
   [SpeciesId.TRUBBISH]: [ MoveId.COIL, MoveId.RECOVER, MoveId.DIRE_CLAW, MoveId.GIGATON_HAMMER ],
   [SpeciesId.ZORUA]: [ MoveId.MALIGNANT_CHAIN, MoveId.MOONBLAST, MoveId.SECRET_SWORD, MoveId.FIERY_WRATH ],
-  [SpeciesId.MINCCINO]: [ MoveId.ICICLE_SPEAR, MoveId.TIDY_UP, MoveId.LOW_KICK, MoveId.POPULATION_BOMB ],
+  [SpeciesId.MINCCINO]: [ MoveId.ICICLE_SPEAR, MoveId.TIDY_UP, MoveId.KNOCK_OFF, MoveId.POPULATION_BOMB ],
   [SpeciesId.GOTHITA]: [ MoveId.RECOVER, MoveId.MOONBLAST, MoveId.AURA_SPHERE, MoveId.LUMINA_CRASH ],
   [SpeciesId.SOLOSIS]: [ MoveId.MIST_BALL, MoveId.SPEED_SWAP, MoveId.FLAMETHROWER, MoveId.LIGHT_OF_RUIN ],
   [SpeciesId.DUCKLETT]: [ MoveId.SPLISHY_SPLASH, MoveId.SANDSEAR_STORM, MoveId.WILDBOLT_STORM, MoveId.QUIVER_DANCE ],
@@ -310,7 +313,7 @@ export const speciesEggMoves = {
   [SpeciesId.TYNAMO]: [ MoveId.SCALD, MoveId.STRENGTH_SAP, MoveId.FIRE_LASH, MoveId.AURA_WHEEL ],
   [SpeciesId.ELGYEM]: [ MoveId.THUNDERCLAP, MoveId.BADDY_BAD, MoveId.AURA_SPHERE, MoveId.PHOTON_GEYSER ],
   [SpeciesId.LITWICK]: [ MoveId.GIGA_DRAIN, MoveId.EARTH_POWER, MoveId.MOONBLAST, MoveId.TORCH_SONG ],
-  [SpeciesId.AXEW]: [ MoveId.STONE_AXE, MoveId.DIRE_CLAW, MoveId.RAGING_FURY, MoveId.BITTER_BLADE ],
+  [SpeciesId.AXEW]: [ MoveId.STONE_AXE, MoveId.DIRE_CLAW, MoveId.BITTER_BLADE, MoveId.GLAIVE_RUSH ],
   [SpeciesId.CUBCHOO]: [ MoveId.MOUNTAIN_GALE, MoveId.AQUA_STEP, MoveId.ICE_SHARD, MoveId.COLLISION_COURSE ],
   [SpeciesId.CRYOGONAL]: [ MoveId.FREEZING_GLARE, MoveId.AURORA_VEIL, MoveId.NASTY_PLOT, MoveId.ORIGIN_PULSE ],
   [SpeciesId.SHELMET]: [ MoveId.POWER_GEM, MoveId.NASTY_PLOT, MoveId.EARTH_POWER, MoveId.STEAM_ERUPTION ],
@@ -448,7 +451,7 @@ export const speciesEggMoves = {
   [SpeciesId.ROOKIDEE]: [ MoveId.ROOST, MoveId.BODY_PRESS, MoveId.KINGS_SHIELD, MoveId.BEHEMOTH_BASH ],
   [SpeciesId.BLIPBUG]: [ MoveId.HEAL_ORDER, MoveId.LUSTER_PURGE, MoveId.SLEEP_POWDER, MoveId.TAIL_GLOW ],
   [SpeciesId.NICKIT]: [ MoveId.BADDY_BAD, MoveId.MYSTICAL_FIRE, MoveId.SPARKLY_SWIRL, MoveId.MAKE_IT_RAIN ],
-  [SpeciesId.GOSSIFLEUR]: [ MoveId.BATON_PASS, MoveId.TAILWIND, MoveId.SAPPY_SEED, MoveId.SPORE ],
+  [SpeciesId.GOSSIFLEUR]: [ MoveId.PARTING_SHOT, MoveId.STRENGTH_SAP, MoveId.SAPPY_SEED, MoveId.SEED_FLARE ],
   [SpeciesId.WOOLOO]: [ MoveId.NUZZLE, MoveId.MILK_DRINK, MoveId.BODY_PRESS, MoveId.MULTI_ATTACK ],
   [SpeciesId.CHEWTLE]: [ MoveId.ICE_FANG, MoveId.PSYCHIC_FANGS, MoveId.SHELL_SMASH, MoveId.MIGHTY_CLEAVE ],
   [SpeciesId.YAMPER]: [ MoveId.ICE_FANG, MoveId.SWORDS_DANCE, MoveId.THUNDER_FANG, MoveId.BOLT_STRIKE ],
@@ -514,7 +517,7 @@ export const speciesEggMoves = {
   [SpeciesId.TAROUNTULA]: [ MoveId.STONE_AXE, MoveId.LEECH_LIFE, MoveId.FAKE_OUT, MoveId.SPORE ],
   [SpeciesId.NYMBLE]: [ MoveId.KNOCK_OFF, MoveId.FELL_STINGER, MoveId.ATTACK_ORDER, MoveId.WICKED_BLOW ],
   [SpeciesId.PAWMI]: [ MoveId.DRAIN_PUNCH, MoveId.METEOR_MASH, MoveId.JET_PUNCH, MoveId.PLASMA_FISTS ],
-  [SpeciesId.TANDEMAUS]: [ MoveId.BATON_PASS, MoveId.FAKE_OUT, MoveId.POWER_UP_PUNCH, MoveId.REVIVAL_BLESSING ],
+  [SpeciesId.TANDEMAUS]: [ MoveId.BATON_PASS, MoveId.COVET, MoveId.SIZZLY_SLIDE, MoveId.REVIVAL_BLESSING ],
   [SpeciesId.FIDOUGH]: [ MoveId.SOFT_BOILED, MoveId.HIGH_HORSEPOWER, MoveId.SIZZLY_SLIDE, MoveId.TIDY_UP ],
   [SpeciesId.SMOLIV]: [ MoveId.STRENGTH_SAP, MoveId.EARTH_POWER, MoveId.CALM_MIND, MoveId.BOOMBURST ],
   [SpeciesId.SQUAWKABILLY]: [ MoveId.PARTING_SHOT, MoveId.EARTHQUAKE, MoveId.FLARE_BLITZ, MoveId.EXTREME_SPEED ],
@@ -582,55 +585,4 @@ export const speciesEggMoves = {
   [SpeciesId.PALDEA_TAUROS]: [ MoveId.NO_RETREAT, MoveId.BLAZING_TORQUE, MoveId.AQUA_STEP, MoveId.THUNDEROUS_KICK ],
   [SpeciesId.PALDEA_WOOPER]: [ MoveId.STONE_AXE, MoveId.RECOVER, MoveId.BANEFUL_BUNKER, MoveId.BARB_BARRAGE ],
   [SpeciesId.BLOODMOON_URSALUNA]: [ MoveId.NASTY_PLOT, MoveId.ROCK_POLISH, MoveId.SANDSEAR_STORM, MoveId.BOOMBURST ]
-};
-
-/**
- * Parse a CSV-separated list of Egg Moves (such as one sourced from a Google Sheets)
- * into code able to form the `speciesEggMoves` const object as above.
- * @param content - The CSV-formatted string to convert into code.
- */
-// TODO: Move this into the scripts folder and stop running it on initialization
-function parseEggMoves(content: string): void {
-  let output = "";
-
-  const speciesNames = getEnumKeys(SpeciesId);
-  const speciesValues = getEnumValues(SpeciesId);
-  const moveNames = allMoves.map(m => m.name.replace(/ \([A-Z]\)$/, "").toLowerCase());
-  const lines = content.split(/\n/g);
-
-  for (const line of lines) {
-    const cols = line.split(",").slice(0, 5);
-    const enumSpeciesName = cols[0].toUpperCase().replace(/[ -]/g, "_") as keyof typeof SpeciesId;
-    // TODO: This should use reverse mapping instead of `indexOf`
-    const species = speciesValues[speciesNames.indexOf(enumSpeciesName)];
-
-    const eggMoves: MoveId[] = [];
-
-    for (let m = 0; m < 4; m++) {
-      const moveName = cols[m + 1].trim();
-      const moveIndex = moveName !== "N/A" ? moveNames.indexOf(moveName.toLowerCase()) : -1;
-      if (moveIndex === -1) {
-        console.warn(moveName, "could not be parsed");
-      }
-
-      eggMoves.push(moveIndex > -1 ? moveIndex as MoveId : MoveId.NONE);
-    }
-
-    if (eggMoves.every(m => m === MoveId.NONE)) {
-      console.warn(`Species ${toTitleCase(SpeciesId[species])} could not be parsed, excluding from output...`)
-    } else {
-      output += `[SpeciesId.${SpeciesId[species]}]: [ ${eggMoves.map(m => `MoveId.${MoveId[m]}`).join(", ")} ],\n`;
-    }
-  }
-
-  console.log(output);
-}
-
-export function initEggMoves() {
-  const eggMovesStr = "";
-  if (eggMovesStr) {
-    setTimeout(() => {
-      parseEggMoves(eggMovesStr);
-    }, 1000);
-  }
-}
+} satisfies Partial<Record<SpeciesId, [MoveId, MoveId, MoveId, MoveId]>>;

src/data/balance/pokemon-evolutions.ts

@@ -1866,17 +1866,16 @@ interface PokemonPrevolutions {
 export const pokemonPrevolutions: PokemonPrevolutions = {};
 
 export function initPokemonPrevolutions(): void {
-  const megaFormKeys = [ SpeciesFormKey.MEGA, "", SpeciesFormKey.MEGA_X, "", SpeciesFormKey.MEGA_Y ].map(sfk => sfk as string);
-  const prevolutionKeys = Object.keys(pokemonEvolutions);
-  prevolutionKeys.forEach(pk => {
-    const evolutions = pokemonEvolutions[pk];
+  // TODO: Why do we have empty strings in our array?
+  const megaFormKeys = [ SpeciesFormKey.MEGA, "", SpeciesFormKey.MEGA_X, "", SpeciesFormKey.MEGA_Y ];
+  for (const [pk, evolutions] of Object.entries(pokemonEvolutions)) {
     for (const ev of evolutions) {
       if (ev.evoFormKey && megaFormKeys.indexOf(ev.evoFormKey) > -1) {
         continue;
       }
       pokemonPrevolutions[ev.speciesId] = Number.parseInt(pk) as SpeciesId;
     }
-  });
+  }
 }
 
 

src/data/moves/move.ts

@@ -90,7 +90,7 @@ import type { ChargingMove, MoveAttrMap, MoveAttrString, MoveClassMap, MoveKindS
 import type { TurnMove } from "#types/turn-move";
 import { BooleanHolder, type Constructor, isNullOrUndefined, NumberHolder, randSeedFloat, randSeedInt, randSeedItem, toDmgValue } from "#utils/common";
 import { getEnumValues } from "#utils/enums";
-import { toTitleCase } from "#utils/strings";
+import { toCamelCase, toTitleCase } from "#utils/strings";
 import i18next from "i18next";
 import { applyChallenges } from "#utils/challenge-utils";
 
@@ -162,10 +162,16 @@ export abstract class Move implements Localizable {
   }
 
   localize(): void {
-    const i18nKey = MoveId[this.id].split("_").filter(f => f).map((f, i) => i ? `${f[0]}${f.slice(1).toLowerCase()}` : f.toLowerCase()).join("") as unknown as string;
+    const i18nKey = toCamelCase(MoveId[this.id])
 
-    this.name = this.id ? `${i18next.t(`move:${i18nKey}.name`)}${this.nameAppend}` : "";
-    this.effect = this.id ? `${i18next.t(`move:${i18nKey}.effect`)}${this.nameAppend}` : "";
+    if (this.id === MoveId.NONE) {
+      this.name = "";
+      this.effect = ""
+      return;
+    }
+
+    this.name = `${i18next.t(`move:${i18nKey}.name`)}${this.nameAppend}`;
+    this.effect = `${i18next.t(`move:${i18nKey}.effect`)}${this.nameAppend}`;
   }
 
   /**

src/data/pokemon-forms/form-change-triggers.ts

@@ -12,6 +12,7 @@ import { WeatherType } from "#enums/weather-type";
 import type { Pokemon } from "#field/pokemon";
 import type { PokemonFormChangeItemModifier } from "#modifiers/modifier";
 import { type Constructor, coerceArray } from "#utils/common";
+import { toCamelCase } from "#utils/strings";
 import i18next from "i18next";
 
 export abstract class SpeciesFormChangeTrigger {
@@ -143,11 +144,7 @@ export class SpeciesFormChangeMoveLearnedTrigger extends SpeciesFormChangeTrigge
     super();
     this.move = move;
     this.known = known;
-    const moveKey = MoveId[this.move]
-      .split("_")
-      .filter(f => f)
-      .map((f, i) => (i ? `${f[0]}${f.slice(1).toLowerCase()}` : f.toLowerCase()))
-      .join("") as unknown as string;
+    const moveKey = toCamelCase(MoveId[this.move]);
     this.description = known
       ? i18next.t("pokemonEvolutions:Forms.moveLearned", {
           move: i18next.t(`move:${moveKey}.name`),

src/enums/ui-mode.ts

@@ -38,6 +38,7 @@ export enum UiMode {
   UNAVAILABLE,
   CHALLENGE_SELECT,
   RENAME_POKEMON,
+  RENAME_RUN,
   RUN_HISTORY,
   RUN_INFO,
   TEST_DIALOGUE,

src/field/arena.ts

@@ -54,7 +54,7 @@ export class Arena {
   public bgm: string;
   public ignoreAbilities: boolean;
   public ignoringEffectSource: BattlerIndex | null;
-  public playerTerasUsed: number;
+  public playerTerasUsed = 0;
   /**
    * Saves the number of times a party pokemon faints during a arena encounter.
    * {@linkcode globalScene.currentBattle.enemyFaints} is the corresponding faint counter for the enemy (this resets every wave).
@@ -68,12 +68,11 @@ export class Arena {
 
   public readonly eventTarget: EventTarget = new EventTarget();
 
-  constructor(biome: BiomeId, bgm: string, playerFaints = 0) {
+  constructor(biome: BiomeId, playerFaints = 0) {
     this.biomeType = biome;
-    this.bgm = bgm;
+    this.bgm = BiomeId[biome].toLowerCase();
     this.trainerPool = biomeTrainerPools[biome];
     this.updatePoolsForTimeOfDay();
-    this.playerTerasUsed = 0;
     this.playerFaints = playerFaints;
   }
 

src/init/init.ts

@@ -1,6 +1,5 @@
 import { initAbilities } from "#abilities/ability";
 import { initBiomes } from "#balance/biomes";
-import { initEggMoves } from "#balance/egg-moves";
 import { initPokemonPrevolutions, initPokemonStarters } from "#balance/pokemon-evolutions";
 import { initSpecies } from "#balance/pokemon-species";
 import { initChallenges } from "#data/challenge";
@@ -24,7 +23,6 @@ export function initializeGame() {
   initPokemonPrevolutions();
   initPokemonStarters();
   initBiomes();
-  initEggMoves();
   initPokemonForms();
   initTrainerTypeDialogue();
   initSpecies();

src/loading-scene.ts

@@ -447,7 +447,9 @@ export class LoadingScene extends SceneBase {
     );
 
     if (!mobile) {
-      loadingGraphics.map(g => g.setVisible(false));
+      loadingGraphics.forEach(g => {
+        g.setVisible(false);
+      });
     }
 
     const intro = this.add.video(0, 0);

src/modifier/modifier.ts

@@ -121,8 +121,8 @@ export class ModifierBar extends Phaser.GameObjects.Container {
   }
 
   updateModifierOverflowVisibility(ignoreLimit: boolean) {
-    const modifierIcons = this.getAll().reverse();
-    for (const modifier of modifierIcons.map(m => m as Phaser.GameObjects.Container).slice(iconOverflowIndex)) {
+    const modifierIcons = this.getAll().reverse() as Phaser.GameObjects.Container[];
+    for (const modifier of modifierIcons.slice(iconOverflowIndex)) {
       modifier.setVisible(ignoreLimit);
     }
   }

src/system/game-data.ts

@@ -127,6 +127,7 @@ export interface SessionSaveData {
   battleType: BattleType;
   trainer: TrainerData;
   gameVersion: string;
+  runNameText: string;
   timestamp: number;
   challenges: ChallengeData[];
   mysteryEncounterType: MysteryEncounterType | -1; // Only defined when current wave is ME,
@@ -206,10 +207,12 @@ export interface StarterData {
   [key: number]: StarterDataEntry;
 }
 
-export interface TutorialFlags {
-  [key: string]: boolean;
-}
+// TODO: Rework into a bitmask
+export type TutorialFlags = {
+  [key in Tutorial]: boolean;
+};
 
+// TODO: Rework into a bitmask
 export interface SeenDialogues {
   [key: string]: boolean;
 }
@@ -822,52 +825,51 @@ export class GameData {
     return true; // TODO: is `true` the correct return value?
   }
 
-  private loadGamepadSettings(): boolean {
-    Object.values(SettingGamepad)
-      .map(setting => setting as SettingGamepad)
-      .forEach(setting => setSettingGamepad(setting, settingGamepadDefaults[setting]));
+  private loadGamepadSettings(): void {
+    Object.values(SettingGamepad).forEach(setting => {
+      setSettingGamepad(setting, settingGamepadDefaults[setting]);
+    });
 
     if (!localStorage.hasOwnProperty("settingsGamepad")) {
-      return false;
+      return;
     }
     const settingsGamepad = JSON.parse(localStorage.getItem("settingsGamepad")!); // TODO: is this bang correct?
 
     for (const setting of Object.keys(settingsGamepad)) {
       setSettingGamepad(setting as SettingGamepad, settingsGamepad[setting]);
     }
-
-    return true; // TODO: is `true` the correct return value?
   }
 
-  public saveTutorialFlag(tutorial: Tutorial, flag: boolean): boolean {
-    const key = getDataTypeKey(GameDataType.TUTORIALS);
-    let tutorials: object = {};
-    if (localStorage.hasOwnProperty(key)) {
-      tutorials = JSON.parse(localStorage.getItem(key)!); // TODO: is this bang correct?
-    }
+  /**
+   * Save the specified tutorial as having the specified completion status.
+   * @param tutorial - The {@linkcode Tutorial} whose completion status is being saved
+   * @param status - The completion status to set
+   */
+  public saveTutorialFlag(tutorial: Tutorial, status: boolean): void {
+    // Grab the prior save data tutorial
+    const saveDataKey = getDataTypeKey(GameDataType.TUTORIALS);
+    const tutorials: TutorialFlags = localStorage.hasOwnProperty(saveDataKey)
+      ? JSON.parse(localStorage.getItem(saveDataKey)!)
+      : {};
 
-    Object.keys(Tutorial)
-      .map(t => t as Tutorial)
-      .forEach(t => {
-        const key = Tutorial[t];
+    // TODO: We shouldn't be storing this like that
+    for (const key of Object.values(Tutorial)) {
       if (key === tutorial) {
-          tutorials[key] = flag;
+        tutorials[key] = status;
       } else {
         tutorials[key] ??= false;
       }
-      });
+    }
 
-    localStorage.setItem(key, JSON.stringify(tutorials));
-
-    return true;
+    localStorage.setItem(saveDataKey, JSON.stringify(tutorials));
   }
 
   public getTutorialFlags(): TutorialFlags {
     const key = getDataTypeKey(GameDataType.TUTORIALS);
-    const ret: TutorialFlags = {};
-    Object.values(Tutorial)
-      .map(tutorial => tutorial as Tutorial)
-      .forEach(tutorial => (ret[Tutorial[tutorial]] = false));
+    const ret: TutorialFlags = Object.values(Tutorial).reduce((acc, tutorial) => {
+      acc[Tutorial[tutorial]] = false;
+      return acc;
+    }, {} as TutorialFlags);
 
     if (!localStorage.hasOwnProperty(key)) {
       return ret;
@@ -979,6 +981,54 @@ export class GameData {
     });
   }
 
+  async renameSession(slotId: number, newName: string): Promise<boolean> {
+    return new Promise(async resolve => {
+      if (slotId < 0) {
+        return resolve(false);
+      }
+      const sessionData: SessionSaveData | null = await this.getSession(slotId);
+
+      if (!sessionData) {
+        return resolve(false);
+      }
+
+      if (newName === "") {
+        return resolve(true);
+      }
+
+      sessionData.runNameText = newName;
+      const updatedDataStr = JSON.stringify(sessionData);
+      const encrypted = encrypt(updatedDataStr, bypassLogin);
+      const secretId = this.secretId;
+      const trainerId = this.trainerId;
+
+      if (bypassLogin) {
+        localStorage.setItem(
+          `sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`,
+          encrypt(updatedDataStr, bypassLogin),
+        );
+        resolve(true);
+        return;
+      }
+      pokerogueApi.savedata.session
+        .update({ slot: slotId, trainerId, secretId, clientSessionId }, encrypted)
+        .then(error => {
+          if (error) {
+            console.error("Failed to update session name:", error);
+            resolve(false);
+          } else {
+            localStorage.setItem(`sessionData${slotId ? slotId : ""}_${loggedInUser?.username}`, encrypted);
+            updateUserInfo().then(success => {
+              if (success !== null && !success) {
+                return resolve(false);
+              }
+            });
+            resolve(true);
+          }
+        });
+    });
+  }
+
   loadSession(slotId: number, sessionData?: SessionSaveData): Promise<boolean> {
     // biome-ignore lint/suspicious/noAsyncPromiseExecutor: TODO: fix this
     return new Promise(async (resolve, reject) => {

src/ui/rename-run-ui-handler.ts

@@ -0,0 +1,54 @@
+import i18next from "i18next";
+import type { InputFieldConfig } from "./form-modal-ui-handler";
+import { FormModalUiHandler } from "./form-modal-ui-handler";
+import type { ModalConfig } from "./modal-ui-handler";
+
+export class RenameRunFormUiHandler extends FormModalUiHandler {
+  getModalTitle(_config?: ModalConfig): string {
+    return i18next.t("menu:renamerun");
+  }
+
+  getWidth(_config?: ModalConfig): number {
+    return 160;
+  }
+
+  getMargin(_config?: ModalConfig): [number, number, number, number] {
+    return [0, 0, 48, 0];
+  }
+
+  getButtonLabels(_config?: ModalConfig): string[] {
+    return [i18next.t("menu:rename"), i18next.t("menu:cancel")];
+  }
+
+  getReadableErrorMessage(error: string): string {
+    const colonIndex = error?.indexOf(":");
+    if (colonIndex > 0) {
+      error = error.slice(0, colonIndex);
+    }
+
+    return super.getReadableErrorMessage(error);
+  }
+
+  override getInputFieldConfigs(): InputFieldConfig[] {
+    return [{ label: i18next.t("menu:runName") }];
+  }
+
+  show(args: any[]): boolean {
+    if (!super.show(args)) {
+      return false;
+    }
+    if (this.inputs?.length) {
+      this.inputs.forEach(input => {
+        input.text = "";
+      });
+    }
+    const config = args[0] as ModalConfig;
+    this.submitAction = _ => {
+      this.sanitizeInputs();
+      const sanitizedName = btoa(encodeURIComponent(this.inputs[0].text));
+      config.buttonActions[0](sanitizedName);
+      return true;
+    };
+    return true;
+  }
+}

src/ui/run-info-ui-handler.ts

@@ -26,6 +26,7 @@ import { addBBCodeTextObject, addTextObject, getTextColor } from "#ui/text";
 import { UiHandler } from "#ui/ui-handler";
 import { addWindow } from "#ui/ui-theme";
 import { formatFancyLargeNumber, formatLargeNumber, formatMoney, getPlayTimeString } from "#utils/common";
+import { toCamelCase } from "#utils/strings";
 import i18next from "i18next";
 import RoundRectangle from "phaser3-rex-plugins/plugins/roundrectangle";
 
@@ -207,6 +208,10 @@ export class RunInfoUiHandler extends UiHandler {
     headerText.setOrigin(0, 0);
     headerText.setPositionRelative(headerBg, 8, 4);
     this.runContainer.add(headerText);
+    const runName = addTextObject(0, 0, this.runInfo.runNameText, TextStyle.WINDOW);
+    runName.setOrigin(0, 0);
+    runName.setPositionRelative(headerBg, 60, 4);
+    this.runContainer.add(runName);
   }
 
   /**
@@ -702,10 +707,7 @@ export class RunInfoUiHandler extends UiHandler {
             rules.push(i18next.t("challenges:inverseBattle.shortName"));
             break;
           default: {
-            const localizationKey = Challenges[this.runInfo.challenges[i].id]
-              .split("_")
-              .map((f, i) => (i ? `${f[0]}${f.slice(1).toLowerCase()}` : f.toLowerCase()))
-              .join("");
+            const localizationKey = toCamelCase(Challenges[this.runInfo.challenges[i].id]);
             rules.push(i18next.t(`challenges:${localizationKey}.name`));
             break;
           }

src/ui/save-slot-select-ui-handler.ts

@@ -1,12 +1,14 @@
 import { GameMode } from "#app/game-mode";
 import { globalScene } from "#app/global-scene";
 import { Button } from "#enums/buttons";
+import { GameModes } from "#enums/game-modes";
 import { TextStyle } from "#enums/text-style";
 import { UiMode } from "#enums/ui-mode";
 // biome-ignore lint/performance/noNamespaceImport: See `src/system/game-data.ts`
 import * as Modifier from "#modifiers/modifier";
 import type { SessionSaveData } from "#system/game-data";
 import type { PokemonData } from "#system/pokemon-data";
+import type { OptionSelectConfig } from "#ui/abstract-option-select-ui-handler";
 import { MessageUiHandler } from "#ui/message-ui-handler";
 import { RunDisplayMode } from "#ui/run-info-ui-handler";
 import { addTextObject } from "#ui/text";
@@ -15,7 +17,7 @@ import { fixedInt, formatLargeNumber, getPlayTimeString, isNullOrUndefined } fro
 import i18next from "i18next";
 
 const SESSION_SLOTS_COUNT = 5;
-const SLOTS_ON_SCREEN = 3;
+const SLOTS_ON_SCREEN = 2;
 
 export enum SaveSlotUiMode {
   LOAD,
@@ -33,6 +35,7 @@ export class SaveSlotSelectUiHandler extends MessageUiHandler {
 
   private uiMode: SaveSlotUiMode;
   private saveSlotSelectCallback: SaveSlotSelectCallback | null;
+  protected manageDataConfig: OptionSelectConfig;
 
   private scrollCursor = 0;
 
@@ -101,6 +104,7 @@ export class SaveSlotSelectUiHandler extends MessageUiHandler {
 
   processInput(button: Button): boolean {
     const ui = this.getUi();
+    const manageDataOptions: any[] = [];
 
     let success = false;
     let error = false;
@@ -109,14 +113,115 @@ export class SaveSlotSelectUiHandler extends MessageUiHandler {
       const originalCallback = this.saveSlotSelectCallback;
       if (button === Button.ACTION) {
         const cursor = this.cursor + this.scrollCursor;
-        if (this.uiMode === SaveSlotUiMode.LOAD && !this.sessionSlots[cursor].hasData) {
+        const sessionSlot = this.sessionSlots[cursor];
+        if (this.uiMode === SaveSlotUiMode.LOAD && !sessionSlot.hasData) {
           error = true;
         } else {
           switch (this.uiMode) {
             case SaveSlotUiMode.LOAD:
-              this.saveSlotSelectCallback = null;
+              if (!sessionSlot.malformed) {
+                manageDataOptions.push({
+                  label: i18next.t("menu:loadGame"),
+                  handler: () => {
+                    globalScene.ui.revertMode();
                     originalCallback?.(cursor);
+                    return true;
+                  },
+                  keepOpen: false,
+                });
+
+                manageDataOptions.push({
+                  label: i18next.t("saveSlotSelectUiHandler:renameRun"),
+                  handler: () => {
+                    globalScene.ui.revertMode();
+                    ui.setOverlayMode(
+                      UiMode.RENAME_RUN,
+                      {
+                        buttonActions: [
+                          (sanitizedName: string) => {
+                            const name = decodeURIComponent(atob(sanitizedName));
+                            globalScene.gameData.renameSession(cursor, name).then(response => {
+                              if (response[0] === false) {
+                                globalScene.reset(true);
+                              } else {
+                                this.clearSessionSlots();
+                                this.cursorObj = null;
+                                this.populateSessionSlots();
+                                this.setScrollCursor(0);
+                                this.setCursor(0);
+                                ui.revertMode();
+                                ui.showText("", 0);
+                              }
+                            });
+                          },
+                          () => {
+                            ui.revertMode();
+                          },
+                        ],
+                      },
+                      "",
+                    );
+                    return true;
+                  },
+                });
+              }
+
+              this.manageDataConfig = {
+                xOffset: 0,
+                yOffset: 48,
+                options: manageDataOptions,
+                maxOptions: 4,
+              };
+
+              manageDataOptions.push({
+                label: i18next.t("saveSlotSelectUiHandler:deleteRun"),
+                handler: () => {
+                  globalScene.ui.revertMode();
+                  ui.showText(i18next.t("saveSlotSelectUiHandler:deleteData"), null, () => {
+                    ui.setOverlayMode(
+                      UiMode.CONFIRM,
+                      () => {
+                        globalScene.gameData.tryClearSession(cursor).then(response => {
+                          if (response[0] === false) {
+                            globalScene.reset(true);
+                          } else {
+                            this.clearSessionSlots();
+                            this.cursorObj = null;
+                            this.populateSessionSlots();
+                            this.setScrollCursor(0);
+                            this.setCursor(0);
+                            ui.revertMode();
+                            ui.showText("", 0);
+                          }
+                        });
+                      },
+                      () => {
+                        ui.revertMode();
+                        ui.showText("", 0);
+                      },
+                      false,
+                      0,
+                      19,
+                      import.meta.env.DEV ? 300 : 2000,
+                    );
+                  });
+                  return true;
+                },
+                keepOpen: false,
+              });
+
+              manageDataOptions.push({
+                label: i18next.t("menuUiHandler:cancel"),
+                handler: () => {
+                  globalScene.ui.revertMode();
+                  return true;
+                },
+                keepOpen: true,
+              });
+
+              ui.setOverlayMode(UiMode.MENU_OPTION_SELECT, this.manageDataConfig);
               break;
+
             case SaveSlotUiMode.SAVE: {
               const saveAndCallback = () => {
                 const originalCallback = this.saveSlotSelectCallback;
@@ -161,6 +266,7 @@ export class SaveSlotSelectUiHandler extends MessageUiHandler {
         }
       } else {
         this.saveSlotSelectCallback = null;
+        ui.showText("", 0);
         originalCallback?.(-1);
         success = true;
       }
@@ -267,33 +373,34 @@ export class SaveSlotSelectUiHandler extends MessageUiHandler {
       this.cursorObj = globalScene.add.container(0, 0);
       const cursorBox = globalScene.add.nineslice(
         0,
-        0,
+        15,
         "select_cursor_highlight_thick",
         undefined,
-        296,
-        44,
+        294,
+        this.sessionSlots[prevSlotIndex ?? 0]?.saveData?.runNameText ? 50 : 60,
         6,
         6,
         6,
         6,
       );
       const rightArrow = globalScene.add.image(0, 0, "cursor");
-      rightArrow.setPosition(160, 0);
+      rightArrow.setPosition(160, 15);
       rightArrow.setName("rightArrow");
       this.cursorObj.add([cursorBox, rightArrow]);
       this.sessionSlotsContainer.add(this.cursorObj);
     }
     const cursorPosition = cursor + this.scrollCursor;
-    const cursorIncrement = cursorPosition * 56;
+    const cursorIncrement = cursorPosition * 76;
     if (this.sessionSlots[cursorPosition] && this.cursorObj) {
-      const hasData = this.sessionSlots[cursorPosition].hasData;
+      const session = this.sessionSlots[cursorPosition];
+      const hasData = session.hasData && !session.malformed;
       // If the session slot lacks session data, it does not move from its default, central position.
       // Only session slots with session data will move leftwards and have a visible arrow.
       if (!hasData) {
-        this.cursorObj.setPosition(151, 26 + cursorIncrement);
+        this.cursorObj.setPosition(151, 20 + cursorIncrement);
         this.sessionSlots[cursorPosition].setPosition(0, cursorIncrement);
       } else {
-        this.cursorObj.setPosition(145, 26 + cursorIncrement);
+        this.cursorObj.setPosition(145, 20 + cursorIncrement);
         this.sessionSlots[cursorPosition].setPosition(-6, cursorIncrement);
       }
       this.setArrowVisibility(hasData);
@@ -311,7 +418,8 @@ export class SaveSlotSelectUiHandler extends MessageUiHandler {
   revertSessionSlot(slotIndex: number): void {
     const sessionSlot = this.sessionSlots[slotIndex];
     if (sessionSlot) {
-      sessionSlot.setPosition(0, slotIndex * 56);
+      const valueHeight = 76;
+      sessionSlot.setPosition(0, slotIndex * valueHeight);
     }
   }
 
@@ -340,7 +448,7 @@ export class SaveSlotSelectUiHandler extends MessageUiHandler {
       this.setCursor(this.cursor, prevSlotIndex);
       globalScene.tweens.add({
         targets: this.sessionSlotsContainer,
-        y: this.sessionSlotsContainerInitialY - 56 * scrollCursor,
+        y: this.sessionSlotsContainerInitialY - 76 * scrollCursor,
         duration: fixedInt(325),
         ease: "Sine.easeInOut",
       });
@@ -374,12 +482,14 @@ export class SaveSlotSelectUiHandler extends MessageUiHandler {
 class SessionSlot extends Phaser.GameObjects.Container {
   public slotId: number;
   public hasData: boolean;
+  /** Indicates the save slot ran into an error while being loaded */
+  public malformed: boolean;
+  private slotWindow: Phaser.GameObjects.NineSlice;
   private loadingLabel: Phaser.GameObjects.Text;
-
   public saveData: SessionSaveData;
 
   constructor(slotId: number) {
-    super(globalScene, 0, slotId * 56);
+    super(globalScene, 0, slotId * 76);
 
     this.slotId = slotId;
 
@@ -387,32 +497,89 @@ class SessionSlot extends Phaser.GameObjects.Container {
   }
 
   setup() {
-    const slotWindow = addWindow(0, 0, 304, 52);
-    this.add(slotWindow);
+    this.slotWindow = addWindow(0, 0, 304, 70);
+    this.add(this.slotWindow);
 
-    this.loadingLabel = addTextObject(152, 26, i18next.t("saveSlotSelectUiHandler:loading"), TextStyle.WINDOW);
+    this.loadingLabel = addTextObject(152, 33, i18next.t("saveSlotSelectUiHandler:loading"), TextStyle.WINDOW);
     this.loadingLabel.setOrigin(0.5, 0.5);
     this.add(this.loadingLabel);
   }
 
+  /**
+   * Generates a name for sessions that don't have a name yet.
+   * @param data - The {@linkcode SessionSaveData} being checked
+   * @returns The default name for the given data.
+   */
+  decideFallback(data: SessionSaveData): string {
+    let fallbackName = `${GameMode.getModeName(data.gameMode)}`;
+    switch (data.gameMode) {
+      case GameModes.CLASSIC:
+        fallbackName += ` (${globalScene.gameData.gameStats.classicSessionsPlayed + 1})`;
+        break;
+      case GameModes.ENDLESS:
+      case GameModes.SPLICED_ENDLESS:
+        fallbackName += ` (${globalScene.gameData.gameStats.endlessSessionsPlayed + 1})`;
+        break;
+      case GameModes.DAILY: {
+        const runDay = new Date(data.timestamp).toLocaleDateString();
+        fallbackName += ` (${runDay})`;
+        break;
+      }
+      case GameModes.CHALLENGE: {
+        const activeChallenges = data.challenges.filter(c => c.value !== 0);
+        if (activeChallenges.length === 0) {
+          break;
+        }
+
+        fallbackName = "";
+        for (const challenge of activeChallenges.slice(0, 3)) {
+          if (fallbackName !== "") {
+            fallbackName += ", ";
+          }
+          fallbackName += challenge.toChallenge().getName();
+        }
+
+        if (activeChallenges.length > 3) {
+          fallbackName += ", ...";
+        } else if (fallbackName === "") {
+          // Something went wrong when retrieving the names of the active challenges,
+          // so fall back to just naming the run "Challenge"
+          fallbackName = `${GameMode.getModeName(data.gameMode)}`;
+        }
+        break;
+      }
+    }
+    return fallbackName;
+  }
+
   async setupWithData(data: SessionSaveData) {
+    const hasName = data?.runNameText;
     this.remove(this.loadingLabel, true);
+    if (hasName) {
+      const nameLabel = addTextObject(8, 5, data.runNameText, TextStyle.WINDOW);
+      this.add(nameLabel);
+    } else {
+      const fallbackName = this.decideFallback(data);
+      await globalScene.gameData.renameSession(this.slotId, fallbackName);
+      const nameLabel = addTextObject(8, 5, fallbackName, TextStyle.WINDOW);
+      this.add(nameLabel);
+    }
 
     const gameModeLabel = addTextObject(
       8,
-      5,
+      19,
       `${GameMode.getModeName(data.gameMode) || i18next.t("gameMode:unknown")} - ${i18next.t("saveSlotSelectUiHandler:wave")} ${data.waveIndex}`,
       TextStyle.WINDOW,
     );
     this.add(gameModeLabel);
 
-    const timestampLabel = addTextObject(8, 19, new Date(data.timestamp).toLocaleString(), TextStyle.WINDOW);
+    const timestampLabel = addTextObject(8, 33, new Date(data.timestamp).toLocaleString(), TextStyle.WINDOW);
     this.add(timestampLabel);
 
-    const playTimeLabel = addTextObject(8, 33, getPlayTimeString(data.playTime), TextStyle.WINDOW);
+    const playTimeLabel = addTextObject(8, 47, getPlayTimeString(data.playTime), TextStyle.WINDOW);
     this.add(playTimeLabel);
 
-    const pokemonIconsContainer = globalScene.add.container(144, 4);
+    const pokemonIconsContainer = globalScene.add.container(144, 16);
     data.party.forEach((p: PokemonData, i: number) => {
       const iconContainer = globalScene.add.container(26 * i, 0);
       iconContainer.setScale(0.75);
@@ -427,13 +594,9 @@ class SessionSlot extends Phaser.GameObjects.Container {
         TextStyle.PARTY,
         { fontSize: "54px", color: "#f8f8f8" },
       );
-      text.setShadow(0, 0, undefined);
-      text.setStroke("#424242", 14);
-      text.setOrigin(1, 0);
-
-      iconContainer.add(icon);
-      iconContainer.add(text);
+      text.setShadow(0, 0, undefined).setStroke("#424242", 14).setOrigin(1, 0);
 
+      iconContainer.add([icon, text]);
       pokemonIconsContainer.add(iconContainer);
 
       pokemon.destroy();
@@ -441,7 +604,7 @@ class SessionSlot extends Phaser.GameObjects.Container {
 
     this.add(pokemonIconsContainer);
 
-    const modifierIconsContainer = globalScene.add.container(148, 30);
+    const modifierIconsContainer = globalScene.add.container(148, 38);
     modifierIconsContainer.setScale(0.5);
     let visibleModifierIndex = 0;
     for (const m of data.modifiers) {
@@ -464,20 +627,31 @@ class SessionSlot extends Phaser.GameObjects.Container {
 
   load(): Promise<boolean> {
     return new Promise<boolean>(resolve => {
-      globalScene.gameData.getSession(this.slotId).then(async sessionData => {
+      globalScene.gameData
+        .getSession(this.slotId)
+        .then(async sessionData => {
           // Ignore the results if the view was exited
           if (!this.active) {
             return;
           }
+          this.hasData = !!sessionData;
           if (!sessionData) {
-          this.hasData = false;
             this.loadingLabel.setText(i18next.t("saveSlotSelectUiHandler:empty"));
             resolve(false);
             return;
           }
-        this.hasData = true;
           this.saveData = sessionData;
-        await this.setupWithData(sessionData);
+          this.setupWithData(sessionData);
+          resolve(true);
+        })
+        .catch(e => {
+          if (!this.active) {
+            return;
+          }
+          console.warn(`Failed to load session slot #${this.slotId}:`, e);
+          this.loadingLabel.setText(i18next.t("menu:failedToLoadSession"));
+          this.hasData = true;
+          this.malformed = true;
           resolve(true);
         });
     });

src/ui/test-dialogue-ui-handler.ts

@@ -31,7 +31,7 @@ export class TestDialogueUiHandler extends FormModalUiHandler {
             // we check for null or undefined here as per above - the typeof is still an object but the value is null so we need to exit out of this and pass the null key
 
             // Return in the format expected by i18next
-            return middleKey ? `${topKey}:${middleKey.map(m => m).join(".")}.${t}` : `${topKey}:${t}`;
+            return middleKey ? `${topKey}:${middleKey.join(".")}.${t}` : `${topKey}:${t}`;
           }
         })
         .filter(t => t);

src/ui/ui.ts

@@ -60,6 +60,7 @@ import { addWindow } from "#ui/ui-theme";
 import { UnavailableModalUiHandler } from "#ui/unavailable-modal-ui-handler";
 import { executeIf } from "#utils/common";
 import i18next from "i18next";
+import { RenameRunFormUiHandler } from "./rename-run-ui-handler";
 
 const transitionModes = [
   UiMode.SAVE_SLOT,
@@ -98,6 +99,7 @@ const noTransitionModes = [
   UiMode.SESSION_RELOAD,
   UiMode.UNAVAILABLE,
   UiMode.RENAME_POKEMON,
+  UiMode.RENAME_RUN,
   UiMode.TEST_DIALOGUE,
   UiMode.AUTO_COMPLETE,
   UiMode.ADMIN,
@@ -168,6 +170,7 @@ export class UI extends Phaser.GameObjects.Container {
       new UnavailableModalUiHandler(),
       new GameChallengesUiHandler(),
       new RenameFormUiHandler(),
+      new RenameRunFormUiHandler(),
       new RunHistoryUiHandler(),
       new RunInfoUiHandler(),
       new TestDialogueUiHandler(UiMode.TEST_DIALOGUE),

test/mystery-encounter/encounters/weird-dream-encounter.test.ts

@@ -112,7 +112,7 @@ describe("Weird Dream - Mystery Encounter", () => {
     it("should transform the new party into new species, 2 at +90/+110, the rest at +40/50 BST", async () => {
       await game.runToMysteryEncounter(MysteryEncounterType.WEIRD_DREAM, defaultParty);
 
-      const pokemonPrior = scene.getPlayerParty().map(pokemon => pokemon);
+      const pokemonPrior = scene.getPlayerParty().slice();
       const bstsPrior = pokemonPrior.map(species => species.getSpeciesForm().getBaseStatTotal());
 
       await runMysteryEncounterToEnd(game, 1);

test/system/rename-run.test.ts

@@ -0,0 +1,82 @@
+import * as account from "#app/account";
+import * as bypassLoginModule from "#app/global-vars/bypass-login";
+import { pokerogueApi } from "#app/plugins/api/pokerogue-api";
+import type { SessionSaveData } from "#app/system/game-data";
+import { AbilityId } from "#enums/ability-id";
+import { MoveId } from "#enums/move-id";
+import { GameManager } from "#test/test-utils/game-manager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+describe("System - Rename Run", () => {
+  let phaserGame: Phaser.Game;
+  let game: GameManager;
+
+  beforeAll(() => {
+    phaserGame = new Phaser.Game({
+      type: Phaser.HEADLESS,
+    });
+  });
+
+  beforeEach(() => {
+    game = new GameManager(phaserGame);
+    game.override
+      .moveset([MoveId.SPLASH])
+      .battleStyle("single")
+      .enemyAbility(AbilityId.BALL_FETCH)
+      .enemyMoveset(MoveId.SPLASH);
+  });
+
+  afterEach(() => {
+    game.phaseInterceptor.restoreOg();
+  });
+
+  describe("renameSession", () => {
+    beforeEach(() => {
+      vi.spyOn(bypassLoginModule, "bypassLogin", "get").mockReturnValue(false);
+      vi.spyOn(account, "updateUserInfo").mockImplementation(async () => [true, 1]);
+    });
+
+    it("should return false if slotId < 0", async () => {
+      const result = await game.scene.gameData.renameSession(-1, "Named Run");
+
+      expect(result).toEqual(false);
+    });
+
+    it("should return false if getSession returns null", async () => {
+      vi.spyOn(game.scene.gameData, "getSession").mockResolvedValue(null as unknown as SessionSaveData);
+
+      const result = await game.scene.gameData.renameSession(-1, "Named Run");
+
+      expect(result).toEqual(false);
+    });
+
+    it("should return true if bypassLogin is true", async () => {
+      vi.spyOn(bypassLoginModule, "bypassLogin", "get").mockReturnValue(true);
+      vi.spyOn(game.scene.gameData, "getSession").mockResolvedValue({} as SessionSaveData);
+
+      const result = await game.scene.gameData.renameSession(0, "Named Run");
+
+      expect(result).toEqual(true);
+    });
+
+    it("should return false if api returns error", async () => {
+      vi.spyOn(game.scene.gameData, "getSession").mockResolvedValue({} as SessionSaveData);
+      vi.spyOn(pokerogueApi.savedata.session, "update").mockResolvedValue("Unknown Error!");
+
+      const result = await game.scene.gameData.renameSession(0, "Named Run");
+
+      expect(result).toEqual(false);
+    });
+
+    it("should return true if api is succesfull", async () => {
+      vi.spyOn(game.scene.gameData, "getSession").mockResolvedValue({} as SessionSaveData);
+      vi.spyOn(pokerogueApi.savedata.session, "update").mockResolvedValue("");
+
+      const result = await game.scene.gameData.renameSession(0, "Named Run");
+
+      expect(result).toEqual(true);
+      expect(account.updateUserInfo).toHaveBeenCalled();
+    });
+  });
+});

test/test-utils/helpers/challenge-mode-helper.ts

@@ -1,5 +1,6 @@
 import overrides from "#app/overrides";
 import type { Challenge } from "#data/challenge";
+import { copyChallenge } from "#data/challenge";
 import { BattleStyle } from "#enums/battle-style";
 import type { Challenges } from "#enums/challenges";
 import type { SpeciesId } from "#enums/species-id";
@@ -10,7 +11,6 @@ import { SelectStarterPhase } from "#phases/select-starter-phase";
 import { TurnInitPhase } from "#phases/turn-init-phase";
 import { generateStarter } from "#test/test-utils/game-manager-utils";
 import { GameManagerHelper } from "#test/test-utils/helpers/game-manager-helper";
-import { copyChallenge } from "data/challenge";
 
 /**
  * Helper to handle Challenge mode specifics

tsconfig.json

@@ -18,46 +18,46 @@
     "esModuleInterop": true,
     "strictNullChecks": true,
     "sourceMap": false,
-    "checkJs": true,
     "strict": false, // TODO: Enable this eventually
     "rootDir": ".",
-    "baseUrl": "./src",
-    "paths": {
-      "#abilities/*": ["./data/abilities/*.ts"],
-      "#api/*": ["./plugins/api/*.ts"],
-      "#balance/*": ["./data/balance/*.ts"],
-      "#enums/*": ["./enums/*.ts"],
-      "#events/*": ["./events/*.ts"],
-      "#field/*": ["./field/*.ts"],
-      "#inputs/*": ["./configs/inputs/*.ts"],
-      "#modifiers/*": ["./modifier/*.ts"],
-      "#moves/*": ["./data/moves/*.ts"],
-      "#mystery-encounters/*": [
-        "./data/mystery-encounters/utils/*.ts",
-        "./data/mystery-encounters/encounters/*.ts",
-        "./data/mystery-encounters/requirements/*.ts",
-        "./data/mystery-encounters/*.ts"
-      ],
-      "#package.json": ["../package.json"],
-      "#phases/*": ["./phases/*.ts"],
-      "#plugins/*": ["./plugins/vite/*.ts", "./plugins/*.ts"],
-      "#sprites/*": ["./sprites/*.ts"],
-      "#system/*": [
-        "./system/settings/*.ts",
-        "./system/version-migration/versions/*.ts",
-        "./system/version-migration/*.ts",
-        "./system/*.ts"
-      ],
-      "#trainers/*": ["./data/trainers/*.ts"],
-      "#types/*": ["./@types/helpers/*.ts", "./@types/*.ts", "./typings/phaser/*.ts"],
-      "#ui/*": ["./ui/battle-info/*.ts", "./ui/settings/*.ts", "./ui/*.ts"],
-      "#utils/*": ["./utils/*.ts"],
-      "#data/*": ["./data/pokemon-forms/*.ts", "./data/pokemon/*.ts", "./data/*.ts"],
-      "#test/*": ["../test/*.ts"],
-      "#app/*": ["*.ts"]
-    },
     "outDir": "./build",
-    "noEmit": true
+    "noEmit": true,
+    "paths": {
+      "#abilities/*": ["./src/data/abilities/*.ts"],
+      "#api/*": ["./src/plugins/api/*.ts"],
+      "#balance/*": ["./src/data/balance/*.ts"],
+      "#enums/*": ["./src/enums/*.ts"],
+      "#events/*": ["./src/events/*.ts"],
+      "#field/*": ["./src/field/*.ts"],
+      "#inputs/*": ["./src/configs/inputs/*.ts"],
+      "#modifiers/*": ["./src/modifier/*.ts"],
+      "#moves/*": ["./src/data/moves/*.ts"],
+      "#mystery-encounters/*": [
+        "./src/data/mystery-encounters/utils/*.ts",
+        "./src/data/mystery-encounters/encounters/*.ts",
+        "./src/data/mystery-encounters/requirements/*.ts",
+        "./src/data/mystery-encounters/*.ts"
+      ],
+      "#package.json": ["./package.json"],
+      "#phases/*": ["./src/phases/*.ts"],
+      "#plugins/*": ["./src/plugins/vite/*.ts", "./src/plugins/*.ts"],
+      "#sprites/*": ["./src/sprites/*.ts"],
+      "#system/*": [
+        "./src/system/settings/*.ts",
+        "./src/system/version-migration/versions/*.ts",
+        "./src/system/version-migration/*.ts",
+        "./src/system/*.ts"
+      ],
+      "#trainers/*": ["./src/data/trainers/*.ts"],
+      "#types/*": ["./src/@types/helpers/*.ts", "./src/@types/*.ts", "./src/typings/phaser/*.ts"],
+      "#ui/*": ["./src/ui/battle-info/*.ts", "./src/ui/settings/*.ts", "./src/ui/*.ts"],
+      "#utils/*": ["./src/utils/*.ts"],
+      "#data/*": ["./src/data/pokemon-forms/*.ts", "./src/data/pokemon/*.ts", "./src/data/*.ts"],
+      "#test/*": ["./test/*.ts"],
+      "#app/*": ["./src/*.ts"]
+    }
   },
+  // Exclude checking for script JS files as those are covered by the folder's `jsconfig/json`
+  "include": ["**/*.ts", "**/*.d.ts"],
   "exclude": ["node_modules", "dist", "vite.config.ts", "vitest.config.ts", "vitest.workspace.ts"]
 }