diff --git a/src/data/battler-tags.ts b/src/data/battler-tags.ts
index ebbab7bfa4a..5726a5d53f3 100644
--- a/src/data/battler-tags.ts
+++ b/src/data/battler-tags.ts
@@ -909,11 +909,15 @@ export class FrenzyTag extends BattlerTag {
   }
 }
 
-export class EncoreTag extends BattlerTag {
+/**
+ * Applies the effects of the move Encore onto the target Pokemon
+ * Encore forces the target Pokemon to use its most-recent move for 3 turns
+ */
+export class EncoreTag extends MoveRestrictionBattlerTag {
   public moveId: Moves;
 
   constructor(sourceId: number) {
-    super(BattlerTagType.ENCORE, BattlerTagLapseType.AFTER_MOVE, 3, Moves.ENCORE, sourceId);
+    super(BattlerTagType.ENCORE, [ BattlerTagLapseType.CUSTOM, BattlerTagLapseType.AFTER_MOVE ], 3, Moves.ENCORE, sourceId);
   }
 
   /**
@@ -969,6 +973,39 @@ export class EncoreTag extends BattlerTag {
     }
   }
 
+  /**
+   * If the encored move has run out of PP, Encore ends early. Otherwise, Encore lapses based on the AFTER_MOVE battler tag lapse type.
+   * @returns `true` to persist | `false` to end and be removed
+   */
+  override lapse(pokemon: Pokemon, lapseType: BattlerTagLapseType): boolean {
+    if (lapseType === BattlerTagLapseType.CUSTOM) {
+      const encoredMove = pokemon.getMoveset().find(m => m?.moveId === this.moveId);
+      if (encoredMove && encoredMove?.getPpRatio() > 0) {
+        return true;
+      }
+      return false;
+    } else {
+      return super.lapse(pokemon, lapseType);
+    }
+  }
+
+  /**
+   * Checks if the move matches the moveId stored within the tag and returns a boolean value
+   * @param move {@linkcode Moves} the move selected
+   * @param user N/A
+   * @returns `true` if the move does not match with the moveId stored and as a result, restricted
+   */
+  override isMoveRestricted(move: Moves, _user?: Pokemon): boolean {
+    if (move !== this.moveId) {
+      return true;
+    }
+    return false;
+  }
+
+  override selectionDeniedText(_pokemon: Pokemon, move: Moves): string {
+    return i18next.t("battle:moveDisabled", { moveName: allMoves[move].name });
+  }
+
   onRemove(pokemon: Pokemon): void {
     super.onRemove(pokemon);
 
@@ -2360,7 +2397,7 @@ export class HealBlockTag extends MoveRestrictionBattlerTag {
   }
 
   /**
-   * Uses DisabledTag's selectionDeniedText() message
+   * Uses its own unique selectionDeniedText() message
    */
   override selectionDeniedText(pokemon: Pokemon, move: Moves): string {
     return i18next.t("battle:moveDisabledHealBlock", { pokemonNameWithAffix: getPokemonNameWithAffix(pokemon), moveName: allMoves[move].name, healBlockName: allMoves[Moves.HEAL_BLOCK].name });
diff --git a/src/phases/command-phase.ts b/src/phases/command-phase.ts
index 547805ec1d1..6163b428603 100644
--- a/src/phases/command-phase.ts
+++ b/src/phases/command-phase.ts
@@ -61,6 +61,12 @@ export class CommandPhase extends FieldPhase {
       this.scene.currentBattle.turnCommands[this.fieldIndex] = { command: Command.FIGHT, move: { move: Moves.NONE, targets: []}, skip: true };
     }
 
+    // Checks if the Pokemon is under the effects of Encore. If so, Encore can end early if the encored move has no more PP.
+    const encoreTag = this.getPokemon().getTag(BattlerTagType.ENCORE) as EncoreTag;
+    if (encoreTag) {
+      this.getPokemon().lapseTag(BattlerTagType.ENCORE);
+    }
+
     if (this.scene.currentBattle.turnCommands[this.fieldIndex]?.skip) {
       return this.end();
     }
@@ -291,26 +297,6 @@ export class CommandPhase extends FieldPhase {
     }
   }
 
-  checkFightOverride(): boolean {
-    const pokemon = this.getPokemon();
-
-    const encoreTag = pokemon.getTag(EncoreTag) as EncoreTag;
-
-    if (!encoreTag) {
-      return false;
-    }
-
-    const moveIndex = pokemon.getMoveset().findIndex(m => m?.moveId === encoreTag.moveId);
-
-    if (moveIndex === -1 || !pokemon.getMoveset()[moveIndex]!.isUsable(pokemon)) { // TODO: is this bang correct?
-      return false;
-    }
-
-    this.handleCommand(Command.FIGHT, moveIndex, false);
-
-    return true;
-  }
-
   getFieldIndex(): integer {
     return this.fieldIndex;
   }
diff --git a/src/test/moves/encore.test.ts b/src/test/moves/encore.test.ts
new file mode 100644
index 00000000000..7d8dc9658bf
--- /dev/null
+++ b/src/test/moves/encore.test.ts
@@ -0,0 +1,116 @@
+import { BattlerTagType } from "#enums/battler-tag-type";
+import { BattlerIndex } from "#app/battle";
+import { MoveResult } from "#app/field/pokemon";
+import { Abilities } from "#enums/abilities";
+import { Moves } from "#enums/moves";
+import { Species } from "#enums/species";
+import GameManager from "#test/utils/gameManager";
+import Phaser from "phaser";
+import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+
+describe("Moves - Encore", () => {
+  let phaserGame: Phaser.Game;
+  let game: GameManager;
+
+  beforeAll(() => {
+    phaserGame = new Phaser.Game({
+      type: Phaser.HEADLESS,
+    });
+  });
+
+  afterEach(() => {
+    game.phaseInterceptor.restoreOg();
+  });
+
+  beforeEach(() => {
+    game = new GameManager(phaserGame);
+    game.override
+      .moveset([ Moves.SPLASH, Moves.ENCORE ])
+      .ability(Abilities.BALL_FETCH)
+      .battleType("single")
+      .disableCrits()
+      .enemySpecies(Species.MAGIKARP)
+      .enemyAbility(Abilities.BALL_FETCH)
+      .enemyMoveset([ Moves.SPLASH, Moves.TACKLE ])
+      .startingLevel(100)
+      .enemyLevel(100);
+  });
+
+  it("should prevent the target from using any move except the last used move", async () => {
+    await game.classicMode.startBattle([ Species.SNORLAX ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon()!;
+
+    game.move.select(Moves.ENCORE);
+    await game.forceEnemyMove(Moves.SPLASH);
+
+    await game.toNextTurn();
+    expect(enemyPokemon.getTag(BattlerTagType.ENCORE)).toBeDefined();
+
+    game.move.select(Moves.SPLASH);
+    // The enemy AI would normally be inclined to use Tackle, but should be
+    // forced into using Splash.
+    await game.phaseInterceptor.to("BerryPhase", false);
+
+    expect(enemyPokemon.getLastXMoves().every(turnMove => turnMove.move === Moves.SPLASH)).toBeTruthy();
+  });
+
+  describe("should fail against the following moves:", () => {
+    it.each([
+      { moveId: Moves.TRANSFORM, name: "Transform", delay: false },
+      { moveId: Moves.MIMIC, name: "Mimic", delay: true },
+      { moveId: Moves.SKETCH, name: "Sketch", delay: true },
+      { moveId: Moves.ENCORE, name: "Encore", delay: false },
+      { moveId: Moves.STRUGGLE, name: "Struggle", delay: false }
+    ])("$name", async ({ moveId, delay }) => {
+      game.override.enemyMoveset(moveId);
+
+      await game.classicMode.startBattle([ Species.SNORLAX ]);
+
+      const playerPokemon = game.scene.getPlayerPokemon()!;
+      const enemyPokemon = game.scene.getEnemyPokemon()!;
+
+      if (delay) {
+        game.move.select(Moves.SPLASH);
+        await game.setTurnOrder([ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]);
+        await game.toNextTurn();
+      }
+
+      game.move.select(Moves.ENCORE);
+
+      const turnOrder = delay
+        ? [ BattlerIndex.PLAYER, BattlerIndex.ENEMY ]
+        : [ BattlerIndex.ENEMY, BattlerIndex.PLAYER ];
+      await game.setTurnOrder(turnOrder);
+
+      await game.phaseInterceptor.to("BerryPhase", false);
+      expect(playerPokemon.getLastXMoves(1)[0].result).toBe(MoveResult.FAIL);
+      expect(enemyPokemon.getTag(BattlerTagType.ENCORE)).toBeUndefined();
+    });
+  });
+
+  it("Pokemon under both Encore and Torment should alternate between Struggle and restricted move", async () => {
+    const turnOrder = [ BattlerIndex.ENEMY, BattlerIndex.PLAYER ];
+    game.override.moveset([ Moves.ENCORE, Moves.TORMENT, Moves.SPLASH ]);
+    await game.classicMode.startBattle([ Species.FEEBAS ]);
+
+    const enemyPokemon = game.scene.getEnemyPokemon();
+    game.move.select(Moves.ENCORE);
+    await game.setTurnOrder(turnOrder);
+    await game.phaseInterceptor.to("BerryPhase");
+    expect(enemyPokemon?.getTag(BattlerTagType.ENCORE)).toBeDefined();
+
+    await game.toNextTurn();
+    game.move.select(Moves.TORMENT);
+    await game.setTurnOrder(turnOrder);
+    await game.phaseInterceptor.to("BerryPhase");
+    expect(enemyPokemon?.getTag(BattlerTagType.TORMENT)).toBeDefined();
+
+    await game.toNextTurn();
+    game.move.select(Moves.SPLASH);
+    await game.setTurnOrder(turnOrder);
+    await game.phaseInterceptor.to("BerryPhase");
+    const lastMove = enemyPokemon?.getLastXMoves()[0];
+    expect(lastMove?.move).toBe(Moves.STRUGGLE);
+  });
+});
diff --git a/src/ui/command-ui-handler.ts b/src/ui/command-ui-handler.ts
index 0f5edc28675..0dacacc7b70 100644
--- a/src/ui/command-ui-handler.ts
+++ b/src/ui/command-ui-handler.ts
@@ -90,9 +90,6 @@ export default class CommandUiHandler extends UiHandler {
         switch (cursor) {
         // Fight
           case Command.FIGHT:
-            if ((this.scene.getCurrentPhase() as CommandPhase).checkFightOverride()) {
-              return true;
-            }
             ui.setMode(Mode.FIGHT, (this.scene.getCurrentPhase() as CommandPhase).getFieldIndex());
             success = true;
             break;