Removed map(x => x)

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";
@@ -1237,8 +1238,7 @@ export class BattleScene extends SceneBase {
             Object.values(mp)
               .flat()
               .map(mt => mt.modifierType)
-              .filter(mt => "localize" in mt)
+              .filter((mt): mt is ModifierType & Localizable => "localize" in mt && typeof mt.localize === "function"),
-              .map(lpb => lpb as unknown as Localizable),
           ),
       ];
       for (const item of localizable) {

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);
+  // TODO: Why do we have empty strings in our array?
-  const prevolutionKeys = Object.keys(pokemonEvolutions);
+  const megaFormKeys = [ SpeciesFormKey.MEGA, "", SpeciesFormKey.MEGA_X, "", SpeciesFormKey.MEGA_Y ]
-  prevolutionKeys.forEach(pk => {
+  for (const [pk, evolutions] of Object.entries(pokemonEvolutions)) {
-    const evolutions = pokemonEvolutions[pk];
     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

@@ -164,8 +164,14 @@ export abstract class Move implements Localizable {
   localize(): void {
     const i18nKey = toCamelCase(MoveId[this.id])
 
-    this.name = this.id ? `${i18next.t(`move:${i18nKey}.name`)}${this.nameAppend}` : "";
+    if (this.id === MoveId.NONE) {
-    this.effect = this.id ? `${i18next.t(`move:${i18nKey}.effect`)}${this.nameAppend}` : "";
+      this.name = "";
+      this.effect = ""
+      return;
+    }
+
+    this.name = `${i18next.t(`move:${i18nKey}.name`)}${this.nameAppend}`;
+    this.effect = `${i18next.t(`move:${i18nKey}.effect`)}${this.nameAppend}`;
   }
 
   /**

src/modifier/modifier.ts

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

src/system/game-data.ts

@@ -206,9 +206,9 @@ export interface StarterData {
   [key: number]: StarterDataEntry;
 }
 
-export interface TutorialFlags {
+export type TutorialFlags = {
-  [key: string]: boolean;
+  [key in Tutorials]: boolean;
-}
+};
 
 export interface SeenDialogues {
   [key: string]: boolean;
@@ -822,52 +822,51 @@ export class GameData {
     return true; // TODO: is `true` the correct return value?
   }
 
-  private loadGamepadSettings(): boolean {
+  private loadGamepadSettings(): void {
-    Object.values(SettingGamepad)
+    Object.values(SettingGamepad).forEach(setting => {
-      .map(setting => setting as SettingGamepad)
+      setSettingGamepad(setting, settingGamepadDefaults[setting]);
-      .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);
+   * Save the specified tutorial as having the specified completion status.
-    let tutorials: object = {};
+   * @param tutorial - The {@linkcode Tutorial} whose completion status is being saved
-    if (localStorage.hasOwnProperty(key)) {
+   * @param status - The completion status to set
-      tutorials = JSON.parse(localStorage.getItem(key)!); // TODO: is this bang correct?
+   */
+  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)!)
+      : {};
+
+    // TODO: We shouldn't be storing this like that
+    for (const key of Object.values(Tutorial)) {
+      if (key === tutorial) {
+        tutorials[key] = status;
+      } else {
+        tutorials[key] ??= false;
+      }
     }
 
-    Object.keys(Tutorial)
+    localStorage.setItem(saveDataKey, JSON.stringify(tutorials));
-      .map(t => t as Tutorial)
-      .forEach(t => {
-        const key = Tutorial[t];
-        if (key === tutorial) {
-          tutorials[key] = flag;
-        } else {
-          tutorials[key] ??= false;
-        }
-      });
-
-    localStorage.setItem(key, JSON.stringify(tutorials));
-
-    return true;
   }
 
   public getTutorialFlags(): TutorialFlags {
     const key = getDataTypeKey(GameDataType.TUTORIALS);
-    const ret: TutorialFlags = {};
+    const ret: TutorialFlags = Object.values(Tutorial).reduce((acc, tutorial) => {
-    Object.values(Tutorial)
+      acc[Tutorial[tutorial]] = false;
-      .map(tutorial => tutorial as Tutorial)
+      return acc;
-      .forEach(tutorial => (ret[Tutorial[tutorial]] = false));
+    }, {} as TutorialFlags);
 
     if (!localStorage.hasOwnProperty(key)) {
       return ret;

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);

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();
       const bstsPrior = pokemonPrior.map(species => species.getSpeciesForm().getBaseStatTotal());
 
       await runMysteryEncounterToEnd(game, 1);