diff --git a/src/battle-scene.ts b/src/battle-scene.ts
index bb5c9fe515d..c2145e8fa39 100644
--- a/src/battle-scene.ts
+++ b/src/battle-scene.ts
@@ -1234,12 +1234,34 @@ export default class BattleScene extends SceneBase {
       newDouble = !!double;
     }
 
-    if (Overrides.BATTLE_TYPE_OVERRIDE === "double") {
-      newDouble = true;
-    }
-    /* Override battles into single only if not fighting with trainers */
-    if (newBattleType !== BattleType.TRAINER && Overrides.BATTLE_TYPE_OVERRIDE === "single") {
-      newDouble = false;
+    if (!isNullOrUndefined(Overrides.BATTLE_TYPE_OVERRIDE)) {
+      let doubleOverrideForWave: "single" | "double" | null = null;
+
+      switch (Overrides.BATTLE_TYPE_OVERRIDE) {
+        case "double":
+          doubleOverrideForWave = "double";
+          break;
+        case "single":
+          doubleOverrideForWave = "single";
+          break;
+        case "even-doubles":
+          doubleOverrideForWave = (newWaveIndex % 2) ? "single" : "double";
+          break;
+        case "odd-doubles":
+          doubleOverrideForWave = (newWaveIndex % 2) ? "double" : "single";
+          break;
+      }
+
+      if (doubleOverrideForWave === "double") {
+        newDouble = true;
+      }
+      /**
+       * Override battles into single only if not fighting with trainers.
+       * @see {@link https://github.com/pagefaultgames/pokerogue/issues/1948 | GitHub Issue #1948}
+       */
+      if (newBattleType !== BattleType.TRAINER && doubleOverrideForWave === "single") {
+        newDouble = false;
+      }
     }
 
     const lastBattle = this.currentBattle;
diff --git a/src/data/battler-tags.ts b/src/data/battler-tags.ts
index 6439b2fa8f3..336a8981b04 100644
--- a/src/data/battler-tags.ts
+++ b/src/data/battler-tags.ts
@@ -1807,8 +1807,8 @@ export class TypeImmuneTag extends BattlerTag {
  * @see {@link https://bulbapedia.bulbagarden.net/wiki/Telekinesis_(move) | Moves.TELEKINESIS}
  */
 export class FloatingTag extends TypeImmuneTag {
-  constructor(tagType: BattlerTagType, sourceMove: Moves) {
-    super(tagType, sourceMove, Type.GROUND, 5);
+  constructor(tagType: BattlerTagType, sourceMove: Moves, turnCount: number) {
+    super(tagType, sourceMove, Type.GROUND, turnCount);
   }
 
   onAdd(pokemon: Pokemon): void {
@@ -3049,7 +3049,7 @@ export function getBattlerTag(tagType: BattlerTagType, turnCount: number, source
     case BattlerTagType.CHARGED:
       return new TypeBoostTag(tagType, sourceMove, Type.ELECTRIC, 2, true);
     case BattlerTagType.FLOATING:
-      return new FloatingTag(tagType, sourceMove);
+      return new FloatingTag(tagType, sourceMove, turnCount);
     case BattlerTagType.MINIMIZED:
       return new MinimizeTag();
     case BattlerTagType.DESTINY_BOND:
diff --git a/src/data/challenge.ts b/src/data/challenge.ts
index a09ab546b49..bf5d33ef0ac 100644
--- a/src/data/challenge.ts
+++ b/src/data/challenge.ts
@@ -653,7 +653,7 @@ export class FreshStartChallenge extends Challenge {
     pokemon.shiny = false; // Not shiny
     pokemon.variant = 0; // Not shiny
     pokemon.formIndex = 0; // Froakie should be base form
-    pokemon.ivs = [ 10, 10, 10, 10, 10, 10 ]; // Default IVs of 10 for all stats
+    pokemon.ivs = [ 15, 15, 15, 15, 15, 15 ]; // Default IVs of 15 for all stats (Updated to 15 from 10 in 1.2.0)
     return true;
   }
 
diff --git a/src/data/move.ts b/src/data/move.ts
index d0293995960..ec8b497e62e 100644
--- a/src/data/move.ts
+++ b/src/data/move.ts
@@ -8898,7 +8898,7 @@ export function initMoves() {
     new SelfStatusMove(Moves.AQUA_RING, Type.WATER, -1, 20, -1, 0, 4)
       .attr(AddBattlerTagAttr, BattlerTagType.AQUA_RING, true, true),
     new SelfStatusMove(Moves.MAGNET_RISE, Type.ELECTRIC, -1, 10, -1, 0, 4)
-      .attr(AddBattlerTagAttr, BattlerTagType.FLOATING, true, true)
+      .attr(AddBattlerTagAttr, BattlerTagType.FLOATING, true, true, 5)
       .condition((user, target, move) => !globalScene.arena.getTag(ArenaTagType.GRAVITY) && [ BattlerTagType.FLOATING, BattlerTagType.IGNORE_FLYING, BattlerTagType.INGRAIN ].every((tag) => !user.getTag(tag))),
     new AttackMove(Moves.FLARE_BLITZ, Type.FIRE, MoveCategory.PHYSICAL, 120, 100, 15, 10, 0, 4)
       .attr(RecoilAttr, false, 0.33)
diff --git a/src/overrides.ts b/src/overrides.ts
index d7a8ee18f15..7b73cd47b03 100644
--- a/src/overrides.ts
+++ b/src/overrides.ts
@@ -47,7 +47,18 @@ class DefaultOverrides {
   /** a specific seed (default: a random string of 24 characters) */
   readonly SEED_OVERRIDE: string = "";
   readonly WEATHER_OVERRIDE: WeatherType = WeatherType.NONE;
-  readonly BATTLE_TYPE_OVERRIDE: "double" | "single" | null = null;
+  /**
+   * If `null`, ignore this override.
+   *
+   * If `"single"`, set every non-trainer battle to be a single battle.
+   *
+   * If `"double"`, set every battle (including trainer battles) to be a double battle.
+   *
+   * If `"even-doubles"`, follow the `"double"` rule on even wave numbers, and follow the `"single"` rule on odd wave numbers.
+   *
+   * If `"odd-doubles"`, follow the `"double"` rule on odd wave numbers, and follow the `"single"` rule on even wave numbers.
+   */
+  readonly BATTLE_TYPE_OVERRIDE: BattleStyle | null = null;
   readonly STARTING_WAVE_OVERRIDE: number = 0;
   readonly STARTING_BIOME_OVERRIDE: Biome = Biome.TOWN;
   readonly ARENA_TINT_OVERRIDE: TimeOfDay | null = null;
@@ -229,3 +240,5 @@ export default {
   ...defaultOverrides,
   ...overrides
 } satisfies InstanceType<typeof DefaultOverrides>;
+
+export type BattleStyle = "double" | "single" | "even-doubles" | "odd-doubles";
diff --git a/src/system/game-data.ts b/src/system/game-data.ts
index ba459d2a5bd..10378668846 100644
--- a/src/system/game-data.ts
+++ b/src/system/game-data.ts
@@ -676,7 +676,7 @@ export class GameData {
         return ret;
       }
 
-      return k.endsWith("Attr") && ![ "natureAttr", "abilityAttr", "passiveAttr" ].includes(k) ? BigInt(v) : v;
+      return k.endsWith("Attr") && ![ "natureAttr", "abilityAttr", "passiveAttr" ].includes(k) ? BigInt(v ?? 0) : v;
     }) as SystemSaveData;
   }
 
@@ -1530,7 +1530,7 @@ export class GameData {
       entry.caughtAttr = defaultStarterAttr;
       entry.natureAttr = 1 << (defaultStarterNatures[ds] + 1);
       for (const i in entry.ivs) {
-        entry.ivs[i] = 10;
+        entry.ivs[i] = 15;
       }
     }
 
diff --git a/src/test/battle/double_battle.test.ts b/src/test/battle/double_battle.test.ts
index 1fc24bfc027..b48f2a96a5b 100644
--- a/src/test/battle/double_battle.test.ts
+++ b/src/test/battle/double_battle.test.ts
@@ -1,4 +1,6 @@
 import { Status } from "#app/data/status-effect";
+import { Abilities } from "#enums/abilities";
+import { GameModes, getGameMode } from "#app/game-mode";
 import { BattleEndPhase } from "#app/phases/battle-end-phase";
 import { TurnInitPhase } from "#app/phases/turn-init-phase";
 import { Moves } from "#enums/moves";
@@ -6,9 +8,11 @@ import { Species } from "#enums/species";
 import { StatusEffect } from "#enums/status-effect";
 import GameManager from "#test/utils/gameManager";
 import Phaser from "phaser";
-import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
 describe("Double Battles", () => {
+  const DOUBLE_CHANCE = 8; // Normal chance of double battle is 1/8
+
   let phaserGame: Phaser.Game;
   let game: GameManager;
 
@@ -56,4 +60,40 @@ describe("Double Battles", () => {
     await game.phaseInterceptor.to(TurnInitPhase);
     expect(game.scene.getPlayerField().filter(p => !p.isFainted())).toHaveLength(2);
   }, 20000);
+
+  it("randomly chooses between single and double battles if there is no battle type override", async () => {
+    let rngSweepProgress = 0; // Will simulate RNG rolls by slowly increasing from 0 to 1
+    let doubleCount = 0;
+    let singleCount = 0;
+
+    vi.spyOn(Phaser.Math.RND, "realInRange").mockImplementation((min: number, max: number) => {
+      return rngSweepProgress * (max - min) + min;
+    });
+
+    game.override.enemyMoveset(Moves.SPLASH)
+      .moveset(Moves.SPLASH)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .ability(Abilities.BALL_FETCH);
+
+    // Play through endless, waves 1 to 9, counting number of double battles from waves 2 to 9
+    await game.classicMode.startBattle([ Species.BULBASAUR ]);
+    game.scene.gameMode = getGameMode(GameModes.ENDLESS);
+
+    for (let i = 0; i < DOUBLE_CHANCE; i++) {
+      rngSweepProgress = (i + 0.5) / DOUBLE_CHANCE;
+
+      game.move.select(Moves.SPLASH);
+      await game.doKillOpponents();
+      await game.toNextWave();
+
+      if (game.scene.getEnemyParty().length === 1) {
+        singleCount++;
+      } else if (game.scene.getEnemyParty().length === 2) {
+        doubleCount++;
+      }
+    }
+
+    expect(doubleCount).toBe(1);
+    expect(singleCount).toBe(DOUBLE_CHANCE - 1);
+  });
 });
diff --git a/src/test/moves/gastro_acid.test.ts b/src/test/moves/gastro_acid.test.ts
index fdd75b90b13..ec9246c855c 100644
--- a/src/test/moves/gastro_acid.test.ts
+++ b/src/test/moves/gastro_acid.test.ts
@@ -62,7 +62,7 @@ describe("Moves - Gastro Acid", () => {
   });
 
   it("fails if used on an enemy with an already-suppressed ability", async () => {
-    game.override.battleType(null);
+    game.override.battleType("single");
 
     await game.startBattle();
 
diff --git a/src/test/utils/helpers/overridesHelper.ts b/src/test/utils/helpers/overridesHelper.ts
index 02950d497ee..1c05f92a334 100644
--- a/src/test/utils/helpers/overridesHelper.ts
+++ b/src/test/utils/helpers/overridesHelper.ts
@@ -4,7 +4,7 @@ import { Abilities } from "#app/enums/abilities";
 import * as GameMode from "#app/game-mode";
 import { GameModes, getGameMode } from "#app/game-mode";
 import { ModifierOverride } from "#app/modifier/modifier-type";
-import Overrides from "#app/overrides";
+import Overrides, { BattleStyle } from "#app/overrides";
 import { Unlockables } from "#app/system/unlockables";
 import { Biome } from "#enums/biome";
 import { Moves } from "#enums/moves";
@@ -238,13 +238,14 @@ export class OverridesHelper extends GameManagerHelper {
   }
 
   /**
-   * Override the battle type (single or double)
+   * Override the battle type (e.g., single or double).
+   * @see {@linkcode Overrides.BATTLE_TYPE_OVERRIDE}
    * @param battleType battle type to set
    * @returns `this`
    */
-  public battleType(battleType: "single" | "double" | null): this {
+  public battleType(battleType: BattleStyle | null): this {
     vi.spyOn(Overrides, "BATTLE_TYPE_OVERRIDE", "get").mockReturnValue(battleType);
-    this.log(`Battle type set to ${battleType} only!`);
+    this.log(battleType === null ? "Battle type override disabled!" : `Battle type set to ${battleType}!`);
     return this;
   }