import { RomReader } from "../rom/reader";
import { BATTLE, RAM, SYMBOLS } from "../rom/profile";
import type { PokemonData } from "../rom/pokemon";
import type { Bag } from "../party/bag";
import {
  MONS_PER_BOX,
  currentBox,
  restorePP,
  type BoxMon,
  type PokemonStorage,
} from "../party/storage";
import {
  NICKNAME_PATTERN,
  PARTY_LENGTH,
  calcStats,
  levelForExp,
  maxPP,
  type PartyMon,
} from "../party/pokemon";
import { readString, readTextEnd, type TextContext } from "../scripts/text";
import { BattleData } from "./data";
import { C, COMMAND } from "./constants";
import { chooseTrainerMove, validateTrainerAI } from "./ai";

/** Raised for battle rules that have not been translated. The battle is
 * discarded, as if it never started. */
export class UnsupportedBattle extends Error {}

/** A battle_struct: the Pokémon on the field, with stage-modified stats. */
export interface BattleMon {
  species: number;
  item: number;
  moves: number[];
  dvs: number;
  pp: number[];
  happiness: number;
  level: number;
  status: number;
  hp: number;
  maxHp: number;
  /** Attack, Defense, Speed, Sp. Atk, Sp. Def after stages and status. */
  stats: number[];
  types: [number, number];
  nickname: string;
}
interface MoveStruct {
  anim: number;
  effect: number;
  power: number;
  type: number;
  accuracy: number;
  pp: number;
  chance: number;
}

/** One side's battle variables (wPlayer* or wEnemy*). */
class Side {
  mon!: BattleMon;
  /** Unmodified stats (wPlayerStats), used for stages and criticals. */
  stats = [0, 0, 0, 0, 0];
  levels = [7, 7, 7, 7, 7, 7, 7];
  /** SubStatus1-5; index 0 is unused so indices match the names. */
  sub = [0, 0, 0, 0, 0, 0];
  move: MoveStruct = { anim: 0, effect: 0, power: 0, type: 0, accuracy: 0, pp: 0, chance: 0 };
  curMove = 0;
  moveNum = 0;
  confuseCount = 0;
  toxicCount = 0;
  disableCount = 0;
  disabledMove = 0;
  encoreCount = 0;
  rolloutCount = 0;
  furyCutterCount = 0;
  protectCount = 0;
  rageCounter = 0;
  /** wWrapCount: turns this side stays trapped, by trappingMove. */
  wrapCount = 0;
  trappingMove = 0;
  damageTaken = 0;
  screens = 0;
  lightScreenCount = 0;
  reflectCount = 0;
  turnsTaken = 0;
  charging = 0;
  lastMove = 0;
  lastCounterMove = 0;
  minimized = 0;
  justGotFrozen = 0;
  perishCount = 0;
  safeguardCount = 0;
  /** wFutureSightCount and the damage Future Sight stored. */
  futureSightCount = 0;
  futureSightDamage = 0;
  has(byte: number, bit: number) {
    return Boolean(this.sub[byte] & (1 << bit));
  }
  set(byte: number, bit: number) {
    this.sub[byte] |= 1 << bit;
  }
  reset(byte: number, bit: number) {
    this.sub[byte] &= ~(1 << bit);
  }
}

export type BattleEffect =
  /** A battle message; prompt texts wait for a button, others continue. */
  | { kind: "text"; text: string; prompt: boolean }
  /** HP, status or level changed; renderers re-read the battle state. */
  | { kind: "hud" }
  /** The battle menu: answered with an action. */
  | { kind: "action" }
  | { kind: "yesno"; text: string }
  /** Choose a move to forget (0-3); 4 cancels, like B on the list. */
  | { kind: "forget"; moves: number[]; learning: number }
  /** The level-up stat box (PrintTempMonStats), acknowledged with a button. */
  | { kind: "stats"; labels: string[]; values: number[] }
  /** The naming screen for a caught Pokémon: answered with the name, or ""
   * to keep `current`. */
  | { kind: "name"; title: string; current: string; max: number }
  /** The battle party menu: answered with a party index, or -1 to go back
   * when `cancel` allows it. With `menu`, the choice goes through the
   * SWITCH/STATS/CANCEL submenu (BattleMonMenu) first. */
  | { kind: "party"; text: string; menu: boolean; cancel: boolean }
  /** MoveSelectionScreen for an item: a move slot (0-3), or -1 to go back. */
  | { kind: "move"; text: string; moves: number[]; pp: number[] };
/** An item from a pack slot (wCurItem and wCurItemQuantity). */
type ItemUse = { item: number; slot: number };
export type BattleAction =
  | { action: "fight"; move: number }
  | { action: "run" }
  /** PKMN: open the party menu to switch. */
  | { action: "pkmn" }
  /** PACK: use the item in this slot of its pocket (only Balls so far). */
  | { action: "item"; item: number; slot: number };
export type BattleInput = number | string | BattleAction | undefined;
/** wBattleResult, the prize money and wEvolvableFlags (a bit per party
 * index that levelled up). */
export type BattleOutcome = {
  result: number;
  prizeMoney?: number;
  /** The part of the prize sent to Mom's savings. */
  momMoney?: number;
  /** wPayDayMoney as CheckPayDay adds it to the wallet after a win. */
  payDayMoney?: number;
  evolvable?: number;
};

export interface BattleTrainer {
  name: string;
  className: string;
  /** wOTPartyMons: level, status and HP follow the Pokémon out only where
   * the original updates them (UpdateEnemyMonInParty: status changes and
   * heals, a faint or a withdrawal); damage alone leaves them stale. */
  party: PartyMon[];
  aiFlags: number;
  /** TrainerClassAttributes' AI item/switch word (SWITCH_* in the low byte). */
  switchFlags: number;
  reward: number;
  winText?: number;
  lossText?: number;
}

type Gen<T = void> = Generator<BattleEffect, T, BattleInput>;

export interface BattleOptions {
  data: PokemonData;
  party: PartyMon[];
  pokedex: { seen: Set<number>; caught: Set<number> };
  playerId: number;
  playerName: string;
  /** wTimeOfDay: morning 0, day 1, night 2. */
  timeOfDay: number;
  random: () => number;
  wild?: { species: number; level: number };
  trainer?: BattleTrainer;
  canLose?: boolean;
  text: () => TextContext;
  /** The player's pack, needed to throw Poké Balls. */
  bag?: Bag;
  /** Bill's PC: a catch with a full party goes to the current box. */
  storage?: PokemonStorage;
  /** ENGINE_POKEDEX: a first catch shows the new-data message. */
  hasPokedex?: boolean;
  /** SetCaughtData's word for a Pokémon caught at this level. */
  caughtData?: (level: number) => number;
  /** BATTLETYPE_TUTORIAL: the Dude's catching demonstration. */
  tutorial?: boolean;
  /** BATTLETYPE_TREE: a wild Pokémon that fell from a Headbutt tree. */
  tree?: boolean;
  /** BATTLETYPE_FISH: a wild Pokémon hooked on a fishing rod. */
  fish?: boolean;
  /** GetWorldMapLocation for the current map (LevelUpHappinessMod). */
  landmark?: number;
  /** wMapGroup:wMapNumber, which LoadEnemyMon compares with the Lake of
   * Rage for wild Magikarp. */
  mapId?: string;
  /** wPartyMenuCursor as the last party menu outside battle left it. */
  partyMenuCursor?: number;
  /** wMomSavingMoney's MOM_SAVING_MONEY_MASK bits and wMomsMoney: how much
   * of a trainer's prize goes to Mom. */
  mom?: { saving: number; money: number };
  /** wOptions' BATTLE_SHIFT clear: the SHIFT battle style (the default). */
  shift?: boolean;
  /** wOptions' BATTLE_SCENE clear: battle animations on (the default).
   * Some texts only show with them off (_CheckBattleScene). */
  battleScene?: boolean;
}

/** BATTLERESULT_BOX_FULL: a catch filled the current box. */
const BATTLERESULT_BOX_FULL = 0x80;
const SUB1 = 1,
  SUB2 = 2,
  SUB3 = 3,
  SUB4 = 4,
  SUB5 = 5;
/** "n percent" in the original: n * $ff / 100, rounded down. */
const percent = (n: number) => Math.floor((n * 0xff) / 100);
/** TrainerClassAttributes AI_ITEM_SWITCH bits (constants/trainer_data_constants.asm). */
const SWITCH_OFTEN = 1 << 0,
  SWITCH_RARELY = 1 << 1,
  SWITCH_SOMETIMES = 1 << 2;
/** SwitchOften/SwitchRarely/SwitchSometimes: for each wEnemySwitchMonParam
 * tier ($10, $20, $30), a Random threshold and whether a roll below it
 * switches (true) or keeps the Pokémon in (false). */
const SWITCH_CHANCES: readonly (readonly [number, boolean])[][] = [
  [[percent(50) + 1, true], [percent(79) - 1, true], [percent(4), false]],
  [[percent(8), true], [percent(12), true], [percent(79) - 1, false]],
  [[percent(20) - 1, true], [percent(50) + 1, true], [percent(20) - 1, false]],
];

export interface TypeMatchup {
  attacker: number;
  defender: number;
  multiplier: number;
}

/** BattleCommand_DamageCalc's arithmetic. `boost` is a type-boosting held
 * item's percentage; `current` is the damage already in wCurDamage.
 * Returns undefined when the original leaves wCurDamage unchanged. */
/** MAP_LAKE_OF_RAGE (constants/map_constants.asm). */
const LAKE_OF_RAGE = { group: 9, number: 6 };

/** CalcMagikarpLength (engine/events/magikarp.asm): a length in feet and
 * inches from the DVs and the trainer ID. The index is rrc(rrc(DV byte))
 * xor rrc(ID byte), per byte. Its .BCLessThanDE compares only the high
 * bytes, so MagikarpLengths' thresholds act on the high byte alone and
 * the difference below them wraps around 16 bits, as in the original. */
export function magikarpLength(
  r: RomReader,
  dvs: number,
  playerId: number,
): { feet: number; inches: number } {
  const rrc = (value: number) => ((value >> 1) | (value << 7)) & 0xff;
  const b = rrc(rrc(dvs >> 8)) ^ rrc((playerId >> 8) & 0xff),
    c = rrc(rrc(dvs & 0xff)) ^ rrc(playerId & 0xff),
    bc = (b << 8) | c;
  let mm: number | undefined;
  let p = BATTLE.MagikarpLengths;
  if (bc < 10) mm = bc + 190;
  else
    for (let z = 2; z < 16; z++, p += 3)
      if (b < r.byte(p + 1)) {
        const quotient = Math.floor(((bc - r.word(p)) & 0xffff) / r.byte(p + 2));
        mm = ((quotient & 0xff) + 100 * z) & 0xffff;
        break;
      }
  // Past the table: bc minus its last threshold, plus 1600.
  mm ??= (((bc - r.word(p - 3)) & 0xffff) + 1600) & 0xffff;
  // Millimetres × 10 / 254 in a byte, then feet and inches.
  const total = Math.floor(((mm * 10) & 0xffff) / 254) & 0xff;
  return { feet: Math.floor(total / 12), inches: total % 12 };
}

export function calculateDamage(input: {
  power: number;
  level: number;
  attack: number;
  defense: number;
  effect: number;
  critical: boolean;
  boost?: number;
  current: number;
}): number | undefined {
  let { defense } = input;
  const { power, effect } = input;
  // Selfdestruct and Explosion halve defense.
  if (effect === C.EFFECT_SELFDESTRUCT) defense = defense >> 1 || 1;
  if (effect !== C.EFFECT_MULTI_HIT && effect !== C.EFFECT_CONVERSION && !power) return undefined;
  if (!defense) defense = 1;
  let value = Math.floor(((input.level * 2) & 0x1ff) / 5) + 2;
  value = Math.floor((value * power * input.attack) / defense);
  value = Math.floor(value / 50);
  if (input.boost !== undefined) value = Math.floor((value * (input.boost + 100)) / 100);
  if (input.critical) {
    // Only the low 16 bits are doubled, capped at $ffff.
    const high = value - (value & 0xffff);
    const doubled = (value & 0xffff) * 2;
    value = high + (doubled > 0xffff ? 0xffff : doubled);
  }
  // Add to wCurDamage, capped at 997, then add 2. The original first adds
  // the high byte of wCurDamage to the result's low byte.
  const current = input.current;
  let low = (value & 0xff) + (current >> 8);
  let high = (value >> 8) & 0xff;
  if (low > 0xff) {
    low &= 0xff;
    high = (high + 1) & 0xff;
    if (!high) return 999;
  }
  if ((value >> 16) & 0xff) return 999; // only hQuotient + 1 is checked
  const result = (high << 8) | low;
  if (result >= 998) return 999;
  const total = result + current;
  if (total > 0xffff || total >= 998) return 999;
  return total + 2;
}

/** BattleCommand_Stab and BattleCheckTypeMatchup. */
export function applyTypeMatchups(
  matchups: readonly TypeMatchup[],
  input: {
    damage: number;
    modifier: number;
    moveType: number;
    userTypes: readonly number[];
    targetTypes: readonly number[];
    identified: boolean;
  },
): { damage: number; modifier: number; matchup: number; missed: boolean } {
  let { damage, modifier } = input;
  let missed = false;
  const type = input.moveType;
  if (type === input.userTypes[0] || type === input.userTypes[1]) {
    damage = (damage + (damage >> 1)) & 0xffff;
    modifier |= C.STAB_DAMAGE;
  }
  const hits = (row: TypeMatchup) =>
    row.attacker === type &&
    (row.defender === input.targetTypes[0] || row.defender === input.targetTypes[1]);
  for (const row of matchups) {
    // Rows after the -2 marker (Ghost immunities) stop under Foresight.
    if (row.attacker === 0xfe) {
      if (input.identified) break;
      continue;
    }
    if (!hits(row)) continue;
    if (!row.multiplier) missed = true;
    modifier = (modifier & C.STAB_DAMAGE) + row.multiplier;
    const product = damage * row.multiplier;
    damage = product ? Math.floor(product / 10) & 0xffff || 1 : 0;
  }
  let matchup: number = C.EFFECTIVE;
  for (const row of matchups) {
    if (row.attacker === 0xfe) {
      if (input.identified) break;
      continue;
    }
    if (hits(row)) matchup = Math.floor((row.multiplier * matchup) / 10) & 0xff;
  }
  return { damage, modifier: (modifier & C.STAB_DAMAGE) | matchup, matchup, missed };
}

/** A native translation of Crystal's battle engine.
 * The move effect scripts are the ROM's own; each battle command is a
 * native translation. Unsupported AI, switching, contest and item paths are refused. */
/** PokeBallEffect's wFinalCatchRate for Poké, Great and Ultra Balls, in
 * the original 8- and 16-bit registers. Returns undefined when the
 * formula would divide by zero (e.g. maximum HP of 342 or 683). */
export function catchRate(input: {
  rate: number;
  ball: number;
  hp: number;
  maxHp: number;
  status: number;
  /** The player's battle Pokémon's held item effect. */
  held: { effect: number; parameter: number };
}): number | undefined {
  let rate = input.rate;
  // BallMultiplierFunctionTable
  if (input.ball === C.ULTRA_BALL) rate = Math.min(0xff, rate << 1);
  else if (input.ball === C.GREAT_BALL) rate = Math.min(0xff, rate + (rate >> 1));
  // A maximum HP above 341 overflows the HP term (a kept bug).
  let hp = (input.hp << 1) & 0xffff,
    max = (input.maxHp * 3) & 0xffff;
  if (max >> 8) {
    max >>= 2;
    hp >>= 2;
    if (!(hp & 0xff)) hp |= 1;
  }
  const divisor = max & 0xff,
    remaining = hp & 0xff;
  if (!divisor) return undefined;
  let chance = Math.floor((rate * ((divisor - remaining) & 0xff)) / divisor) & 0xff;
  if (!chance) chance = 1;
  // Only sleep and freeze add to the chance; BRN/PSN/PAR do not (a kept bug).
  if (input.status & ((1 << C.FRZ) | C.SLP_MASK)) chance = Math.min(0xff, chance + 10);
  // HELD_CATCH_CHANCE adds its parameter, but no item has that effect.
  if (input.held.effect === C.HELD_CATCH_CHANCE)
    chance = Math.min(0xff, chance + input.held.parameter);
  return chance;
}

/** HP × 25 / (max HP / 4) as a byte, as SendOutMonText and WithdrawMonText
 * compute it. Undefined when max HP / 4 is zero: the original divides by
 * zero and freezes. */
function cheerPercent(hp: number, maxHp: number): number | undefined {
  const divisor = (maxHp >> 2) & 0xff;
  return divisor ? Math.floor((hp * 25) / divisor) & 0xff : undefined;
}
/** SendOutMonText's cheer from the enemy's remaining HP ("Go!" when it
 * has fainted). */
export function sendOutText(hp: number, maxHp: number) {
  if (!hp) return "GoMonText" as const;
  const percent = cheerPercent(hp, maxHp);
  if (percent === undefined) return undefined;
  return percent >= 70
    ? ("GoMonText" as const)
    : percent >= 40
      ? ("DoItMonText" as const)
      : percent >= 10
        ? ("GoForItMonText" as const)
        : ("YourFoesWeakGetmMonText" as const);
}
/** WithdrawMonText's choice from the HP lost since the send-out, in 16
 * bits. The multiplicand's high byte is left over from earlier arithmetic
 * in the original; it is taken as zero here. */
export function withdrawText(hpAtSwitch: number, hp: number, maxHp: number) {
  const percent = cheerPercent((hpAtSwitch - hp) & 0xffff, maxHp);
  if (percent === undefined) return undefined;
  return !percent
    ? ("ThatsEnoughComeBackText" as const)
    : percent < 30
      ? ("ComeBackText" as const)
      : percent < 70
        ? ("OKComeBackText" as const)
        : ("GoodComeBackText" as const);
}
/** RestoreHealth: a 16-bit sum that overflows or passes the maximum is
 * the maximum. */
export function restoreHealth(hp: number, maxHp: number, amount: number) {
  const sum = hp + amount;
  return sum > 0xffff || sum > maxHp ? maxHp : sum;
}
/** RestorePP's new PP byte (PP Ups kept), or undefined when the move's PP
 * is already at `max` (GetMaxPPOfMove). MAX items fill the move; others add
 * 10, or 5 for the MysteryBerry. */
export function restoredPP(pp: number, max: number, item: number) {
  const current = pp & C.PP_MASK;
  if (current >= max) return undefined;
  const full = item === C.MAX_ELIXER || item === C.MAX_ETHER;
  return (pp & ~C.PP_MASK) | (full ? max : Math.min(max, current + (item === C.MYSTERYBERRY ? 5 : 10)));
}
/** ChangeHappiness' arithmetic with a HappinessChanges byte: bytes from
 * $64 up (`cp $64`) are decreases that stop at zero. */
export function changedHappiness(happiness: number, delta: number) {
  const sum = happiness + delta;
  return delta >= 0x64 ? (sum > 0xff ? sum & 0xff : 0) : Math.min(0xff, sum);
}

export class Battle {
  readonly data: BattleData;
  readonly player = new Side();
  readonly enemy = new Side();
  /** hBattleTurn: 0 for the player's turn, 1 for the enemy's. */
  turn = 0;
  curBattleMon = 0;
  battleMode: number = C.WILD_BATTLE;
  battleType: number = C.BATTLETYPE_NORMAL;
  battleResult: number = C.WIN;
  battleEnded = false;
  battlePlayerAction = 0;
  enemyGoesFirst = 0;
  numFleeAttempts = 0;
  /** wBattleParticipantsNotFainted, which shares the experience. */
  participants = 0;
  /** wEvolvableFlags: party members that levelled up, which
   * EvolveAfterBattle checks after a win. */
  private evolvable = 0;
  /** wBattleParticipantsIncludingFainted, which revives consult. */
  private participantsAll = 0;
  /** wEnemyMonBaseStats: five base stats, catch rate and base exp. */
  enemyBase = { stats: [0, 0, 0, 0, 0], catchRate: 0, exp: 0 };
  weather: number = C.WEATHER_NONE;
  /** wCurOTMon: the trainer's party index in battle. */
  curOTMon = 0;
  /** wWildMon after a ball: the caught species, or 0. */
  wildMon = 0;
  /** wFinalCatchRate from the last ball that ran the catch formula. */
  private finalCatchRate = 0;
  /** wWildMonMoves/wWildMonPP: the wild Pokémon's moves and PP when it
   * appeared, which a caught Pokémon keeps. */
  private wildMoves: number[] = [];
  private wildPP: number[] = [];
  /** wEnemySwitchMonIndex: the AI's chosen party index plus one, or 0. */
  private enemySwitchMonIndex = 0;
  private battleHasJustStarted = 0;
  /** wCurPartyMon: the party index a menu picked. */
  private curPartyMon = 0;
  /** wPartyMenuCursor: the 1-based cursor of the last party menu, from
   * the start menu's until the battle's own party menu sets it. */
  private partyMenuCursor: number;
  /** wLastPlayerMon: the Pokémon that was out before the last switch. */
  lastPlayerMon = 0;
  /** wEnemyIsSwitching: ParseEnemyAction keeps the current move. */
  private enemyIsSwitching = 0;
  /** wPlayerIsSwitching, which Pursuit doubles against. */
  private playerIsSwitching = 0;
  /** wEnemyHPAtTimeOfPlayerSwitch, which WithdrawMonText compares with. */
  private enemyHPAtSwitch = 0;
  /** wPlayerUsedMoves: the player's distinct moves since sending out. */
  private playerUsedMoves = [0, 0, 0, 0];
  private curDamage = 0;
  private criticalHit = 0;
  private attackMissed = 0;
  private effectFailed = 0;
  private typeModifier: number = C.EFFECTIVE;
  private alreadyDisobeyed = 0;
  private alreadyFailed = 0;
  /** wTypeMatchup from the last BattleCheckTypeMatchup. */
  private matchup: number = C.EFFECTIVE;
  /** wBattleAnimParam, which Triple Kick also reads as its kick count. */
  private animParam = 0;
  /** wPayDayMoney: Pay Day's coins, paid out after a win. */
  private payDayMoney = 0;
  /** wAmuletCoin: a Pokémon sent out held an Amulet Coin. */
  private amuletCoin = false;
  /** wCurBeatUpPartyMon and wBeatUpHitAtLeastOnce. */
  private beatUpMon = 0;
  private beatUpHit = 0;
  private turnEnded = 0;
  private loweredStat = 0;
  private failedMessage = 0;
  private script: number[] = [];
  private scriptIndex = 0;
  private strings: Record<number, string> = {};
  private numbers: Record<number, number> = {};
  private matchups;
  private moveGrammarCache = new Map<number, number>();

  constructor(private options: BattleOptions) {
    this.data = new BattleData(options.data.reader);
    this.matchups = this.data.typeMatchups();
    this.partyMenuCursor = options.partyMenuCursor ?? 0;
    if (options.trainer) this.battleMode = C.TRAINER_BATTLE;
    if (options.tutorial) this.battleType = C.BATTLETYPE_TUTORIAL;
    else if (options.tree) this.battleType = C.BATTLETYPE_TREE;
    else if (options.fish) this.battleType = C.BATTLETYPE_FISH;
  }
  private get reader(): RomReader {
    return this.options.data.reader;
  }
  private random() {
    return this.options.random() & 0xff;
  }
  private get user() {
    return this.turn === 0 ? this.player : this.enemy;
  }
  private get target() {
    return this.turn === 0 ? this.enemy : this.player;
  }
  get partyMon(): PartyMon {
    return this.options.party[this.curBattleMon];
  }
  /** ParsePlayerAction skips MoveSelectionScreen: FIGHT goes on with the
   * current move, as while biding. */
  get fightKeepsMove() {
    return this.player.has(SUB3, C.SUBSTATUS_BIDE) || this.player.has(SUB5, C.SUBSTATUS_ENCORED);
  }

  // ------------------------------------------------------------- messages

  private context(): TextContext {
    const base = this.options.text();
    return {
      ...base,
      // CatchTutorial copies "DUDE" over wPlayerName for the battle.
      player:
        this.battleType === C.BATTLETYPE_TUTORIAL
          ? readString(this.reader, BATTLE["CatchTutorial.Dude"], base)
          : base.player,
      trainer: this.options.trainer
        ? `${this.options.trainer.className} ${this.options.trainer.name}`.trim()
        : base.trainer,
      strings: {
        ...base.strings,
        [RAM.battleMonNickname]: this.player.mon?.nickname ?? "",
        [RAM.enemyMonNickname]: this.enemy.mon?.nickname ?? "",
        ...this.strings,
      },
      numbers: this.numbers,
      battle: {
        turn: this.turn,
        player: this.player.mon?.nickname ?? "",
        enemy: this.enemy.mon?.nickname ?? "",
        enemyPrefix: readString(this.reader, BATTLE.EnemyText, base),
      },
      asm: (offset) => this.textAsm(offset),
    };
  }
  /** StdBattleTextbox / BattleTextbox with a ROM text. `button` waits for
   * a button afterwards even without a prompt (WaitPressAorB_BlinkCursor). */
  private *say(address: number, button = false): Gen {
    const { text, prompt } = readTextEnd(this.reader, address, this.context());
    // The tutorial's auto input presses A at every prompt.
    const waits = (prompt || button) && this.battleType !== C.BATTLETYPE_TUTORIAL;
    for (const page of text.split("\n\n").filter(Boolean))
      yield { kind: "text", text: page, prompt: waits };
  }
  /** text_asm routines that battle texts run between fragments. */
  private textAsm(offset: number): number {
    const at = (label: string, fragment = 4) => BATTLE[label as keyof typeof BATTLE] + fragment;
    switch (offset) {
      case at("UsedMoveText"): {
        // Updates the last move, then picks the grammar for "used".
        if (this.turn === 0) this.updateUsedMoves(this.player.move.anim);
        const user = this.user;
        if (!user.charging) {
          user.lastCounterMove = user.move.anim;
          user.lastMove = user.move.anim;
        }
        const grammar = this.grammar(user.move.anim);
        return this.alreadyDisobeyed || grammar < 3 ? BATTLE.UsedMove2Text : BATTLE.UsedMove1Text;
      }
      case at("UsedMove1Text"):
      case at("UsedMove2Text"):
        return this.alreadyDisobeyed ? BATTLE["UsedMoveText_CheckObedience.UsedInsteadText"] : BATTLE.MoveNameText;
      case at("UsedMoveText_CheckObedience.UsedInsteadText"):
        return BATTLE.MoveNameText;
      case at("MoveNameText"): {
        const ends = BATTLE["MoveNameText.endusedmovetexts"];
        const grammar = this.grammar(this.user.move.anim);
        return this.reader.near(ends + grammar * 2, this.reader.bank(ends));
      }
      case at("BattleCommand_StatUpMessage.stat"):
        return this.loweredStat & 0xf0
          ? BATTLE["BattleCommand_StatUpMessage.BattleStatWentWayUpText"]
          : BATTLE["BattleCommand_StatUpMessage.BattleStatWentUpText"];
      case at("BattleCommand_StatDownMessage.stat"):
        return this.loweredStat & 0xf0
          ? BATTLE["BattleCommand_StatDownMessage.BattleStatSharplyFellText"]
          : BATTLE["BattleCommand_StatDownMessage.BattleStatFellText"];
      case at("Text_MonGainedExpPoint"):
        return this.numbers[RAM.stringBuffer2 + 2] ? BATTLE.BoostedExpPointsText : BATTLE.ExpPointsText;
      case at("GoMonText"):
      case at("DoItMonText"):
      case at("GoForItMonText"):
      case at("YourFoesWeakGetmMonText"):
        return BATTLE.BattleMonNicknameText;
      case at("WithdrawMonText.WithdrawMonText"): {
        const text = withdrawText(this.enemyHPAtSwitch, this.enemy.mon.hp, this.enemy.mon.maxHp);
        if (!text) throw new UnsupportedBattle("A maximum HP below 4 freezes the original here.");
        return BATTLE[text];
      }
      case at("Text_1_2_and_Poof"):
        return BATTLE["Text_1_2_and_Poof.MoveForgotText"];
      case at("BattleCommand_Charge.UsedText"): {
        const text = {
          [C.RAZOR_WIND]: "BattleCommand_Charge.BattleMadeWhirlwindText",
          [C.SOLARBEAM]: "BattleCommand_Charge.BattleTookSunlightText",
          [C.SKULL_BASH]: "BattleCommand_Charge.BattleLoweredHeadText",
          [C.SKY_ATTACK]: "BattleCommand_Charge.BattleGlowingText",
          [C.FLY]: "BattleCommand_Charge.BattleFlewText",
        }[this.user.move.anim];
        // Any other move falls through to the Dig text.
        return BATTLE[(text ?? "BattleCommand_Charge.BattleDugText") as keyof typeof BATTLE];
      }
      case at("Text_GotchaMonWasCaught"):
        // Capture music (not ported), then WaitButtonText.
        return BATTLE.WaitButtonText;
      default:
        throw new UnsupportedBattle(`Battle text routine at 0x${offset.toString(16)} is not ported.`);
    }
  }
  private grammar(move: number) {
    let value = this.moveGrammarCache.get(move);
    if (value === undefined) {
      value = this.data.moveGrammar(move);
      this.moveGrammarCache.set(move, value);
    }
    return value;
  }
  private hud(): BattleEffect {
    return { kind: "hud" };
  }

  // --------------------------------------------------------------- setup

  /** LoadEnemyMon: the trainer's wCurOTMon, or a wild Pokémon from a grass
   * or water table. */
  private loadEnemyMon() {
    const trainer = this.options.trainer;
    if (trainer) {
      const mon = trainer.party[this.curOTMon],
        base = this.options.data.baseData(mon.species);
      this.enemy.mon = {
        species: mon.species,
        item: mon.item,
        moves: [...mon.moves],
        dvs: mon.dvs,
        pp: [...mon.pp],
        happiness: mon.happiness,
        level: mon.level,
        status: mon.status,
        hp: mon.hp,
        maxHp: mon.stats[0],
        stats: mon.stats.slice(1),
        types: [...base.types],
        nickname: mon.nickname,
      };
      this.enemyBase = {
        stats: base.stats.slice(0, 5),
        catchRate: base.catchRate,
        exp: base.baseExp,
      };
      this.enemy.stats = [...this.enemy.mon.stats];
      this.applyStatusEffects(this.enemy);
      this.options.pokedex.seen.add(mon.species);
      return;
    }
    if (!this.options.wild) throw new UnsupportedBattle("Missing encounter.");
    const { species, level } = this.options.wild;
    if (species === C.UNOWN)
      throw new UnsupportedBattle("Unown encounters are not ported yet.");
    const data = this.options.data,
      base = data.baseData(species);
    // 25% chance of an item: 23% the first, 2% the second.
    let item = 0;
    if (this.random() >= percent(75) + 1) item = this.random() < percent(8) ? base.items[1] : base.items[0];
    let dvs: number;
    do dvs = (this.random() << 8) | this.random();
    while (species === C.MAGIKARP && this.rerollMagikarp(dvs));
    const stats = calcStats(data, species, dvs, level);
    const moves: number[] = [];
    for (const learned of data.learnset(species)) {
      if (learned.level > level) break;
      if (moves.includes(learned.move)) continue;
      if (moves.length === 4) moves.shift();
      moves.push(learned.move);
    }
    while (moves.length < 4) moves.push(0);
    this.enemy.mon = {
      species,
      item,
      moves,
      dvs,
      pp: moves.map((move) => (move ? data.move(move).pp : 0)),
      happiness: C.BASE_HAPPINESS,
      level,
      // .TreeMon: some Pokémon fall from trees asleep.
      status: this.sleepingTreeMon(species) ? C.TREEMON_SLEEP_TURNS : 0,
      hp: stats[0],
      maxHp: stats[0],
      stats: stats.slice(1),
      types: [base.types[0], base.types[1]],
      nickname: data.speciesName(species),
    };
    this.enemyBase = {
      stats: base.stats.slice(0, 5),
      catchRate: base.catchRate,
      exp: base.baseExp,
    };
    this.options.pokedex.seen.add(species);
    this.enemy.stats = [...this.enemy.mon.stats];
    this.wildMoves = [...moves];
    this.wildPP = [...this.enemy.mon.pp];
  }
  /** LoadEnemyMon's .Magikarp filters, true when the DVs are drawn again.
   * Their limits are in millimetres but CalcMagikarpLength gives feet and
   * inches: the two size checks need 6 feet, which no Magikarp reaches
   * (they only draw from Random), and the floor of 1024 mm compares
   * feet with 4. The Lake of Rage test matches its map group or its map
   * number on their own, and skips the floor there. */
  private rerollMagikarp(dvs: number): boolean {
    const { feet, inches } = magikarpLength(
      this.reader,
      dvs,
      this.options.playerId,
    );
    if (feet === 1536 >> 8 && this.random() >= percent(5)) {
      if (inches >= (1616 & 0xff)) return true;
      if (this.random() >= percent(20) - 1 && inches >= (1600 & 0xff))
        return true;
    }
    const [group, number] = (this.options.mapId ?? "0:0").split(":").map(Number);
    if (group === LAKE_OF_RAGE.group || number === LAKE_OF_RAGE.number)
      return false;
    if (this.random() < percent(39) + 1) return false;
    return feet < 1024 >> 8;
  }
  /** CheckSleepingTreeMon: in a tree battle, the time of day's
   * AsleepTreeMons list names the species that sleep. */
  private sleepingTreeMon(species: number) {
    if (this.battleType !== C.BATTLETYPE_TREE) return false;
    const time = this.options.timeOfDay;
    let p =
      time < C.DAY_F
        ? BATTLE.AsleepTreeMonsMorn
        : time === C.DAY_F
          ? BATTLE.AsleepTreeMonsDay
          : BATTLE.AsleepTreeMonsNite;
    for (const r = this.reader; r.byte(p) !== 0xff; p++)
      if (r.byte(p) === species) return true;
    return false;
  }
  /** InitBattleMon from the party, then status penalties. */
  private initBattleMon() {
    const mon = this.partyMon,
      base = this.options.data.baseData(mon.species);
    this.player.mon = {
      species: mon.species,
      item: mon.item,
      moves: [...mon.moves],
      dvs: mon.dvs,
      pp: [...mon.pp],
      happiness: mon.happiness,
      level: mon.level,
      status: mon.status,
      hp: mon.hp,
      maxHp: mon.stats[0],
      stats: mon.stats.slice(1),
      types: [base.types[0], base.types[1]],
      nickname: mon.nickname,
    };
    this.player.stats = mon.stats.slice(1);
    this.applyStatusEffects(this.player);
    // No badges exist yet, so BadgeStatBoosts changes nothing.
  }
  /** ApplyPrzEffectOnSpeed and ApplyBrnEffectOnAttack for one side. */
  private applyStatusEffects(side: Side) {
    const mon = side.mon;
    if (mon.status & (1 << C.PAR)) mon.stats[C.SPEED] = Math.max(1, mon.stats[C.SPEED] >> 2);
    if (mon.status & (1 << C.BRN)) mon.stats[C.ATTACK] = Math.max(1, mon.stats[C.ATTACK] >> 1);
  }
  /** NewBattleMonStatus (with ResetPlayerStatLevels) or NewEnemyMonStatus
   * at the start of a battle. */
  private newStatus(side: Side) {
    if (side === this.player) {
      this.playerUsedMoves = [0, 0, 0, 0];
      this.enemy.lastCounterMove = 0;
      this.enemy.wrapCount = 0;
      this.enemy.reset(SUB5, C.SUBSTATUS_CANT_RUN);
    }
    side.sub = [0, 0, 0, 0, 0, 0];
    side.levels = [7, 7, 7, 7, 7, 7, 7];
    side.lastMove = 0;
    side.lastCounterMove = 0;
    side.disableCount = 0;
    side.disabledMove = 0;
    side.furyCutterCount = 0;
    side.protectCount = 0;
    side.rageCounter = 0;
    side.minimized = 0;
    side.wrapCount = 0;
    side.turnsTaken = 0;
  }
  /** UpdateBattleMonInParty: level, status and HP go back to the party. */
  private updateBattleMonInParty() {
    const mon = this.partyMon;
    mon.level = this.player.mon.level;
    mon.status = this.player.mon.status;
    mon.hp = this.player.mon.hp;
  }

  // ---------------------------------------------------------------- flow

  /** StartBattle through ExitBattle. */
  *run(): Gen<BattleOutcome> {
    const outcome = yield* this.doBattle();
    // ExitBattle: CheckPayDay after a win.
    if (outcome.result & 0x0f) return outcome;
    const payDayMoney = yield* this.checkPayDay();
    return payDayMoney ? { ...outcome, payDayMoney } : outcome;
  }
  /** CheckPayDay: the coins, doubled by an Amulet Coin, for the wallet. */
  private *checkPayDay(): Gen<number> {
    let money = this.payDayMoney;
    if (!money) return 0;
    if (this.amuletCoin) money = Math.min(0xffffff, money * 2);
    this.numbers[RAM.payDayMoney] = money;
    yield* this.say(BATTLE.BattleText_PlayerPickedUpPayDayMoney);
    return money;
  }
  /** CheckAmuletCoin, at every SendOutPlayerMon. */
  private checkAmuletCoin() {
    if (this.data.heldEffect(this.player.mon.item).effect === C.HELD_AMULET_COIN)
      this.amuletCoin = true;
  }

  private *doBattle(): Gen<BattleOutcome> {
    const trainer = this.options.trainer;
    if (trainer) {
      validateTrainerAI(trainer.aiFlags, trainer.party.flatMap((mon) =>
        mon.moves.filter(Boolean).map((move) => this.options.data.move(move).effect),
      ));
      if (trainer.party.length < 1 || trainer.party.length > 6)
        throw new UnsupportedBattle("Invalid trainer party.");
      if (
        !Number.isInteger(trainer.reward) ||
        trainer.reward < 0 ||
        trainer.reward > C.MAX_MONEY
      )
        throw new UnsupportedBattle("Invalid trainer reward.");
    }
    if (this.options.tutorial && (trainer || !this.options.wild))
      throw new UnsupportedBattle("The catching tutorial needs a wild Pokémon.");
    this.loadEnemyMon();
    this.curBattleMon = this.options.party.findIndex((mon) => mon.hp > 0);
    if (this.curBattleMon < 0)
      throw new UnsupportedBattle("No Pokémon can fight.");
    if (this.battleType === C.BATTLETYPE_TUTORIAL) {
      // DoBattle goes straight to BattleMenu without sending anyone out.
      // The auto input picks PACK, then TutorialPack's Balls pocket, and
      // BattleMenu_Pack uses the Dude's own POKé BALL.
      yield* this.say(BATTLE.WildPokemonAppearedText);
      yield this.hud();
      yield* this.pokeBallEffect(C.POKE_BALL, -1);
      if (!this.wildMon) throw new UnsupportedBattle("The tutorial ball did not catch.");
      this.battleResult &= 0xc0; // BattleMenu_Pack.UseItem's .run: WIN
      return { result: this.battleResult };
    }
    if (trainer) {
      yield* this.say(BATTLE.WantsToBattleText);
      yield* this.say(BATTLE.BattleText_EnemySentOut);
    } else
      yield* this.say(
        this.battleType === C.BATTLETYPE_FISH
          ? BATTLE.HookedPokemonAttackedText
          : this.battleType === C.BATTLETYPE_TREE
            ? BATTLE.PokemonFellFromTreeText
            : BATTLE.WildPokemonAppearedText,
      );
    this.resetBattleParticipants();
    this.initBattleMon();
    this.checkAmuletCoin();
    this.newStatus(this.player);
    this.newStatus(this.enemy);
    yield* this.sendOutMonText();
    yield this.hud();
    this.turn = 0; // SetPlayerTurn before SpikesDamage
    yield* this.battleTurn();
    if (trainer && (this.battleResult & 0x3f) === C.WIN) {
      yield* this.say(BATTLE.BattleText_EnemyWasDefeated);
      if (this.options.canLose) {
        for (const mon of this.options.party) {
          mon.hp = mon.stats[0];
          mon.status = 0;
          mon.pp = mon.moves.map((move, slot) => {
            if (!move) return 0;
            const ups = mon.pp[slot] >> 6,
              base = this.options.data.move(move).pp;
            return (
              (ups << 6) | (base + Math.min(Math.floor(base / 5), 7) * ups)
            );
          }) as PartyMon["pp"];
        }
        this.initBattleMon();
        yield this.hud();
      }
      if (trainer.winText) yield* this.say(trainer.winText);
      return {
        result: this.battleResult,
        ...(yield* this.giveMoney(trainer.reward, this.amuletCoin)),
        evolvable: this.evolvable,
      };
    }
    if (trainer && this.options.canLose && trainer.lossText)
      yield* this.say(trainer.lossText);
    return { result: this.battleResult, evolvable: this.evolvable };
  }

  /** WinTrainerBattle.give_money: the reward (TrainerClassAttributes'
   * base times the last Pokémon's level, which `reward` holds four times)
   * is added four times, to Mom for as many quarters as her saving mode
   * takes unless her account is full, and to the wallet for the rest. Each
   * account stops at MAX_MONEY. The text shows four times the reward. */
  private *giveMoney(
    reward: number,
    amuletCoin: boolean,
  ): Gen<{ prizeMoney: number; momMoney?: number }> {
    const quarter = (reward / 4) * (amuletCoin ? 2 : 1);
    const mom = this.options.mom ?? { saving: 0, money: 0 },
      maxedOut = mom.money >= C.MAX_MONEY;
    if (![0, 1, 2, 3].includes(mom.saving))
      throw new UnsupportedBattle("Unsupported Mom saving mode.");
    // .CheckMaxedOutMomMoney, then SOME|HALF counts as all four quarters.
    const toMom = maxedOut ? 0 : mom.saving === 3 ? 4 : mom.saving;
    this.numbers[RAM.battleReward] = quarter * 4;
    yield* this.say(
      maxedOut || !mom.saving
        ? BATTLE.GotMoneyForWinningText
        : [
            BATTLE.SentSomeToMomText,
            BATTLE.SentHalfToMomText,
            BATTLE.SentAllToMomText,
          ][mom.saving - 1],
    );
    return {
      prizeMoney: quarter * (4 - toMom),
      ...(toMom ? { momMoney: quarter * toMom } : {}),
    };
  }

  private *battleTurn(): Gen {
    for (let turns = 0; turns < 1000; turns++) {
      this.curDamage = 0;
      this.enemyIsSwitching = 0;
      this.playerIsSwitching = 0;
      this.player.justGotFrozen = 0;
      this.enemy.justGotFrozen = 0;
      this.updateBattleMonInParty();
      // AIChooseMove runs once before BattleMenu, even with exhausted PP.
      if (this.options.trainer && !this.checkEnemyLockedIn()) {
        const choice = chooseTrainerMove({
          weights: this.options.trainer.aiFlags,
          player: this.player, enemy: this.enemy,
          data: this.options.data, battleData: this.data, weather: this.weather,
          random: () => this.random(),
          damage: (move) => this.enemyAIDamage(move),
        });
        this.enemy.moveNum = choice.index;
        this.enemy.curMove = choice.move;
        if (choice.enemyTurn) this.turn = 1;
      }
      if (!this.checkPlayerLockedIn()) {
        for (;;) {
          const escaped = yield* this.battleMenu();
          if (escaped || this.battleEnded) return;
          if (yield* this.parsePlayerAction()) break;
        }
      } else if (!(yield* this.parsePlayerAction())) continue;
      if (this.determineMoveOrder()) yield* this.battlePlayerFirst();
      else yield* this.battleEnemyFirst();
      if (this.battleEnded) return;
      yield* this.handleBetweenTurnEffects();
      if (this.battleEnded) return;
    }
    throw new UnsupportedBattle("The battle did not end.");
  }

  /** AIDamageCalc: pre-variation damage used only for scoring. It omits
   * accuracy and does not roll a critical hit, but, as in the ROM, a
   * wCriticalHit left over from an earlier move still selects unboosted
   * stats and doubles the estimate. */
  private enemyAIDamage(moveId: number): number {
    const move = this.options.data.move(moveId);
    switch (move.effect) {
      case C.EFFECT_SUPER_FANG:
        return Math.max(1, this.player.mon.hp >> 1);
      case C.EFFECT_STATIC_DAMAGE:
        return move.power;
      case C.EFFECT_LEVEL_DAMAGE:
        return this.enemy.mon.level;
      case C.EFFECT_PSYWAVE: {
        const limit = this.enemy.mon.level + (this.enemy.mon.level >> 1);
        for (let attempt = 0; attempt < 4096; attempt++) {
          const damage = this.random();
          if (damage && damage < limit) return damage;
        }
        throw new UnsupportedBattle("Trainer Psywave AI random source did not produce damage.");
      }
    }
    if (!move.power) return 0;
    if (this.weather) throw new UnsupportedBattle("Weather is not ported yet.");
    const special = move.type >= C.SPECIAL,
      attackStat = special ? C.SP_ATTACK : C.ATTACK,
      defenseStat = special ? C.SP_DEFENSE : C.DEFENSE,
      screen = special ? C.SCREENS_LIGHT_SCREEN : C.SCREENS_REFLECT;
    const unboosted =
      this.criticalHit && this.player.levels[defenseStat] >= this.enemy.levels[attackStat];
    let attack: number, defense: number;
    if (unboosted) {
      attack = this.enemy.stats[attackStat];
      defense = this.player.stats[defenseStat];
    } else {
      attack = this.enemy.mon.stats[attackStat];
      defense = this.player.mon.stats[defenseStat];
      if (this.player.screens & (1 << screen)) defense = (defense * 2) & 0xffff;
    }
    const boosted = special
      ? this.enemy.mon.species === C.PIKACHU && this.enemy.mon.item === C.LIGHT_BALL
      : (this.enemy.mon.species === C.CUBONE || this.enemy.mon.species === C.MAROWAK) && this.enemy.mon.item === C.THICK_CLUB;
    if (boosted) attack = (attack * 2) & 0xffff;
    [attack, defense] = this.truncate(attack, defense);
    if (this.player.mon.species === C.DITTO && this.player.mon.item === C.METAL_POWDER)
      throw new UnsupportedBattle("Metal Powder is not ported yet.");
    const held = this.data.heldEffect(this.enemy.mon.item),
      typeBoost = this.data.typeBoost(held.effect),
      boost = held.effect && typeBoost === move.type ? held.parameter : undefined,
      baseDamage = calculateDamage({
        power: move.power,
        level: this.enemy.mon.level,
        attack,
        defense,
        effect: move.effect,
        critical: Boolean(this.criticalHit),
        boost,
        current: 0,
      });
    if (baseDamage === undefined) return 0;
    return applyTypeMatchups(this.matchups, {
      damage: baseDamage,
      modifier: C.EFFECTIVE,
      moveType: move.type,
      userTypes: this.enemy.mon.types,
      targetTypes: this.player.mon.types,
      identified: this.player.has(SUB1, C.SUBSTATUS_IDENTIFIED),
    }).damage;
  }

  /** BattleMenu: FIGHT chooses a move; RUN tries to flee. Returns true if
   * the battle ended from the menu. */
  private *battleMenu(): Gen<boolean> {
    for (;;) {
      const input = yield { kind: "action" };
      if (!input || typeof input !== "object") continue;
      if (input.action === "item") {
        const used = yield* this.battleMenuPack(input.item, input.slot);
        if (this.wildMon) {
          // BattleMenu_Pack.UseItem's .run: a caught Pokémon ends the
          // battle as a WIN, keeping the result's flag bits.
          this.wildMon = 0;
          this.battleResult &= 0xc0;
          this.battleEnded = true;
          return true;
        }
        if (!used) continue;
        this.battlePlayerAction = C.BATTLEPLAYERACTION_USEITEM;
        return false;
      }
      if (input.action === "pkmn") {
        if (yield* this.battleMenuPKMN()) return false;
        continue;
      }
      if (input.action === "run") {
        const escaped = yield* this.tryToRunAway();
        if (escaped) {
          this.battleEnded = true;
          return true;
        }
        // A failed escape uses the turn (BATTLEPLAYERACTION_USEITEM).
        if (this.battlePlayerAction) return false;
        continue;
      }
      this.battlePlayerAction = 0;
      // ParsePlayerAction: Bide and Encore go on without MoveSelectionScreen.
      if (this.fightKeepsMove) return false;
      if (!(yield* this.moveSelection(input.move))) continue;
      return false;
    }
  }
  /** BattleMenu_Pack with BattlePack's USE on a Balls- or Items-pocket
   * slot. Returns true if the item was used, which takes the player's turn
   * (wItemEffectSucceeded shares wBattlePlayerAction's byte). */
  private *battleMenuPack(item: number, slot: number): Gen<boolean> {
    const data = this.options.data,
      kind = data.itemPocket(item);
    const pocket = kind === "ball" ? this.options.bag?.balls : kind === "item" ? this.options.bag?.items : undefined;
    if (!pocket || !Number.isInteger(slot) || pocket[slot]?.item !== item) return false;
    if (kind === "ball") return yield* this.pokeBallEffect(item, slot);
    // _DoItemEffect names the item in wStringBuffer1 and wStringBuffer2.
    this.strings[RAM.stringBuffer1] = this.strings[RAM.stringBuffer2] = data.itemName(item);
    // CheckItemContext: the low nibble of the item's help byte.
    const context = this.reader.byte(SYMBOLS.itemAttributes + (item - 1) * 7 + 6) & 0x0f;
    if (context < C.ITEMMENU_CURRENT) {
      yield* this.say(BATTLE.OakThisIsntTheTimeText);
      return false;
    }
    // ItemEffects: the routine this item runs, chosen by its ROM address.
    const effect = this.reader.near(BATTLE.ItemEffects + (item - 1) * 2, this.reader.bank(BATTLE.ItemEffects));
    const use = { item, slot };
    if (context === C.ITEMMENU_PARTY) {
      // BattlePack's .BattleField: anything but success stays in the pack.
      switch (effect) {
        case BATTLE.RestoreHPEffect:
          return yield* this.statusHealerResult(yield* this.itemRestoreHP(use));
        case BATTLE.StatusHealingEffect:
          return yield* this.statusHealingEffect(use);
        case BATTLE.FullRestoreEffect:
          return yield* this.fullRestoreEffect(use);
        case BATTLE.ReviveEffect:
          return yield* this.reviveEffect(use, 0);
        case BATTLE.RevivalHerbEffect:
          return yield* this.reviveEffect(use, C.HAPPINESS_REVIVALHERB);
        case BATTLE.EnergypowderEffect:
        case BATTLE.EnergyRootEffect:
          return yield* this.bitterRestoreHP(use, effect === BATTLE.EnergyRootEffect ? C.HAPPINESS_ENERGYROOT : C.HAPPINESS_BITTERPOWDER);
        case BATTLE.HealPowderEffect:
          return yield* this.healPowderEffect(use);
        case BATTLE.BitterBerryEffect:
          return yield* this.bitterBerryEffect(use);
        case BATTLE.RestorePPEffect:
          return yield* this.restorePPEffect(use);
      }
    } else if (context !== C.ITEMMENU_CURRENT) {
      // BattlePack's .BattleOnly: failure gives Oak's warning, and the
      // "won't have any effect" value 2 returns to the pack.
      let result: number | undefined;
      switch (effect) {
        case BATTLE.XItemEffect:
          result = yield* this.xItemEffect(use);
          break;
        case BATTLE.XAccuracyEffect:
          result = yield* this.setPlayerSubstatusItem(use, C.SUBSTATUS_X_ACCURACY);
          break;
        case BATTLE.GuardSpecEffect:
          result = yield* this.setPlayerSubstatusItem(use, C.SUBSTATUS_MIST);
          break;
        case BATTLE.DireHitEffect:
          result = yield* this.setPlayerSubstatusItem(use, C.SUBSTATUS_FOCUS_ENERGY);
          break;
        case BATTLE.PokeDollEffect:
          result = yield* this.pokeDollEffect(use);
          break;
      }
      if (result !== undefined) {
        if (!result) yield* this.say(BATTLE.OakThisIsntTheTimeText);
        return result === 1;
      }
    }
    throw new UnsupportedBattle(`${data.itemName(item)} is not ported yet.`);
  }
  /** StatusHealer_Jumptable: 0 used, 1 "won't have any effect", 2 cancelled. */
  private *statusHealerResult(code: number): Gen<boolean> {
    if (code === 1) yield* this.say(BATTLE.ItemWontHaveEffectText);
    return code === 0;
  }
  /** UseItem_SelectMon: the party menu for an item. Returns the party
   * index, or -1 when cancelled or an Egg was chosen. */
  private *useItemSelectMon(): Gen<number> {
    const slot = yield* this.partyMenu(BATTLE.UseOnWhichPKMNString, false, true);
    if (slot < 0) return -1;
    if (this.options.party[slot].species === C.EGG) {
      yield* this.say(BATTLE.ItemCantUseOnEggText);
      return -1;
    }
    return slot;
  }
  /** UseItemText: "<PLAYER> used <ITEM>!", a button, then UseDisposableItem. */
  private *useItemText({ item, slot }: ItemUse): Gen {
    yield* this.say(BATTLE.ItemUsedText, true);
    this.tossItem("items", item, slot);
  }
  /** ItemRestoreHP: HealingHPAmounts, up to the maximum. The Pokémon out
   * takes the party HP, which UpdateBattleMonInParty copied at the start of
   * the turn. Returns the StatusHealer_Jumptable value. */
  private *itemRestoreHP({ item, slot }: ItemUse): Gen<number> {
    const target = yield* this.useItemSelectMon();
    if (target < 0) return 2;
    const mon = this.options.party[target];
    if (!mon.hp || mon.hp >= mon.stats[0]) return 1;
    const r = this.reader;
    let amount: number | undefined;
    for (let p = BATTLE.HealingHPAmounts; r.byte(p) !== 0xff; p += 3)
      if (r.byte(p) === item) amount = r.word(p + 1);
    if (amount === undefined) throw new UnsupportedBattle("Missing healing amount.");
    yield* this.restoreHP(target, restoreHealth(mon.hp, mon.stats[0], amount), C.PARTYMENUTEXT_HEAL_HP);
    this.tossItem("items", item, slot);
    return 0;
  }
  /** The HP change, BattlemonRestoreHealth and the party menu action text
   * with wCurHPAnimDeltaHP. */
  private *restoreHP(target: number, hp: number, text: number): Gen {
    const mon = this.options.party[target];
    this.numbers[RAM.curHPAnimDeltaHP] = hp - mon.hp;
    mon.hp = hp;
    if (target === this.curBattleMon) this.player.mon.hp = hp;
    yield this.hud();
    yield* this.partyMenuActionText(target, text);
  }
  /** EnergypowderEffect and EnergyRootEffect: ItemRestoreHP, then the
   * bitter taste costs happiness. */
  private *bitterRestoreHP(use: ItemUse, happiness: number): Gen<boolean> {
    const code = yield* this.itemRestoreHP(use);
    if (!code) {
      this.changeHappiness(this.curPartyMon, happiness);
      yield* this.say(BATTLE.ItemLooksBitterText);
    }
    return yield* this.statusHealerResult(code);
  }
  /** StatusHealingEffect. */
  private *statusHealingEffect(use: ItemUse): Gen<boolean> {
    const target = yield* this.useItemSelectMon();
    if (target < 0) return false;
    return yield* this.statusHealerResult(yield* this.useStatusHealer(use, target));
  }
  /** HealPowderEffect: a status heal that tastes bitter. */
  private *healPowderEffect(use: ItemUse): Gen<boolean> {
    const target = yield* this.useItemSelectMon();
    if (target < 0) return false;
    const code = yield* this.useStatusHealer(use, target);
    if (!code) {
      this.changeHappiness(target, C.HAPPINESS_BITTERPOWDER);
      yield* this.say(BATTLE.ItemLooksBitterText);
    }
    return yield* this.statusHealerResult(code);
  }
  /** GetItemHealingAction: StatusHealingActions' text and status mask. */
  private healingAction(item: number) {
    const r = this.reader;
    let p = BATTLE.StatusHealingActions;
    while (r.byte(p) !== item) {
      if (r.byte(p) === 0xff) throw new UnsupportedBattle("Missing status healing action.");
      p += 3;
    }
    return { text: r.byte(p + 1), mask: r.byte(p + 2) };
  }
  /** UseStatusHealer: 0 if used, 1 if it would have no effect. */
  private *useStatusHealer({ item, slot }: ItemUse, target: number): Gen<number> {
    const mon = this.options.party[target];
    if (!mon.hp) return 1;
    let { text, mask } = this.healingAction(item);
    if (!(mon.status & mask)) {
      // IsItemUsedOnConfusedMon: a full heal still cures the confusion of
      // the Pokémon out.
      if (!(target === this.curBattleMon && mask === 0xff && this.player.has(SUB3, C.SUBSTATUS_CONFUSED)))
        return 1;
      text = C.PARTYMENUTEXT_HEAL_CONFUSION;
    }
    mon.status = 0;
    this.healStatus(target, mask);
    yield this.hud();
    yield* this.partyMenuActionText(target, text);
    this.tossItem("items", item, slot);
    return 0;
  }
  /** HealStatus: the Pokémon out loses its status, Toxic and Nightmare
   * (and confusion with a full heal), then CalcPlayerStats. */
  private healStatus(target: number, mask: number) {
    if (target !== this.curBattleMon) return;
    this.player.mon.status = 0;
    this.player.reset(SUB5, C.SUBSTATUS_TOXIC);
    this.player.reset(SUB1, C.SUBSTATUS_NIGHTMARE);
    if (mask === 0xff) this.player.reset(SUB3, C.SUBSTATUS_CONFUSED);
    this.calcPlayerStats();
  }
  /** FullRestoreEffect: full HP and no status; at full HP only the status. */
  private *fullRestoreEffect(use: ItemUse): Gen<boolean> {
    const target = yield* this.useItemSelectMon();
    if (target < 0) return false;
    const mon = this.options.party[target];
    if (!mon.hp) return yield* this.statusHealerResult(1);
    if (mon.hp >= mon.stats[0]) return yield* this.statusHealerResult(yield* this.useStatusHealer(use, target));
    mon.status = 0;
    this.healStatus(target, this.healingAction(use.item).mask);
    yield* this.restoreHP(target, mon.stats[0], C.PARTYMENUTEXT_HEAL_HP);
    this.tossItem("items", use.item, use.slot);
    return true;
  }
  /** ReviveEffect and RevivalHerbEffect (RevivePokemon). A revived
   * Pokémon that took part in the battle shares the experience again. */
  private *reviveEffect(use: ItemUse, happiness: number): Gen<boolean> {
    const target = yield* this.useItemSelectMon();
    if (target < 0) return false;
    const mon = this.options.party[target];
    if (mon.hp) return yield* this.statusHealerResult(1);
    if (this.participantsAll & (1 << target)) this.participants |= 1 << target;
    // ReviveHalfHP halves the maximum HP; the others restore all of it.
    yield* this.restoreHP(target, use.item === C.REVIVE ? mon.stats[0] >> 1 : mon.stats[0], C.PARTYMENUTEXT_REVIVE);
    this.tossItem("items", use.item, use.slot);
    if (happiness) {
      this.changeHappiness(target, happiness);
      yield* this.say(BATTLE.ItemLooksBitterText);
    }
    return true;
  }
  /** BitterBerryEffect: cures the confusion of the Pokémon out. */
  private *bitterBerryEffect(use: ItemUse): Gen<boolean> {
    if (!this.player.has(SUB3, C.SUBSTATUS_CONFUSED)) return yield* this.statusHealerResult(1);
    this.player.reset(SUB3, C.SUBSTATUS_CONFUSED);
    this.turn = 0;
    yield* this.useItemText(use);
    yield* this.say(BATTLE.ConfusedNoMoreText);
    return true;
  }
  /** RestorePPEffect for Ethers, Elixers and the MysteryBerry. Choosing no
   * move goes back to the party menu. */
  private *restorePPEffect(use: ItemUse): Gen<boolean> {
    const data = this.options.data,
      item = use.item;
    for (;;) {
      const target = yield* this.useItemSelectMon();
      if (target < 0) return false;
      const mon = this.options.party[target];
      let restored = false;
      if (item === C.ELIXER || item === C.MAX_ELIXER) {
        for (let slot = 0; slot < 4; slot++)
          if (mon.moves[slot] && this.restorePP(mon, slot, item)) restored = true;
      } else {
        const choice = yield {
          kind: "move",
          text: readTextEnd(this.reader, BATTLE.RestoreThePPOfWhichMoveText, this.context()).text,
          moves: [...mon.moves],
          pp: [...mon.pp],
        };
        if (typeof choice !== "number" || choice < 0 || choice > 3 || !mon.moves[choice]) continue;
        // GetMoveName and CopyName1: the move's name in wStringBuffer2.
        this.strings[RAM.stringBuffer1] = this.strings[RAM.stringBuffer2] = data.moveName(mon.moves[choice]);
        restored = this.restorePP(mon, choice, item);
      }
      if (!restored) return yield* this.statusHealerResult(1);
      // BattleRestorePP: the Pokémon out takes the PP of matching moves,
      // unless it is transformed.
      if (target === this.curBattleMon && !this.player.has(SUB5, C.SUBSTATUS_TRANSFORMED))
        this.player.mon.moves.forEach((move, slot) => {
          if (move && move === mon.moves[slot]) this.player.mon.pp[slot] = mon.pp[slot];
        });
      yield* this.say(BATTLE.PPRestoredText);
      this.tossItem("items", item, use.slot);
      return true;
    }
  }
  /** RestorePP: MAX items fill the move; others add 10 (the MysteryBerry
   * 5) up to GetMaxPPOfMove. Returns false if the PP was already full. */
  private restorePP(mon: PartyMon, slot: number, item: number) {
    const max = maxPP(this.options.data, mon.moves[slot], mon.pp[slot] >> 6) & C.PP_MASK;
    const pp = restoredPP(mon.pp[slot], max, item);
    if (pp === undefined) return false;
    mon.pp[slot] = pp;
    return true;
  }
  /** XItemEffect: the item is used, then RaiseStat on the player's side,
   * even if the stat cannot rise, and a small happiness gain. */
  private *xItemEffect(use: ItemUse): Gen<number> {
    yield* this.useItemText(use);
    const r = this.reader;
    let p = BATTLE.XItemStats;
    while (r.byte(p) !== use.item) p += 2;
    this.turn = 0;
    this.attackMissed = 0;
    this.effectFailed = 0;
    this.raiseStat(r.byte(p + 1));
    yield this.hud();
    yield* this.statUpMessage();
    yield* this.statUpFailText();
    this.changeHappiness(this.curBattleMon, C.HAPPINESS_USEDXITEM);
    return 1;
  }
  /** XAccuracyEffect, GuardSpecEffect and DireHitEffect: a SubStatus4 flag
   * that can be set once (WontHaveAnyEffect_NotUsedMessage returns 2). */
  private *setPlayerSubstatusItem(use: ItemUse, bit: number): Gen<number> {
    if (this.player.has(SUB4, bit)) {
      yield* this.say(BATTLE.ItemWontHaveEffectText);
      return 2;
    }
    this.player.sub[SUB4] |= 1 << bit;
    yield* this.useItemText(use);
    return 1;
  }
  /** PokeDollEffect: ends a wild battle as a draw (wForcedSwitch); in a
   * trainer battle it fails. */
  private *pokeDollEffect(use: ItemUse): Gen<number> {
    if (this.battleMode !== C.WILD_BATTLE) return 0;
    this.battleResult = (this.battleResult & 0xc0) | C.DRAW;
    yield* this.useItemText(use);
    this.battleEnded = true;
    return 1;
  }
  /** CalcPlayerStats: stat stages, then the paralysis and burn penalties
   * for the side that hBattleTurn names after BattleCommand_SwitchTurn,
   * which is the enemy if hBattleTurn held the enemy's turn. At the battle
   * menu that happens after a full turn (HandleHealingItems ends on the
   * enemy) and after a trainer AI layer set it. */
  private calcPlayerStats() {
    const player = this.player;
    for (let stat = 0; stat < 5; stat++) {
      const [numerator, denominator] = this.data.statMultiplier(player.levels[stat]);
      const value = Math.floor((player.stats[stat] * numerator) / denominator);
      player.mon.stats[stat] = value === 0 ? 1 : Math.min(999, value);
    }
    this.applyStatusEffects(this.turn === 0 ? this.player : this.enemy);
  }
  /** PrintPartyMenuActionText with the Pokémon's nickname. */
  private *partyMenuActionText(target: number, text: number): Gen {
    this.strings[RAM.stringBuffer1] = this.options.party[target].nickname;
    const table = BATTLE["PrintPartyMenuActionText.MenuActionTexts"];
    yield* this.say(this.reader.near(table + (text & 0x0f) * 2, this.reader.bank(table)));
  }
  /** UseDisposableItem: toss one from the pocket slot it was used from. */
  private tossItem(pocketName: "items" | "balls", item: number, slot: number) {
    const pocket = this.options.bag?.[pocketName];
    if (!pocket) throw new UnsupportedBattle("Missing pack.");
    const index = pocket[slot]?.item === item ? slot : pocket.findIndex((entry) => entry.item === item);
    if (index < 0) throw new UnsupportedBattle("The item is not in the pack.");
    if (!--pocket[index].quantity) pocket.splice(index, 1);
  }

  /** PokeBallEffect (engine/items/item_effects.asm). `slot` is the pocket
   * index the ball came from (wCurItemQuantity); the tutorial uses the
   * Dude's own ball and passes -1. Returns false if no ball was used. */
  private *pokeBallEffect(item: number, slot: number): Gen<boolean> {
    const data = this.options.data,
      tutorial = this.battleType === C.BATTLETYPE_TUTORIAL;
    // _DoItemEffect: GetItemName, then CopyName1 into wStringBuffer2.
    this.strings[RAM.stringBuffer1] = this.strings[RAM.stringBuffer2] = data.itemName(item);
    if (this.battleMode !== C.WILD_BATTLE) {
      // UseBallInTrainerBattle: the blocked-ball animation, then
      // UseDisposableItem. The turn is used.
      yield* this.say(BATTLE.BallBlockedText);
      yield* this.say(BATTLE.BallDontBeAThiefText);
      this.tossItem("balls", item, slot);
      return true;
    }
    // With a full party the Pokémon would go to the current box; if that is
    // full too, the ball is not used (Ball_BoxIsFullMessage).
    const storage = this.options.storage;
    if (
      this.options.party.length >= PARTY_LENGTH &&
      (!storage || currentBox(storage).length >= MONS_PER_BOX)
    ) {
      // The Dude's tutorial reaches this check too, and the original then
      // repeats the unusable ball forever (docs/bugs_and_glitches.md).
      if (tutorial) throw new UnsupportedBattle("The Dude's Poké Ball cannot be used with a full party and box.");
      if (!storage) throw new UnsupportedBattle("Missing PC boxes.");
      yield* this.say(BATTLE.BallBoxFullText);
      return false;
    }
    if (![C.MASTER_BALL, C.ULTRA_BALL, C.GREAT_BALL, C.POKE_BALL].includes(item as never))
      throw new UnsupportedBattle(`${data.itemName(item)} is not ported yet.`);
    this.wildMon = 0;
    yield* this.say(BATTLE.ItemUsedText);

    const { caught, wobbles } = this.rollCapture(item, tutorial);

    if (!caught) {
      yield* this.say(
        [
          BATTLE.BallBrokeFreeText,
          BATTLE.BallAppearedCaughtText,
          BATTLE.BallAlmostHadItText,
          BATTLE.BallSoCloseText,
        ][wobbles - 1],
      );
      if (!tutorial) this.tossItem("balls", item, slot);
      return true;
    }

    // Caught: LoadEnemyMon runs again with SUBSTATUS_TRANSFORMED set, which
    // keeps the DVs, redraws the wild item (restored afterwards) and
    // recalculates stats. Status, HP and item are kept; moves and PP return
    // to wWildMonMoves and wWildMonPP.
    if (this.enemy.has(SUB5, C.SUBSTATUS_TRANSFORMED))
      throw new UnsupportedBattle("Catching a transformed Pokémon is not ported yet.");
    if (this.random() >= percent(75) + 1) this.random();
    const enemy = this.enemy.mon,
      species = enemy.species,
      level = enemy.level;
    this.wildMon = species;
    if (tutorial) {
      // .FinishTutorial: the Dude's Pokémon is not kept, and his ball is
      // not tossed.
      yield* this.say(BATTLE.Text_GotchaMonWasCaught);
      return true;
    }
    yield* this.say(BATTLE.Text_GotchaMonWasCaught);
    const pokedex = this.options.pokedex,
      caughtBefore = pokedex.caught.has(species);
    pokedex.seen.add(species);
    pokedex.caught.add(species);
    if (!caughtBefore && this.options.hasPokedex) {
      // NewPokedexEntry's Pokédex page is not presented yet.
      yield* this.say(BATTLE.NewDexDataText);
    }
    if (!this.options.caughtData) throw new UnsupportedBattle("Missing caught data.");
    const name = data.speciesName(species);
    if (this.options.party.length >= PARTY_LENGTH) {
      yield* this.sendToPC(species, level, name);
      this.tossItem("balls", item, slot);
      return true;
    }
    // TryAddMonToParty with wBattleMode set: GeneratePartyMonStats copies
    // the wild Pokémon, then SetCaughtData.
    const mon: PartyMon = {
      species,
      item: enemy.item,
      moves: [...this.wildMoves] as PartyMon["moves"],
      otId: this.options.playerId,
      ot: this.options.playerName,
      nickname: name,
      exp: data.expAtLevel(data.baseData(species).growthRate, level),
      statExp: [0, 0, 0, 0, 0],
      dvs: enemy.dvs,
      pp: [...this.wildPP] as PartyMon["pp"],
      happiness: C.BASE_HAPPINESS,
      pokerus: 0,
      caughtData: this.options.caughtData(level),
      level,
      status: enemy.status,
      hp: enemy.hp,
      stats: calcStats(data, species, enemy.dvs, level),
    };
    this.options.party.push(mon);
    mon.nickname = yield* this.askNickname(name);
    this.tossItem("balls", item, slot);
    return true;
  }
  /** PokeBallEffect's decision, before animation and caught-mon loading. */
  private rollCapture(item: number, tutorial: boolean) {
    let caught = tutorial || item === C.MASTER_BALL;
    if (!caught) {
      const held = this.data.heldEffect(this.player.mon?.item ?? 0);
      const chance = catchRate({
        rate: this.enemyBase.catchRate,
        ball: item,
        hp: this.enemy.mon.hp,
        maxHp: this.enemy.mon.maxHp,
        status: this.enemy.mon.status,
        held,
      });
      if (chance === undefined) throw new UnsupportedBattle("The catch rate divides by zero.");
      this.finalCatchRate = chance;
      caught = this.random() <= chance;
    }

    return { caught, wobbles: this.ballWobbles(caught) };
  }

  private ballWobbles(caught: boolean): number {
    // BattleAnim_ThrowPokeBall's .Shake loop runs GetPokeBallWobble until
    // the ball clicks or the Pokémon breaks free.
    let wobbles = 0;
    for (;;) {
      wobbles++;
      if (wobbles === 4) break;
      if (caught) continue;
      let entry = BATTLE.WobbleProbabilities;
      while (this.reader.byte(entry) < this.finalCatchRate) entry += 2;
      if (this.random() >= this.reader.byte(entry + 1)) break;
    }
    return wobbles;
  }

  /** AskGiveNicknameText, then NamingScreen (NAME_MON) if accepted: the
   * chosen name, or the species name for a declined or blank one. */
  private *askNickname(name: string): Gen<string> {
    this.strings[RAM.stringBuffer1] = name;
    yield* this.say(BATTLE.AskGiveNicknameText);
    if (!(yield { kind: "yesno", text: "" })) return name;
    // "<SPECIES>'S" / "NICKNAME?".
    let second = SYMBOLS.nicknameStrings;
    while (this.reader.byte(second++) !== 0x50);
    const context = this.context(),
      suffix = readString(this.reader, SYMBOLS.nicknameStrings, context),
      title = readString(this.reader, second, context);
    const answer = yield { kind: "name", title: `${name}${suffix}\n${title}`, current: name, max: 10 };
    if (typeof answer !== "string" || answer.length > 10 || (answer && !NICKNAME_PATTERN.test(answer)))
      throw new UnsupportedBattle("Invalid nickname.");
    // InitName: a name of zero or more spaces takes the species name.
    return /^ *$/.test(answer) ? name : answer;
  }
  /** PokeBallEffect's .SendToPC: SendMonIntoBox puts the caught Pokémon
   * first in the current box (from wEnemyMon, with restored PP), then
   * SetBoxMonCaughtData. A box filled by it sets BATTLERESULT_BOX_FULL for
   * Bill's call; the nickname and BallSentToPCText follow. */
  private *sendToPC(species: number, level: number, name: string): Gen {
    const data = this.options.data,
      storage = this.options.storage!,
      box = currentBox(storage);
    const mon: BoxMon = {
      species,
      item: this.enemy.mon.item,
      moves: [...this.wildMoves] as BoxMon["moves"],
      otId: this.options.playerId,
      ot: this.options.playerName,
      nickname: name,
      exp: data.expAtLevel(data.baseData(species).growthRate, level),
      statExp: [0, 0, 0, 0, 0],
      dvs: this.enemy.mon.dvs,
      pp: [...this.wildPP] as BoxMon["pp"],
      happiness: C.BASE_HAPPINESS,
      pokerus: 0,
      caughtData: this.options.caughtData!(level),
      level,
    };
    restorePP(data, mon);
    box.unshift(mon);
    if (box.length === MONS_PER_BOX) this.battleResult |= BATTLERESULT_BOX_FULL;
    mon.nickname = yield* this.askNickname(name);
    this.strings[RAM.monOrItemNameBuffer] = mon.nickname;
    yield* this.say(BATTLE.BallSentToPCText);
  }
  /** TossItem after a throw: RemoveItemFromPocket takes the ball from the
   * selected slot if it matches, otherwise from the first matching slot. */

  /** MoveSelectionScreen's checks for a chosen move. */
  private *moveSelection(index: number): Gen<boolean> {
    const mon = this.player.mon;
    if (!this.checkPlayerHasUsableMoves()) {
      yield* this.say(BATTLE.BattleText_MonHasNoMovesLeft);
      this.player.curMove = C.STRUGGLE;
      return true;
    }
    if (!Number.isInteger(index) || index < 0 || index > 3 || !mon.moves[index]) return false;
    if (this.player.disableCount && index === ((this.player.disableCount >> 4) & 0xf) - 1) {
      this.strings[RAM.stringBuffer1] = this.options.data.moveName(mon.moves[index]);
      yield* this.say(BATTLE.BattleText_TheMoveIsDisabled);
      return false;
    }
    if (!(mon.pp[index] & C.PP_MASK)) {
      yield* this.say(BATTLE.BattleText_TheresNoPPLeftForThisMove);
      return false;
    }
    this.player.moveNum = index;
    this.player.curMove = mon.moves[index];
    return true;
  }
  private checkPlayerHasUsableMoves() {
    const side = this.player;
    if (side.disableCount) {
      const disabled = ((side.disableCount >> 4) & 0xf) - 1;
      return side.mon.pp.some((pp, index) => index !== disabled && pp & C.PP_MASK);
    }
    return Boolean(side.mon.pp.reduce((a, b) => a | b, 0) & C.PP_MASK);
  }
  private checkPlayerLockedIn(): boolean {
    const player = this.player;
    if (player.has(SUB4, C.SUBSTATUS_RECHARGE)) return true;
    this.enemy.reset(SUB3, C.SUBSTATUS_FLINCHED);
    player.reset(SUB3, C.SUBSTATUS_FLINCHED);
    if (player.sub[SUB3] & ((1 << C.SUBSTATUS_CHARGED) | (1 << C.SUBSTATUS_RAMPAGE))) return true;
    return player.has(SUB1, C.SUBSTATUS_ROLLOUT);
  }
  /** ParsePlayerAction then ParseEnemyAction. Returns false to re-open the menu. */
  private *parsePlayerAction(): Gen<boolean> {
    const player = this.player;
    // A locked-in or biding Pokémon keeps last turn's move and move struct.
    if (this.checkPlayerLockedIn()) return this.playerLockedIn();
    // An encored Pokémon takes its last move, whatever the action.
    const encored = player.has(SUB5, C.SUBSTATUS_ENCORED);
    if (encored) player.curMove = player.lastMove;
    else if (this.battlePlayerAction === C.BATTLEPLAYERACTION_SWITCH) {
      // PlayerSwitch already ran ParseEnemyAction.
      player.furyCutterCount = 0;
      player.protectCount = 0;
      player.rageCounter = 0;
      player.reset(SUB4, C.SUBSTATUS_RAGE);
      return true;
    }
    if (encored || this.battlePlayerAction === 0) {
      if (!encored && player.has(SUB3, C.SUBSTATUS_BIDE)) return this.playerLockedIn();
      this.turn = 0;
      this.updateMoveData();
      player.charging = 0;
      if (player.move.effect !== C.EFFECT_FURY_CUTTER) player.furyCutterCount = 0;
      if (player.move.effect !== C.EFFECT_RAGE) {
        player.reset(SUB4, C.SUBSTATUS_RAGE);
        player.rageCounter = 0;
      }
      if (player.move.effect !== C.EFFECT_PROTECT && player.move.effect !== C.EFFECT_ENDURE)
        player.protectCount = 0;
    } else {
      player.reset(SUB3, C.SUBSTATUS_BIDE);
      return this.playerLockedIn();
    }
    this.parseEnemyAction();
    return true;
  }
  /** ParsePlayerAction's .locked_in. */
  private playerLockedIn() {
    const player = this.player;
    player.furyCutterCount = 0;
    player.protectCount = 0;
    player.rageCounter = 0;
    player.reset(SUB4, C.SUBSTATUS_RAGE);
    this.parseEnemyAction();
    return true;
  }
  /** ParseEnemyAction: use the trainer AI selection or a random wild move. */
  private parseEnemyAction() {
    if (this.enemyIsSwitching) return;
    const enemy = this.enemy,
      mon = enemy.mon;
    const encored = enemy.has(SUB5, C.SUBSTATUS_ENCORED);
    if (!encored && this.checkEnemyLockedIn()) {
      // ResetVarsForSubstatusRage: the move and its struct stay.
      enemy.furyCutterCount = 0;
      enemy.protectCount = 0;
      enemy.rageCounter = 0;
      enemy.reset(SUB4, C.SUBSTATUS_RAGE);
      return;
    }
    let move: number = encored ? enemy.lastMove : C.STRUGGLE;
    const usable = !encored && mon.moves.some(
      (candidate, slot) =>
        candidate &&
        candidate !== enemy.disabledMove &&
        mon.pp[slot] & C.PP_MASK,
    );
    if (encored) {
      // The move number stays the AI's or last turn's choice.
    } else if (this.options.trainer && usable) {
      move = enemy.curMove;
    } else
      for (let slot = 0; slot < 4; slot++) {
        const candidate = mon.moves[slot];
        if (!candidate) break;
        if (candidate === enemy.disabledMove || !(mon.pp[slot] & C.PP_MASK))
          continue;
        for (let guard = 0; guard < 4096; guard++) {
          const choice = this.random() & 3;
          if (((enemy.disableCount >> 4) & 0xf) - 1 === choice) continue;
          if (!mon.moves[choice] || !(mon.pp[choice] & C.PP_MASK)) continue;
          enemy.moveNum = choice;
          move = mon.moves[choice];
          break;
        }
        break;
      }
    enemy.curMove = move;
    this.turn = 1;
    this.updateMoveData();
    if (!this.checkEnemyLockedIn()) enemy.charging = 0;
    if (enemy.move.effect !== C.EFFECT_FURY_CUTTER) enemy.furyCutterCount = 0;
    if (enemy.move.effect !== C.EFFECT_RAGE) {
      enemy.reset(SUB4, C.SUBSTATUS_RAGE);
      enemy.rageCounter = 0;
    }
    if (enemy.move.effect !== C.EFFECT_PROTECT && enemy.move.effect !== C.EFFECT_ENDURE)
      enemy.protectCount = 0;
  }
  private checkEnemyLockedIn() {
    const enemy = this.enemy;
    return (
      enemy.has(SUB4, C.SUBSTATUS_RECHARGE) ||
      Boolean(
        enemy.sub[SUB3] &
          ((1 << C.SUBSTATUS_CHARGED) | (1 << C.SUBSTATUS_RAMPAGE) | (1 << C.SUBSTATUS_BIDE)),
      ) ||
      enemy.has(SUB1, C.SUBSTATUS_ROLLOUT)
    );
  }
  /** UpdateMoveData: the move struct for the current turn's move. */
  private updateMoveData() {
    const side = this.user;
    const move = this.options.data.move(side.curMove);
    side.move = {
      anim: move.id,
      effect: move.effect,
      power: move.power,
      type: move.type,
      accuracy: move.accuracy,
      pp: move.pp,
      chance: move.chance,
    };
    // GetMoveName fills wStringBuffer1; CopyName1 copies it to wStringBuffer2.
    const name = this.options.data.moveName(side.curMove);
    this.strings[RAM.stringBuffer1] = name;
    this.strings[RAM.stringBuffer2] = name;
  }

  /** DetermineMoveOrder: true if the player moves first. */
  private determineMoveOrder(): boolean {
    if (this.battlePlayerAction) return true;
    const player = this.data.priority(
      this.options.data.move(this.player.curMove).effect,
      C.BASE_PRIORITY,
    );
    const enemy = this.data.priority(
      this.options.data.move(this.enemy.curMove).effect,
      C.BASE_PRIORITY,
    );
    const priority = (move: number, value: number) =>
      move === C.VITAL_THROW ? 0 : value;
    const playerPriority = priority(this.player.curMove, player),
      enemyPriority = priority(this.enemy.curMove, enemy);
    if (playerPriority !== enemyPriority) return playerPriority > enemyPriority;
    const playerItem = this.data.heldEffect(this.player.mon.item),
      enemyItem = this.data.heldEffect(this.enemy.mon.item);
    if (playerItem.effect === C.HELD_QUICK_CLAW && enemyItem.effect === C.HELD_QUICK_CLAW) {
      if (this.random() < enemyItem.parameter) return false;
      if (this.random() < playerItem.parameter) return true;
    } else if (playerItem.effect === C.HELD_QUICK_CLAW) {
      if (this.random() < playerItem.parameter) return true;
    } else if (enemyItem.effect === C.HELD_QUICK_CLAW) {
      if (this.random() < enemyItem.parameter) return false;
    }
    const playerSpeed = this.player.mon.stats[C.SPEED],
      enemySpeed = this.enemy.mon.stats[C.SPEED];
    if (playerSpeed !== enemySpeed) return playerSpeed > enemySpeed;
    return this.random() < percent(50) + 1;
  }

  private *battlePlayerFirst(): Gen {
    this.enemyGoesFirst = 0;
    this.turn = 1;
    const switched = yield* this.aiSwitchOrTryItem();
    yield* this.doTurnFor(0);
    if (this.hasFainted(this.enemy)) return yield* this.handleEnemyMonFaint();
    if (this.hasFainted(this.player)) return yield* this.handlePlayerMonFaint();
    this.turn = 0;
    if (!(yield* this.residualDamage())) return yield* this.handlePlayerMonFaint();
    yield this.hud();
    if (!switched) {
      if (this.tryEnemyFlee()) return yield* this.wildFled();
      yield* this.doTurnFor(1);
      if (this.hasFainted(this.player)) return yield* this.handlePlayerMonFaint();
      if (this.hasFainted(this.enemy)) return yield* this.handleEnemyMonFaint();
    }
    this.turn = 1;
    if (!(yield* this.residualDamage())) return yield* this.handleEnemyMonFaint();
    yield this.hud();
    this.battlePlayerAction = 0;
  }
  private *battleEnemyFirst(): Gen {
    if (this.tryEnemyFlee()) return yield* this.wildFled();
    this.turn = 1;
    this.enemyGoesFirst = 1;
    if (!(yield* this.aiSwitchOrTryItem())) {
      yield* this.doTurnFor(1);
      if (this.hasFainted(this.player)) return yield* this.handlePlayerMonFaint();
      if (this.hasFainted(this.enemy)) return yield* this.handleEnemyMonFaint();
    }
    this.turn = 1;
    if (!(yield* this.residualDamage())) return yield* this.handleEnemyMonFaint();
    yield this.hud();
    yield* this.doTurnFor(0);
    if (this.hasFainted(this.enemy)) return yield* this.handleEnemyMonFaint();
    if (this.hasFainted(this.player)) return yield* this.handlePlayerMonFaint();
    this.turn = 0;
    if (!(yield* this.residualDamage())) return yield* this.handlePlayerMonFaint();
    yield this.hud();
    this.battlePlayerAction = 0;
  }
  /** PlayerTurn/EnemyTurn_EndOpponentProtectEndureDestinyBond. */
  private *doTurnFor(turn: number): Gen {
    this.turn = turn;
    this.user.reset(SUB5, C.SUBSTATUS_DESTINY_BOND);
    if (turn === 0 && this.battlePlayerAction) {
      // DoPlayerTurn does nothing after a failed escape or an item.
    } else yield* this.doTurn();
    const opponent = this.target;
    opponent.reset(SUB1, C.SUBSTATUS_PROTECT);
    opponent.reset(SUB1, C.SUBSTATUS_ENDURE);
    opponent.reset(SUB5, C.SUBSTATUS_DESTINY_BOND);
  }
  private hasFainted(side: Side) {
    return side.mon.hp === 0;
  }
  /** TryEnemyFlee: only some species flee, and never while asleep. */
  private tryEnemyFlee(): boolean {
    if (this.battleMode !== C.WILD_BATTLE) return false;
    if (this.player.has(SUB5, C.SUBSTATUS_CANT_RUN) || this.enemy.wrapCount) return false;
    if (this.enemy.mon.status & ((1 << C.FRZ) | C.SLP_MASK)) return false;
    const species = this.enemy.mon.species;
    if (this.data.byteList(BATTLE.AlwaysFleeMons).includes(species)) return true;
    const roll = this.random();
    if (roll >= percent(50) + 1) return false;
    if (this.data.byteList(BATTLE.OftenFleeMons).includes(species)) return true;
    if (roll >= percent(10) + 1) return false;
    return this.data.byteList(BATTLE.SometimesFleeMons).includes(species);
  }
  private *wildFled(): Gen {
    this.battleResult = (this.battleResult & 0xc0) + C.DRAW;
    yield* this.say(BATTLE.BattleText_WildFled);
    this.battleEnded = true;
  }

  /** TryToRunAwayFromBattle for a wild battle. Returns true on escape.
   * The Speed compared is the battle Pokémon's, except after a faint. */
  private *tryToRunAway(playerSpeed = this.player.mon.stats[C.SPEED]): Gen<boolean> {
    if (this.options.trainer) {
      yield* this.say(BATTLE.BattleText_TheresNoEscapeFromTrainerBattle);
      return false;
    }
    if (this.enemy.has(SUB5, C.SUBSTATUS_CANT_RUN) || this.player.wrapCount) {
      yield* this.say(BATTLE.BattleText_CantEscape);
      return false;
    }
    if (this.data.heldEffect(this.player.mon.item).effect === C.HELD_ESCAPE)
      throw new UnsupportedBattle("Escape items are not ported yet.");
    this.numFleeAttempts = (this.numFleeAttempts + 1) & 0xff;
    const enemySpeed = this.enemy.mon.stats[C.SPEED];
    let escaped = playerSpeed >= enemySpeed;
    if (!escaped) {
      const divisor = (enemySpeed >> 2) & 0xff;
      if (!divisor) escaped = true;
      else {
        const quotient = Math.floor(((playerSpeed * 32) & 0xffff) / divisor);
        if (quotient > 0xff) escaped = true;
        else {
          let odds = quotient;
          for (let attempt = this.numFleeAttempts - 1; attempt > 0; attempt--) {
            odds += 30;
            if (odds > 0xff) {
              escaped = true;
              break;
            }
          }
          if (!escaped) escaped = odds >= this.random();
        }
      }
    }
    if (!escaped) {
      this.battlePlayerAction = 1; // BATTLEPLAYERACTION_USEITEM
      yield* this.say(BATTLE.BattleText_CantEscape2);
      return false;
    }
    this.battleResult = (this.battleResult & 0xc0) + C.DRAW;
    yield* this.say(BATTLE.BattleText_GotAwaySafely);
    return true;
  }

  // ------------------------------------------------------ move execution

  /** DoTurn: CheckTurn, then the move's effect script. */
  private *doTurn(): Gen {
    this.turnEnded = 0;
    yield* this.checkTurn();
    if (this.turnEnded) return;
    this.updateMoveData();
    yield* this.doMove();
  }
  /** DoMove: run the user's move effect script. */
  private *doMove(): Gen {
    this.script = this.data.effectScript(this.user.move.effect);
    this.scriptIndex = 0;
    for (let steps = 0; steps < 256; steps++) {
      const command = this.script[this.scriptIndex++];
      if (command >= COMMAND.endturn) return;
      yield* this.command(command);
    }
    throw new UnsupportedBattle("Move effect script did not end.");
  }
  /** EndMoveEffect: stop reading the effect script. */
  private endMoveEffect() {
    this.script.splice(this.scriptIndex, 3, 0xff, 0xff, 0xff);
  }
  private *endTurn(): Gen {
    this.turnEnded = 1;
    this.curDamage = 0;
  }

  private *checkTurn(): Gen {
    const user = this.user,
      mon = user.mon;
    if (user.curMove === 0xff) return yield* this.endTurn(); // CANNOT_MOVE
    this.attackMissed = 0;
    this.effectFailed = 0;
    this.animParam = 0;
    this.alreadyDisobeyed = 0;
    this.alreadyFailed = 0;
    this.typeModifier = C.EFFECTIVE;
    if (user.has(SUB4, C.SUBSTATUS_RECHARGE)) {
      user.reset(SUB4, C.SUBSTATUS_RECHARGE);
      yield* this.say(BATTLE.MustRechargeText);
      this.cantMove();
      return yield* this.endTurn();
    }
    if (mon.status & C.SLP_MASK) {
      mon.status = (mon.status & ~C.SLP_MASK) | (((mon.status & C.SLP_MASK) - 1) & C.SLP_MASK);
      // The player checks the sleep counter; the enemy checks the whole status.
      const awake = this.turn === 0 ? !(mon.status & C.SLP_MASK) : mon.status === 0;
      if (awake) {
        yield* this.say(BATTLE.WokeUpText);
        this.cantMove();
        this.updateUserInParty();
        yield this.hud();
        user.reset(SUB1, C.SUBSTATUS_NIGHTMARE);
      } else {
        yield* this.say(BATTLE.FastAsleepText);
        if (user.curMove !== C.SNORE && user.curMove !== C.SLEEP_TALK) {
          this.cantMove();
          return yield* this.endTurn();
        }
      }
    }
    if (mon.status & (1 << C.FRZ) && user.curMove !== C.FLAME_WHEEL && user.curMove !== C.SACRED_FIRE) {
      yield* this.say(BATTLE.FrozenSolidText);
      this.cantMove();
      return yield* this.endTurn();
    }
    if (user.has(SUB3, C.SUBSTATUS_FLINCHED)) {
      user.reset(SUB3, C.SUBSTATUS_FLINCHED);
      yield* this.say(BATTLE.FlinchedText);
      this.cantMove();
      return yield* this.endTurn();
    }
    if (user.disableCount) {
      user.disableCount = (user.disableCount - 1) & 0xff;
      if (!(user.disableCount & 0xf)) {
        user.disableCount = 0;
        user.disabledMove = 0;
        yield* this.say(BATTLE.DisabledNoMoreText);
      }
    }
    if (user.has(SUB3, C.SUBSTATUS_CONFUSED)) {
      user.confuseCount = (user.confuseCount - 1) & 0xff;
      if (!user.confuseCount) {
        user.reset(SUB3, C.SUBSTATUS_CONFUSED);
        yield* this.say(BATTLE.ConfusedNoMoreText);
      } else {
        yield* this.say(BATTLE.IsConfusedText);
        if (this.random() < percent(50) + 1) {
          user.sub[SUB3] &= 1 << C.SUBSTATUS_CONFUSED;
          yield* this.hitConfusion();
          this.cantMove();
          return yield* this.endTurn();
        }
      }
    }
    if (user.has(SUB1, C.SUBSTATUS_IN_LOVE)) {
      yield* this.say(BATTLE.InLoveWithText);
      if (this.random() >= percent(50) + 1) {
        yield* this.say(BATTLE.InfatuationText);
        this.cantMove();
        return yield* this.endTurn();
      }
    }
    if (user.disabledMove && user.disabledMove === user.curMove) {
      user.reset(SUB3, C.SUBSTATUS_CHARGED);
      this.strings[RAM.stringBuffer1] = this.options.data.moveName(user.curMove);
      yield* this.say(BATTLE.DisabledMoveText);
      this.cantMove();
      return yield* this.endTurn();
    }
    if (mon.status & (1 << C.PAR) && this.random() < percent(25)) {
      yield* this.say(BATTLE.FullyParalyzedText);
      this.cantMove();
      return yield* this.endTurn();
    }
  }
  /** CantMove: moves that span turns are interrupted. */
  private cantMove() {
    const user = this.user;
    user.reset(SUB1, C.SUBSTATUS_ROLLOUT);
    user.sub[SUB3] &= ~((1 << C.SUBSTATUS_BIDE) | (1 << C.SUBSTATUS_RAMPAGE) | (1 << C.SUBSTATUS_CHARGED));
    user.furyCutterCount = 0;
    if (user.move.anim === C.FLY || user.move.anim === C.DIG) {
      user.reset(SUB3, C.SUBSTATUS_UNDERGROUND);
      user.reset(SUB3, C.SUBSTATUS_FLYING);
    }
  }
  /** HitConfusion / HitSelfInConfusion: a typeless 40-power hit on itself. */
  private *hitConfusion(): Gen {
    yield* this.say(BATTLE.HurtItselfText);
    this.criticalHit = 0;
    const user = this.user,
      mon = user.mon;
    this.curDamage = 0;
    let defense = mon.stats[C.DEFENSE];
    if (user.screens & (1 << C.SCREENS_REFLECT)) defense *= 2;
    const [attack, def] = this.truncate(mon.stats[C.ATTACK], defense);
    this.damageCalc(40, mon.level, attack, def);
    this.doDamage(this.user, true);
    yield this.hud();
  }

  private *command(command: number): Gen {
    switch (command) {
      case COMMAND.checkobedience:
        return this.checkObedience();
      case COMMAND.usedmovetext:
        return yield* this.say(BATTLE.UsedMoveText);
      case COMMAND.doturn:
        return yield* this.doTurnCommand();
      case COMMAND.critical:
        return this.critical();
      case COMMAND.damagestats:
        return this.damageStats();
      case COMMAND.damagecalc:
        return this.damageCalcCommand();
      case COMMAND.stab:
        return this.stab();
      case COMMAND.damagevariation:
        return this.damageVariation();
      case COMMAND.checkhit:
        return yield* this.checkHit();
      case COMMAND.effectchance:
        return this.effectChance();
      case COMMAND.lowersub:
      case COMMAND.raisesub:
      case COMMAND.lowersubnoanim:
      case COMMAND.raisesubnoanim:
      case COMMAND.movedelay:
        return this.requireNoSubstitute();
      case COMMAND.moveanimnosub:
      case COMMAND.moveanim:
        this.requireNoSubstitute();
        return this.moveAnimNoSub();
      case COMMAND.statupanim:
      case COMMAND.statdownanim:
        this.requireNoSubstitute();
        // BattleCommand_StatUpDownAnim
        if (!this.attackMissed) this.animParam = 0;
        return;
      case COMMAND.cleartext:
        return; // An empty BattleTextbox.
      case COMMAND.startloop:
        this.user.rolloutCount = 0;
        return;
      case COMMAND.endloop:
        return yield* this.endLoop();
      case COMMAND.supereffectivelooptext:
        if (this.user.has(SUB3, C.SUBSTATUS_IN_LOOP)) return;
        return yield* this.superEffectiveText();
      case COMMAND.triplekick:
        // The damage once more for each kick so far, up to $ffff.
        this.curDamage = Math.min(0xffff, this.curDamage * (this.animParam + 1));
        return;
      case COMMAND.kickcounter:
        this.animParam = (this.animParam + 1) & 0xff;
        return;
      case COMMAND.beatup:
        return yield* this.beatUp();
      case COMMAND.beatupfailtext:
        return yield* this.beatUpFailText();
      case COMMAND.constantdamage:
        return this.constantDamage();
      case COMMAND.resettypematchup:
        this.resetTypeMatchup();
        return;
      case COMMAND.ohko:
        return yield* this.ohko();
      case COMMAND.counter:
        return this.counter(false);
      case COMMAND.mirrorcoat:
        return this.counter(true);
      case COMMAND.payday:
        return yield* this.payDay();
      case COMMAND.thief:
        return yield* this.thief();
      case COMMAND.selfdestruct:
        return yield* this.selfdestruct();
      case COMMAND.eatdream:
        return yield* this.drainTarget(BATTLE.DreamEatenText);
      case COMMAND.freezetarget:
        return yield* this.freezeTarget();
      case COMMAND.tristatuschance:
        return yield* this.triStatusChance();
      case COMMAND.defrost:
        return yield* this.defrostUser();
      case COMMAND.confusetarget:
        return yield* this.confuseTarget();
      case COMMAND.getmagnitude:
        return yield* this.getMagnitude();
      case COMMAND.present:
        return yield* this.present();
      case COMMAND.hiddenpower:
        return this.hiddenPower();
      case COMMAND.happinesspower:
        // BattleCommand_HappinessPower: happiness × 10 / 25, so a
        // Pokémon below 3 happiness deals no damage (a kept bug).
        this.damageArgs.power = Math.floor((this.user.mon.happiness * 10) / 25) & 0xff;
        return;
      case COMMAND.frustrationpower:
        this.damageArgs.power = Math.floor(((0xff - this.user.mon.happiness) * 10) / 25) & 0xff;
        return;
      case COMMAND.falseswipe:
        this.falseSwipe();
        return;
      case COMMAND.doubleundergrounddamage:
        if (this.target.has(SUB3, C.SUBSTATUS_UNDERGROUND)) this.curDamage = Math.min(0xffff, this.curDamage * 2);
        return;
      case COMMAND.doubleminimizedamage:
        if (this.target.minimized) this.curDamage = Math.min(0xffff, this.curDamage * 2);
        return;
      case COMMAND.thunderaccuracy:
        // Overwrites the move's accuracy; rain's 100% is redundant with
        // CheckHit's own rain check.
        if (this.weather === C.WEATHER_RAIN) this.user.move.accuracy = 0xff;
        else if (this.weather === C.WEATHER_SUN) this.user.move.accuracy = percent(50) + 1;
        return;
      case COMMAND.fakeout:
        return this.fakeOut();
      case COMMAND.checkcharge:
        return this.checkCharge();
      case COMMAND.charge:
        return yield* this.charge();
      case COMMAND.skipsuncharge:
        // A sunny day skips the charging turn.
        if (this.weather === C.WEATHER_SUN) this.skipTo(COMMAND.charge);
        return;
      case COMMAND.rechargenextturn:
        this.user.set(SUB4, C.SUBSTATUS_RECHARGE);
        return;
      case COMMAND.checkrampage:
        return this.checkRampage();
      case COMMAND.rampage:
        return this.rampage();
      case COMMAND.checkrollout:
        return this.checkRollout();
      case COMMAND.rolloutpower:
        return this.rolloutPower();
      case COMMAND.furycutter:
        return this.furyCutter();
      case COMMAND.storeenergy:
        return yield* this.storeEnergy();
      case COMMAND.unleashenergy:
        return this.unleashEnergy();
      case COMMAND.bidefailtext:
        if (!this.attackMissed) return;
        return yield* this.say(this.typeModifier & C.EFFECTIVENESS_MASK ? BATTLE.ButItFailedText : BATTLE.DoesntAffectText);
      case COMMAND.traptarget:
        return yield* this.trapTarget();
      case COMMAND.lockon:
        return yield* this.lockOn();
      case COMMAND.leechseed:
        return yield* this.leechSeed();
      case COMMAND.nightmare:
        return yield* this.nightmare();
      case COMMAND.curse:
        return yield* this.curse();
      case COMMAND.destinybond:
        this.user.set(SUB5, C.SUBSTATUS_DESTINY_BOND);
        return yield* this.say(BATTLE.DestinyBondEffectText);
      case COMMAND.protect:
      case COMMAND.endure:
        return yield* this.protect(command === COMMAND.endure);
      case COMMAND.spite:
        return yield* this.spite();
      case COMMAND.healbell:
        return yield* this.healBell();
      case COMMAND.disable:
        return yield* this.disable();
      case COMMAND.encore:
        return yield* this.encore();
      case COMMAND.attract:
        return yield* this.attract();
      case COMMAND.mist:
      case COMMAND.focusenergy: {
        const mist = command === COMMAND.mist,
          bit = mist ? C.SUBSTATUS_MIST : C.SUBSTATUS_FOCUS_ENERGY;
        if (this.user.has(SUB4, bit)) return yield* this.say(BATTLE.ButItFailedText);
        this.user.set(SUB4, bit);
        return yield* this.say(mist ? BATTLE.MistText : BATTLE.GettingPumpedText);
      }
      case COMMAND.resetstats:
        return yield* this.resetStats();
      case COMMAND.heal:
        return yield* this.heal();
      case COMMAND.arenatrap:
        // Mean Look marks the user: its opponent can't run or switch.
        if (this.hiddenOpponent() || this.user.has(SUB5, C.SUBSTATUS_CANT_RUN))
          return yield* this.say(BATTLE.ButItFailedText);
        this.user.set(SUB5, C.SUBSTATUS_CANT_RUN);
        return yield* this.say(BATTLE.CantEscapeNowText);
      case COMMAND.painsplit:
        return yield* this.painSplit();
      case COMMAND.bellydrum:
        return yield* this.bellyDrum();
      case COMMAND.psychup:
        return yield* this.psychUp();
      case COMMAND.safeguard: {
        const user = this.user;
        if (user.screens & (1 << C.SCREENS_SAFEGUARD)) return yield* this.say(BATTLE.ButItFailedText);
        user.screens |= 1 << C.SCREENS_SAFEGUARD;
        user.safeguardCount = 5;
        return yield* this.say(BATTLE.CoveredByVeilText);
      }
      case COMMAND.perishsong:
        return yield* this.perishSong();
      case COMMAND.spikes: {
        // Spikes go on the target's side.
        const target = this.target;
        if (target.screens & (1 << C.SCREENS_SPIKES)) return yield* this.failMove();
        target.screens |= 1 << C.SCREENS_SPIKES;
        return yield* this.say(BATTLE.SpikesText);
      }
      case COMMAND.clearhazards:
        return yield* this.clearHazards();
      case COMMAND.allstatsup:
        // AncientPower: each stat in turn, without a failure text.
        for (let stat = C.ATTACK; stat <= C.SP_DEFENSE; stat++) {
          this.attackMissed = 0;
          this.statUp(stat);
          yield* this.statUpMessage();
        }
        return;
      case COMMAND.checkfuturesight:
        return this.checkFutureSight();
      case COMMAND.futuresight:
        return yield* this.futureSight();
      case COMMAND.pursuit:
        // Double damage against a Pokémon being withdrawn.
        if (this.turn === 0 ? this.enemyIsSwitching : this.playerIsSwitching)
          this.curDamage = Math.min(0xffff, this.curDamage * 2);
        return;
      case COMMAND.failuretext:
        return yield* this.failureText();
      case COMMAND.applydamage:
        return yield* this.applyDamage();
      case COMMAND.criticaltext:
        return yield* this.criticalText();
      case COMMAND.supereffectivetext:
        return yield* this.superEffectiveText();
      case COMMAND.checkfaint:
        return yield* this.checkFaint();
      case COMMAND.buildopponentrage:
        return yield* this.buildOpponentRage();
      case COMMAND.kingsrock:
        return this.kingsRock();
      case COMMAND.poisontarget:
        return yield* this.poisonTarget();
      case COMMAND.burntarget:
        return yield* this.burnTarget();
      case COMMAND.paralyzetarget:
        return yield* this.paralyzeTarget();
      case COMMAND.flinchtarget:
        return this.flinchTarget();
      case COMMAND.sleeptarget:
        return yield* this.sleepTarget();
      case COMMAND.poison:
        return yield* this.poisonCommand();
      case COMMAND.paralyze:
        return yield* this.paralyzeCommand();
      case COMMAND.confuse:
        return yield* this.confuseCommand();
      case COMMAND.draintarget:
        return yield* this.drainTarget();
      case COMMAND.recoil:
        return yield* this.recoil();
      case COMMAND.checksafeguard:
        return yield* this.checkSafeguard();
      case COMMAND.splash:
        return yield* this.say(BATTLE.NothingHappenedText);
      case COMMAND.foresight:
        return yield* this.foresight();
      case COMMAND.rage:
        return this.user.set(SUB4, C.SUBSTATUS_RAGE);
      case COMMAND.ragedamage:
        return this.rageDamage();
      case COMMAND.screen:
        return yield* this.screen();
      case COMMAND.curl:
        return this.user.set(SUB2, C.SUBSTATUS_CURLED);
      case COMMAND.doubleflyingdamage:
        if (this.target.has(SUB3, C.SUBSTATUS_FLYING)) this.curDamage = Math.min(0xffff, this.curDamage * 2);
        return;
      case COMMAND.clearmissdamage:
        if (this.attackMissed) this.curDamage = 0;
        return;
      case COMMAND.switchturn:
        this.turn ^= 1;
        return;
      case COMMAND.healmorn:
      case COMMAND.healday:
      case COMMAND.healnite:
        return yield* this.timeBasedHeal(command - COMMAND.healmorn);
      case COMMAND.statupmessage:
        return yield* this.statUpMessage();
      case COMMAND.statdownmessage:
        return yield* this.statDownMessage();
      case COMMAND.statupfailtext:
        return yield* this.statUpFailText();
      case COMMAND.statdownfailtext:
        return yield* this.statDownFailText();
      default:
        if (command >= COMMAND.attackup && command <= COMMAND.evasionup2) {
          const stat = (command - COMMAND.attackup) % 7;
          return this.statUp(stat | (command >= COMMAND.attackup2 ? 0x10 : 0));
        }
        if (command >= COMMAND.attackdown && command <= COMMAND.evasiondown2) {
          const stat = (command - COMMAND.attackdown) % 7;
          return this.statDown(stat | (command >= COMMAND.attackdown2 ? 0x10 : 0));
        }
        throw new UnsupportedBattle(`Battle command 0x${command.toString(16)} is not ported.`);
    }
  }
  /** Substitute presentation is only safe once substitutes exist. */
  private requireNoSubstitute() {
    if (this.user.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || this.target.has(SUB4, C.SUBSTATUS_SUBSTITUTE))
      throw new UnsupportedBattle("Substitutes are not ported yet.");
  }

  /** BattleCommand_CheckObedience: only foreign Pokémon may disobey. */
  private checkObedience() {
    if (this.turn !== 0 || this.user.charging || this.alreadyDisobeyed) return;
    if (this.partyMon.otId !== this.options.playerId)
      throw new UnsupportedBattle("Traded Pokémon obedience is not ported yet.");
  }
  /** BattleCommand_DoTurn: count the turn and use one PP. */
  private *doTurnCommand(): Gen {
    const user = this.user;
    if (user.charging) return;
    user.turnsTaken = (user.turnsTaken + 1) & 0xff;
    if (user.curMove === C.STRUGGLE) return;
    if (user.sub[SUB3] & ((1 << C.SUBSTATUS_IN_LOOP) | (1 << C.SUBSTATUS_RAMPAGE) | (1 << C.SUBSTATUS_BIDE)))
      return;
    const slot = user.moveNum;
    if (!(user.mon.pp[slot] & C.PP_MASK)) {
      const continuous = [
        C.EFFECT_RAZOR_WIND,
        C.EFFECT_SKY_ATTACK,
        C.EFFECT_SKULL_BASH,
        C.EFFECT_SOLARBEAM,
        C.EFFECT_FLY,
        C.EFFECT_ROLLOUT,
        C.EFFECT_BIDE,
        C.EFFECT_RAMPAGE,
      ] as number[];
      yield* this.say(continuous.includes(user.move.effect) ? BATTLE.HasNoPPLeftText : BATTLE.NoPPLeftText);
      return this.endMoveEffect();
    }
    user.mon.pp[slot]--;
    if (user.has(SUB5, C.SUBSTATUS_TRANSFORMED)) return;
    // The party struct loses the PP too, or a wild Pokémon's wWildMonPP,
    // which it keeps if caught; not for a move learnt by Mimic
    // (CheckMimicUsed).
    const party =
      this.turn === 0
        ? this.partyMon
        : this.battleMode !== C.WILD_BATTLE
          ? this.options.trainer!.party[this.curOTMon]
          : undefined;
    if (party) {
      if (user.curMove !== C.MIMIC && party.moves[slot] === C.MIMIC) return;
      this.consumePP(party.pp, slot);
    } else {
      if (user.mon.moves[slot] !== C.MIMIC && this.wildMoves[slot] === C.MIMIC) return;
      this.consumePP(this.wildPP, slot);
    }
  }
  /** DoTurn's .consume_pp on a party struct, which keeps step with the
   * battle struct here. */
  private consumePP(pp: number[], slot: number) {
    if (!(pp[slot] & C.PP_MASK)) throw new UnsupportedBattle("Party PP out of step with the battle's.");
    pp[slot]--;
  }

  private critical() {
    this.criticalHit = 0;
    const user = this.user,
      mon = user.mon;
    if (!user.move.power) return;
    let stage = 0;
    if (mon.species === C.CHANSEY && mon.item === C.LUCKY_PUNCH) stage = 2;
    else if (mon.species === C.FARFETCH_D && mon.item === C.STICK) stage = 2;
    else {
      if (user.has(SUB4, C.SUBSTATUS_FOCUS_ENERGY)) stage++;
      if (this.data.byteList(BATTLE.CriticalHitMoves).includes(user.move.anim)) stage += 2;
      if (this.data.heldEffect(mon.item).effect === C.HELD_CRITICAL_UP) stage++;
    }
    if (this.random() < this.data.criticalChance(stage)) this.criticalHit = 1;
  }

  /** BattleCommand_Screen: a repeated screen fails without renewing it. */
  private *screen(): Gen {
    const side = this.user;
    const light = side.move.effect === C.EFFECT_LIGHT_SCREEN;
    const bit = 1 << (light ? C.SCREENS_LIGHT_SCREEN : C.SCREENS_REFLECT);
    if (side.screens & bit) return yield* this.say(BATTLE.ButItFailedText);
    side.screens |= bit;
    if (light) side.lightScreenCount = 5;
    else side.reflectCount = 5;
    yield* this.say(light ? BATTLE.LightScreenEffectText : BATTLE.ReflectEffectText);
  }

  /** HandleScreens, in non-Link order. Screens belong to the side and
   * survive a send-out; their setup turn is the first of five ticks. */
  private *handleScreens(): Gen {
    for (const [turn, side] of [this.player, this.enemy].entries()) {
      this.turn = turn;
      this.strings[RAM.stringBuffer1] = turn === 0 ? "Your" : "Enemy";
      if (side.screens & (1 << C.SCREENS_LIGHT_SCREEN)) {
        side.lightScreenCount = (side.lightScreenCount - 1) & 0xff;
        if (!side.lightScreenCount) {
          side.screens &= ~(1 << C.SCREENS_LIGHT_SCREEN);
          yield* this.say(BATTLE.BattleText_MonsLightScreenFell);
        }
      }
      if (side.screens & (1 << C.SCREENS_REFLECT)) {
        side.reflectCount = (side.reflectCount - 1) & 0xff;
        if (!side.reflectCount) {
          side.screens &= ~(1 << C.SCREENS_REFLECT);
          yield* this.say(BATTLE.BattleText_MonsReflectFaded);
        }
      }
    }
  }

  private damageArgs = { power: 0, level: 0, attack: 0, defense: 0 };
  /** PlayerAttackDamage / EnemyAttackDamage. */
  private damageStats() {
    this.curDamage = 0;
    const user = this.user,
      target = this.target,
      power = user.move.power;
    this.damageArgs.power = power;
    if (!power) return;
    const special = user.move.type >= C.SPECIAL;
    const stat = special ? C.SP_ATTACK : C.ATTACK,
      defenseStat = special ? C.SP_DEFENSE : C.DEFENSE;
    const screen = special ? C.SCREENS_LIGHT_SCREEN : C.SCREENS_REFLECT;
    // Criticals ignore stages when the target's are at least as high.
    const unboosted =
      this.criticalHit && target.levels[defenseStat] >= user.levels[stat];
    let attack: number, defense: number;
    if (unboosted) {
      attack = user.stats[stat];
      defense = target.stats[defenseStat];
    } else {
      attack = user.mon.stats[stat];
      defense = target.mon.stats[defenseStat];
      if (target.screens & (1 << screen)) defense = (defense * 2) & 0xffff;
    }
    attack = this.speciesItemBoost(attack, special);
    [attack, defense] = this.truncate(attack, defense);
    // DittoMetalPowder boosts the defender's Defense.
    if (target.mon.species === C.DITTO && target.mon.item === C.METAL_POWDER)
      throw new UnsupportedBattle("Metal Powder is not ported yet.");
    this.damageArgs = { power, level: user.mon.level, attack, defense };
  }
  /** ThickClubBoost / LightBallBoost. */
  private speciesItemBoost(attack: number, special: boolean) {
    const mon = this.user.mon;
    const boosted = special
      ? mon.species === C.PIKACHU && mon.item === C.LIGHT_BALL
      : (mon.species === C.CUBONE || mon.species === C.MAROWAK) && mon.item === C.THICK_CLUB;
    return boosted ? (attack * 2) & 0xffff : attack;
  }
  /** TruncateHL_BC: scale both stats down by 4 until they fit a byte. */
  private truncate(attack: number, defense: number): [number, number] {
    while (attack > 0xff || defense > 0xff) {
      defense = defense >> 2 || 1;
      attack = attack >> 2 || 1;
    }
    return [attack, defense];
  }
  private damageCalcCommand() {
    const { power, level, attack, defense } = this.damageArgs;
    this.damageCalc(power, level, attack, defense);
  }
  /** BattleCommand_DamageCalc. */
  private damageCalc(power: number, level: number, attack: number, defense: number) {
    const held = this.data.heldEffect(this.user.mon.item);
    const boost =
      held.effect && this.data.typeBoost(held.effect) === this.user.move.type ? held.parameter : undefined;
    const damage = calculateDamage({
      power,
      level,
      attack,
      defense,
      effect: this.user.move.effect,
      critical: Boolean(this.criticalHit),
      boost,
      current: this.curDamage,
    });
    if (damage !== undefined) this.curDamage = damage;
  }

  /** BattleCommand_Stab, including type effectiveness. */
  private stab() {
    const user = this.user,
      target = this.target;
    if (user.move.anim === C.STRUGGLE) return;
    if (this.weather) throw new UnsupportedBattle("Weather is not ported yet.");
    const result = applyTypeMatchups(this.matchups, {
      damage: this.curDamage,
      modifier: this.typeModifier,
      moveType: user.move.type,
      userTypes: user.mon.types,
      targetTypes: target.mon.types,
      identified: target.has(SUB1, C.SUBSTATUS_IDENTIFIED),
    });
    this.curDamage = result.damage;
    this.typeModifier = result.modifier;
    this.matchup = result.matchup;
    if (result.missed) this.attackMissed = 1;
  }
  /** BattleCheckTypeMatchup: wTypeMatchup for the move against the target. */
  private battleCheckTypeMatchup() {
    const target = this.target;
    return (this.matchup = this.typeMatchup(this.user.move.type, target.mon.types, target.has(SUB1, C.SUBSTATUS_IDENTIFIED)));
  }
  /** BattleCommand_ResetTypeMatchup: an immune target makes the move miss;
   * otherwise wTypeMatchup becomes EFFECTIVE. Returns wTypeMatchup. */
  private resetTypeMatchup() {
    if (this.battleCheckTypeMatchup()) return (this.matchup = C.EFFECTIVE);
    this.curDamage = 0;
    this.typeModifier = 0;
    this.attackMissed = 1;
    return 0;
  }
  /** BattleCommand_DamageVariation: 217-255 / 255. */
  private damageVariation() {
    if (this.curDamage < 2) return;
    let multiplier: number;
    do {
      const r = this.random();
      multiplier = ((r >> 1) | ((r & 1) << 7)) & 0xff;
    } while (multiplier < percent(85) + 1);
    this.curDamage = Math.floor((this.curDamage * multiplier) / 255) & 0xffff;
  }

  /** BattleCommand_CheckHit. */
  private *checkHit(): Gen {
    const user = this.user,
      target = this.target,
      effect = user.move.effect;
    const miss = () => {
      if (effect !== C.EFFECT_JUMP_KICK) this.curDamage = 0;
      this.attackMissed = 1;
    };
    if (effect === C.EFFECT_DREAM_EATER && !(target.mon.status & C.SLP_MASK)) return miss();
    if (target.has(SUB1, C.SUBSTATUS_PROTECT)) {
      yield* this.say(BATTLE.ProtectingItselfText);
      return miss();
    }
    if (target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) && (effect === C.EFFECT_LEECH_HIT || effect === C.EFFECT_DREAM_EATER))
      return miss();
    // .LockOn: a locked-on target is hit, unless it is flying from an
    // Earthquake, Fissure or Magnitude; the lock is spent either way.
    const anim = user.move.anim,
      groundMoves: number[] = [C.EARTHQUAKE, C.FISSURE, C.MAGNITUDE];
    if (target.has(SUB5, C.SUBSTATUS_LOCK_ON)) {
      target.reset(SUB5, C.SUBSTATUS_LOCK_ON);
      if (!(target.has(SUB3, C.SUBSTATUS_FLYING) && groundMoves.includes(anim))) return;
    }
    // .FlyDigMoves
    if (target.has(SUB3, C.SUBSTATUS_FLYING)) {
      if (!([C.GUST, C.WHIRLWIND, C.THUNDER, C.TWISTER] as number[]).includes(anim)) return miss();
    } else if (target.has(SUB3, C.SUBSTATUS_UNDERGROUND) && !groundMoves.includes(anim)) return miss();
    if (effect === C.EFFECT_THUNDER && this.weather === C.WEATHER_RAIN) return;
    if (user.has(SUB4, C.SUBSTATUS_X_ACCURACY)) return;
    if (effect === C.EFFECT_ALWAYS_HIT) return;
    this.statModifiers();
    let accuracy = user.move.accuracy;
    const opponentItem = this.data.heldEffect(target.mon.item);
    if (opponentItem.effect === C.HELD_BRIGHTPOWDER) accuracy = Math.max(0, accuracy - opponentItem.parameter);
    if (accuracy === 0xff) return;
    if (this.random() >= accuracy) miss();
  }
  /** CheckHit.StatModifiers: accuracy and evasion stages on the move. */
  private statModifiers() {
    const user = this.user,
      target = this.target;
    const accuracyLevel = user.levels[C.ACCURACY],
      evasionLevel = target.levels[C.EVASION];
    if (evasionLevel >= accuracyLevel && target.has(SUB1, C.SUBSTATUS_IDENTIFIED)) return;
    let value = user.move.accuracy;
    for (const level of [accuracyLevel, C.MAX_STAT_LEVEL + 1 - evasionLevel]) {
      const [numerator, denominator] = this.data.accuracyMultiplier(level);
      value = Math.floor((value * numerator) / denominator) || 1;
    }
    user.move.accuracy = value > 0xff ? 0xff : value;
  }
  private effectChance() {
    this.effectFailed = 0;
    if (this.target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || !(this.random() < this.user.move.chance))
      this.effectFailed = 1;
  }

  /** BattleCommand_FailureText. */
  private *failureText(): Gen {
    if (!this.attackMissed) return;
    yield* this.getFailureResultText();
    const user = this.user;
    if (user.move.anim === C.FLY || user.move.anim === C.DIG) {
      user.reset(SUB3, C.SUBSTATUS_UNDERGROUND);
      user.reset(SUB3, C.SUBSTATUS_FLYING);
      this.requireNoSubstitute(); // AppearUserRaiseSub
      return this.endMoveEffect();
    }
    // Multi-hit moves other than Triple Kick and Beat Up raise the
    // substitute again (Beat Up not doing so is a kept bug).
    const effect = user.move.effect;
    if (effect === C.EFFECT_MULTI_HIT || effect === C.EFFECT_DOUBLE_HIT || effect === C.EFFECT_POISON_MULTI_HIT)
      this.requireNoSubstitute();
    this.endMoveEffect();
  }
  private *getFailureResultText(): Gen {
    let text: number = BATTLE.DoesntAffectText,
      protectedText: number = BATTLE.DoesntAffectText;
    if (this.typeModifier & C.EFFECTIVENESS_MASK) {
      if (this.user.move.effect === C.EFFECT_FUTURE_SIGHT) {
        text = BATTLE.ButItFailedText;
        protectedText = BATTLE.ItFailedText;
      } else {
        text = BATTLE.AttackMissedText;
        protectedText = BATTLE.AttackMissed2Text;
        if (this.criticalHit === 0xff) text = BATTLE.UnaffectedText;
      }
    }
    yield* this.say(this.target.has(SUB1, C.SUBSTATUS_PROTECT) ? protectedText : text);
    this.criticalHit = 0;
    if (this.user.move.effect !== C.EFFECT_JUMP_KICK || !(this.typeModifier & C.EFFECTIVENESS_MASK)) return;
    // (Hi) Jump Kick crashes for an eighth of the damage it would have
    // dealt, at least 1, ignoring the user's substitute.
    this.curDamage = this.curDamage >> 3 || 1;
    yield* this.say(BATTLE.CrashedText);
    this.doDamage(this.user, true);
    yield this.hud();
  }

  /** BattleCommand_ApplyDamage. */
  private *applyDamage(): Gen {
    const target = this.target;
    let hungOn = 0;
    const item = this.data.heldEffect(target.mon.item);
    if (target.has(SUB1, C.SUBSTATUS_ENDURE)) hungOn = this.falseSwipe() ? 1 : 0;
    else if (item.effect === C.HELD_FOCUS_BAND && this.random() < item.parameter)
      hungOn = this.falseSwipe() ? 2 : 0;
    if (!target.has(SUB4, C.SUBSTATUS_SUBSTITUTE))
      target.damageTaken = Math.min(0xffff, target.damageTaken + this.curDamage);
    this.doDamage(target, false);
    yield this.hud();
    if (hungOn === 1) yield* this.say(BATTLE.EnduredText);
    if (hungOn === 2) {
      this.strings[RAM.stringBuffer1] = this.options.data.itemName(target.mon.item);
      yield* this.say(BATTLE.HungOnText);
    }
  }
  /** BattleCommand_FalseSwipe: a hit that would faint leaves 1 HP (no
   * damage at all against 1 HP) and is no longer a one-hit KO. Returns
   * true (carry) when it changed the damage. */
  private falseSwipe(): boolean {
    const hp = this.target.mon.hp;
    if (this.curDamage < hp) return false;
    this.curDamage = (hp - 1) & 0xffff;
    if (this.criticalHit === 2) this.criticalHit = 0;
    return true;
  }
  /** DoEnemyDamage / DoPlayerDamage. */
  private doDamage(side: Side, ignoreSubstitute: boolean) {
    if (!this.curDamage) return;
    if (!ignoreSubstitute && side.has(SUB4, C.SUBSTATUS_SUBSTITUTE))
      throw new UnsupportedBattle("Substitutes are not ported yet.");
    const hp = side.mon.hp;
    if (this.curDamage > hp) this.curDamage = hp;
    side.mon.hp = hp - this.curDamage;
    if (side === this.player) this.updateBattleMonInParty();
  }
  private *criticalText(): Gen {
    if (!this.criticalHit) return;
    yield* this.say(this.criticalHit === 1 ? BATTLE.CriticalHitText : BATTLE.OneHitKOText);
    this.criticalHit = 0;
  }
  private *superEffectiveText(): Gen {
    const effectiveness = this.typeModifier & C.EFFECTIVENESS_MASK;
    if (effectiveness === C.EFFECTIVE) return;
    yield* this.say(effectiveness > C.EFFECTIVE ? BATTLE.SuperEffectiveText : BATTLE.NotVeryEffectiveText);
  }
  /** BattleCommand_CheckFaint: end the move if the target fainted. */
  private *checkFaint(): Gen {
    if (this.target.mon.hp) return;
    if (this.target.has(SUB5, C.SUBSTATUS_DESTINY_BOND)) {
      // The user faints too, and the move ends there.
      yield* this.say(BATTLE.TookDownWithItText);
      this.user.mon.hp = 0;
      yield this.hud();
      return this.endMoveEffect();
    }
    // A multi-hit move stops here, without "Hit n times!" and with
    // SUBSTATUS_IN_LOOP still set; the faint handlers clear it.
    const effect = this.user.move.effect;
    if ([C.EFFECT_MULTI_HIT, C.EFFECT_DOUBLE_HIT, C.EFFECT_POISON_MULTI_HIT, C.EFFECT_TRIPLE_KICK, C.EFFECT_BEAT_UP].includes(effect as never))
      this.requireNoSubstitute(); // BattleCommand_RaiseSub
    this.endMoveEffect();
  }
  private *buildOpponentRage(): Gen {
    if (this.attackMissed) return;
    const target = this.target;
    if (!target.has(SUB4, C.SUBSTATUS_RAGE)) return;
    if (target.rageCounter === 0xff) return;
    target.rageCounter++;
    this.turn ^= 1;
    yield* this.say(BATTLE.RageBuildingText);
    this.turn ^= 1;
  }
  private rageDamage() {
    let damage = this.curDamage;
    for (let count = this.user.rageCounter; count > 0; count--) {
      damage += this.curDamage;
      if (damage > 0xffff) {
        damage = 0xffff;
        break;
      }
    }
    this.curDamage = damage;
  }
  /** BattleCommand_MoveAnimNoSub's effect on wBattleAnimParam: multi-hit
   * moves alternate it, Triple Kick keeps its kick count, others clear it. */
  private moveAnimNoSub() {
    if (this.attackMissed) return;
    const effect = this.user.move.effect;
    if (effect === C.EFFECT_MULTI_HIT || effect === C.EFFECT_CONVERSION || effect === C.EFFECT_DOUBLE_HIT || effect === C.EFFECT_POISON_MULTI_HIT)
      this.animParam = (this.animParam & 1) ^ 1;
    else if (effect !== C.EFFECT_TRIPLE_KICK) this.animParam = 0;
  }

  // ------------------------------------------------------ multi-hit moves

  /** BattleCommand_EndLoop. The first pass draws the extra hits into the
   * user's rollout count and the total into the high byte of its
   * wDamageTaken, which "Hit n times!" prints; later passes count down.
   * Each repeat resumes at the script's `critical`. */
  private *endLoop(): Gen {
    const user = this.user,
      effect = user.move.effect;
    if (user.has(SUB3, C.SUBSTATUS_IN_LOOP)) {
      user.rolloutCount = (user.rolloutCount - 1) & 0xff;
      if (user.rolloutCount) return this.loopBackToCritical();
      return yield* this.doneLoop();
    }
    user.set(SUB3, C.SUBSTATUS_IN_LOOP);
    let extra: number;
    if (effect === C.EFFECT_POISON_MULTI_HIT || effect === C.EFFECT_DOUBLE_HIT) extra = 1;
    else if (effect === C.EFFECT_BEAT_UP) {
      const count =
        this.turn === 0
          ? this.options.party.length
          : this.battleMode === C.WILD_BATTLE
            ? 1
            : this.options.trainer!.party.length;
      if (count === 1) {
        // .only_one_beatup: no raisesub or King's Rock (a kept bug).
        user.reset(SUB3, C.SUBSTATUS_IN_LOOP);
        yield* this.beatUpFailText();
        return this.endMoveEffect();
      }
      extra = count - 1;
    } else if (effect === C.EFFECT_TRIPLE_KICK) {
      let kicks: number;
      do kicks = this.random() & 3;
      while (!kicks);
      if (kicks === 1) {
        this.setHitCount(user, 1);
        return yield* this.doneLoop();
      }
      extra = kicks - 1;
    } else {
      // Two or three hits, or a second draw for two to five.
      let draw = this.random() & 3;
      if (draw >= 2) draw = this.random() & 3;
      extra = draw + 1;
    }
    user.rolloutCount = extra;
    this.setHitCount(user, extra + 1);
    this.loopBackToCritical();
  }
  private setHitCount(side: Side, hits: number) {
    side.damageTaken = ((hits & 0xff) << 8) | (side.damageTaken & 0xff);
  }
  /** EndLoop's .done_loop: the hit count text (not for Beat Up), then the
   * high byte of wDamageTaken is cleared. */
  private *doneLoop(): Gen {
    const user = this.user;
    user.reset(SUB3, C.SUBSTATUS_IN_LOOP);
    if (user.move.effect !== C.EFFECT_BEAT_UP) {
      this.numbers[this.turn === 0 ? RAM.playerDamageTaken : RAM.enemyDamageTaken] = user.damageTaken >> 8;
      yield* this.say(this.turn === 0 ? BATTLE.PlayerHitTimesText : BATTLE.EnemyHitTimesText);
    }
    user.damageTaken &= 0xff;
  }
  /** EndLoop's .loop_back_to_critical: search back for `critical`. */
  private loopBackToCritical() {
    let index = this.scriptIndex;
    while (index >= 0 && this.script[index] !== COMMAND.critical) index--;
    if (index < 0) throw new UnsupportedBattle("Multi-hit script has no critical command.");
    this.scriptIndex = index;
  }
  /** BattleCommand_BeatUp: the next party member's base Attack and level
   * against the target's base Defense. A fainted or statused member skips
   * to after buildopponentrage. Wild Pokémon hit with their own stats but
   * never count a hit, so "But it failed!" follows (a kept bug). */
  private *beatUp(): Gen {
    this.curDamage = 0;
    const user = this.user,
      data = this.options.data;
    const player = this.turn === 0,
      party = player ? this.options.party : this.options.trainer?.party;
    if (!user.has(SUB3, C.SUBSTATUS_IN_LOOP)) {
      user.rolloutCount = 0;
      this.beatUpMon = 0;
      this.beatUpHit = 0;
    } else {
      const count = player ? this.options.party.length : this.options.trainer!.party.length;
      this.beatUpMon = (count - user.rolloutCount) & 0xff;
    }
    if (!party) {
      this.strings[RAM.stringBuffer1] = data.speciesName(this.enemy.mon.species);
      yield* this.say(BATTLE.BeatUpAttackText);
      return this.damageStats(); // EnemyAttackDamage
    }
    const mon = party[this.beatUpMon];
    if (!mon) throw new UnsupportedBattle("Beat Up ran past the party.");
    if (party.some((member) => member.species === C.EGG))
      throw new UnsupportedBattle("Beat Up with an Egg in the party is not ported yet.");
    // The player's members go by nickname, a trainer's by species name.
    this.strings[RAM.stringBuffer1] = player ? mon.nickname : data.speciesName(mon.species);
    const skip = () => this.skipTo(COMMAND.buildopponentrage);
    if (!mon.hp) return skip();
    // The player's side takes the battle status when wCurBattleMon equals
    // the member's HP low byte rather than its index (a kept bug).
    const active = player ? this.curBattleMon === (mon.hp & 0xff) : this.curOTMon === this.beatUpMon;
    if ((active ? user.mon.status : mon.status) !== 0) return skip();
    this.beatUpHit = 1;
    yield* this.say(BATTLE.BeatUpAttackText);
    this.damageArgs = {
      power: user.move.power,
      level: mon.level,
      attack: data.baseData(mon.species).stats[C.ATTACK + 1],
      defense: data.baseData(this.target.mon.species).stats[C.DEFENSE + 1],
    };
  }
  /** BattleCommand_BeatUpFailText. */
  private *beatUpFailText(): Gen {
    if (!this.beatUpHit) yield* this.say(BATTLE.ButItFailedText);
  }

  // ------------------------------------------------- special damage moves

  /** BattleCommand_ConstantDamage: the level, the move's power, Psywave's
   * random damage below 1.5 × level, half the target's HP, or Flail and
   * Reversal's power from the user's HP bar. */
  private constantDamage() {
    const user = this.user,
      level = user.mon.level;
    switch (user.move.effect) {
      case C.EFFECT_LEVEL_DAMAGE:
        this.curDamage = level;
        return;
      case C.EFFECT_PSYWAVE: {
        const limit = (level + (level >> 1)) & 0xff;
        // A limit of 1 or less loops forever in the original.
        if (limit <= 1) throw new UnsupportedBattle("Psywave at this level freezes the original.");
        for (let attempt = 0; attempt < 4096; attempt++) {
          const damage = this.random();
          if (damage && damage < limit) {
            this.curDamage = damage;
            return;
          }
        }
        throw new UnsupportedBattle("Psywave random source did not produce damage.");
      }
      case C.EFFECT_SUPER_FANG:
        this.curDamage = this.target.mon.hp >> 1 || 1;
        return;
      case C.EFFECT_REVERSAL:
        return this.reversalDamage();
      default:
        this.curDamage = user.move.power;
    }
  }
  /** ConstantDamage's .reversal: HP bar pixels (HP × 48 / max HP, scaled
   * down by 4 when max HP has a high byte) pick FlailReversalPower's power
   * for a normal damage calculation, then the move's power becomes 1. */
  private reversalDamage() {
    const user = this.user,
      { hp, maxHp } = user.mon;
    let dividend = hp * 48,
      divisor = maxHp & 0xff;
    if (maxHp >> 8) {
      divisor = (maxHp >> 2) & 0xff;
      dividend = (dividend >> 2) & 0xffff;
    }
    if (!divisor) throw new UnsupportedBattle("Reversal divides by zero.");
    const pixels = Math.floor(dividend / divisor) & 0xff;
    let p = BATTLE.FlailReversalPower;
    while (this.reader.byte(p) < pixels) p += 2;
    user.move.power = this.reader.byte(p + 1);
    this.damageStats();
    this.damageCalcCommand();
    user.move.power = 1;
  }
  /** BattleCommand_OHKO: fails against a higher level; otherwise each
   * level of difference adds 2 to the accuracy before CheckHit. */
  private *ohko(): Gen {
    this.curDamage = 0;
    const user = this.user,
      difference = user.mon.level - this.target.mon.level;
    if (!(this.typeModifier & C.EFFECTIVENESS_MASK) || difference < 0) {
      this.criticalHit = 0xff; // "is unaffected!"
      this.attackMissed = 1;
      return;
    }
    user.move.accuracy = Math.min(0xff, user.move.accuracy + ((difference * 2) & 0xff));
    yield* this.checkHit();
    this.curDamage = 0xffff;
    this.criticalHit = 2;
  }
  /** BattleCommand_Counter and BattleCommand_MirrorCoat: twice the damage
   * of the opponent's last physical (special) move, if the opponent moved
   * first. wCurDamage still holds that damage, even after the opponent
   * used an item instead (a kept bug). */
  private counter(special: boolean) {
    this.attackMissed = 1;
    const data = this.options.data,
      last = this.target.lastCounterMove;
    if (!last) return;
    const move = data.move(last);
    if (move.effect === (special ? C.EFFECT_MIRROR_COAT : C.EFFECT_COUNTER)) return;
    if (!this.resetTypeMatchup()) return;
    if (!(this.enemyGoesFirst ^ this.turn)) return;
    if (!move.power || move.type >= C.SPECIAL !== special) return;
    if (!this.curDamage) return;
    this.curDamage = Math.min(0xffff, this.curDamage * 2);
    this.attackMissed = 0;
  }
  /** BattleCommand_GetMagnitude: MagnitudePower's power for damagecalc. */
  private *getMagnitude(): Gen {
    const roll = this.random();
    let p = BATTLE.MagnitudePower;
    while (this.reader.byte(p) < roll) p += 3;
    this.damageArgs.power = this.reader.byte(p + 1);
    this.numbers[RAM.textDecimalByte] = this.reader.byte(p + 2);
    yield* this.say(BATTLE.MagnitudeText);
  }
  /** BattleCommand_Present: a PresentPower power for damagecalc, or a
   * quarter of the target's maximum HP as a gift. A target at full HP
   * refuses it, which is only said with battle animations off. */
  private *present(): Gen {
    this.stab();
    if (!this.matchup || this.attackMissed) return;
    const roll = this.random(),
      r = this.reader;
    let p = BATTLE.PresentPower;
    for (let index = 0; r.byte(p) !== 0xff; index++, p += 2)
      if (r.byte(p) >= roll) {
        this.animParam = index;
        this.damageArgs.power = r.byte(p + 1);
        return;
      }
    this.animParam = 3;
    const target = this.target.mon;
    if (target.hp === target.maxHp) {
      if (this.options.battleScene === false) yield* this.say(BATTLE.PresentFailedText);
      return this.endMoveEffect();
    }
    // GetQuarterMaxHP of the target, then RestoreHP.
    target.hp = Math.min(target.maxHp, (target.hp + (target.maxHp >> 2 || 1)) & 0xffff);
    yield this.hud();
    this.turn ^= 1;
    yield* this.say(BATTLE.RegainedHealthText);
    this.turn ^= 1;
    this.updateOpponentInParty();
    this.endMoveEffect();
  }
  /** HiddenPowerDamage: the type and power from the user's DVs, then the
   * damage stats for that type. */
  private hiddenPower() {
    if (this.attackMissed) return;
    const dvs = this.user.mon.dvs,
      attackDefense = dvs >> 8,
      speedSpecial = dvs & 0xff;
    const bits =
      ((attackDefense >> 4) & 8) | ((attackDefense & 8) >> 1) | ((speedSpecial >> 6) & 2) | ((speedSpecial & 8) >> 3);
    const power = ((bits * 5 + (speedSpecial & 3)) >> 1) + 31;
    let type = ((attackDefense & 3) | (((attackDefense >> 4) & 3) << 2)) + 1;
    if (type >= C.BIRD) type++;
    if (type >= C.UNUSED_TYPES) type += C.UNUSED_TYPES_END - C.UNUSED_TYPES;
    this.user.move.type = type;
    this.damageStats();
    this.damageArgs.power = power;
  }
  /** BattleCommand_FakeOut: flinches unless the target has a substitute,
   * sleeps, is frozen or moved first; otherwise the move misses. */
  private fakeOut() {
    if (this.attackMissed) return;
    const target = this.target;
    if (
      target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) ||
      target.mon.status & ((1 << C.FRZ) | C.SLP_MASK) ||
      this.enemyGoesFirst ^ this.turn
    ) {
      this.attackMissed = 1;
      return;
    }
    target.set(SUB3, C.SUBSTATUS_FLINCHED);
    target.reset(SUB4, C.SUBSTATUS_RECHARGE);
  }
  /** BattleCommand_PayDay: twice the user's level in coins. */
  private *payDay(): Gen {
    this.payDayMoney = (this.payDayMoney + ((this.user.mon.level * 2) & 0xff)) & 0xffffff;
    yield* this.say(BATTLE.CoinsScatteredText);
  }
  /** BattleCommand_Thief: an item-less user takes the target's item, but
   * not MAIL. A trainer's Pokémon keeps a stolen item for the rest of the
   * battle, so the player loses it for good. */
  private *thief(): Gen {
    const data = this.options.data,
      user = this.user,
      target = this.target;
    if (user.mon.item) return;
    const item = target.mon.item;
    if (!item || data.itemIsMail(item) || this.effectFailed) return;
    const otMon = this.options.trainer?.party[this.curOTMon];
    target.mon.item = 0;
    user.mon.item = item;
    if (this.turn === 0) {
      this.partyMon.item = item;
      if (otMon) otMon.item = 0;
    } else {
      this.partyMon.item = 0;
      if (otMon) otMon.item = item;
    }
    this.strings[RAM.stringBuffer1] = data.itemName(item);
    yield* this.say(BATTLE.StoleText);
  }
  /** BattleCommand_Selfdestruct: the user faints, hit or miss, and loses
   * Leech Seed; the target's Destiny Bond is cleared. */
  private *selfdestruct(): Gen {
    const user = this.user;
    user.mon.status = 0;
    user.mon.hp = 0;
    this.requireNoSubstitute(); // BattleCommand_LowerSub
    user.reset(SUB4, C.SUBSTATUS_LEECH_SEED);
    this.target.reset(SUB5, C.SUBSTATUS_DESTINY_BOND);
    yield this.hud();
  }

  // ------------------------------------------------- status and field moves

  /** CheckHiddenOpponent: the target is flying or underground. */
  private hiddenOpponent() {
    return Boolean(this.target.sub[SUB3] & ((1 << C.SUBSTATUS_FLYING) | (1 << C.SUBSTATUS_UNDERGROUND)));
  }
  /** FailMove: "But it failed!", or "It failed!" against Protect. */
  private *failMove(): Gen {
    yield* this.say(this.target.has(SUB1, C.SUBSTATUS_PROTECT) ? BATTLE.ItFailedText : BATTLE.ButItFailedText);
  }
  /** The slot of the move an opponent last used. The original searches on
   * past the move list when the move is not there (after Metronome, for
   * instance), which is refused. */
  private moveSlot(side: Side, move: number) {
    const slot = side.mon.moves.indexOf(move);
    if (slot < 0) throw new UnsupportedBattle("A move that is not in the move list is not ported yet.");
    return slot;
  }
  /** BattleCommand_LeechSeed: not on a Grass type or a substitute. */
  private *leechSeed(): Gen {
    const target = this.target;
    if (this.attackMissed || target.has(SUB4, C.SUBSTATUS_SUBSTITUTE)) return yield* this.say(BATTLE.EvadedText);
    if (this.isType(target, C.GRASS)) return yield* this.say(BATTLE.DoesntAffectText);
    if (target.has(SUB4, C.SUBSTATUS_LEECH_SEED)) return yield* this.say(BATTLE.EvadedText);
    target.set(SUB4, C.SUBSTATUS_LEECH_SEED);
    yield* this.say(BATTLE.WasSeededText);
  }
  /** BattleCommand_Nightmare: only on a sleeping target in reach. */
  private *nightmare(): Gen {
    const target = this.target;
    if (
      this.hiddenOpponent() ||
      target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) ||
      !(target.mon.status & C.SLP_MASK) ||
      target.has(SUB1, C.SUBSTATUS_NIGHTMARE)
    )
      return yield* this.say(BATTLE.ButItFailedText);
    target.set(SUB1, C.SUBSTATUS_NIGHTMARE);
    yield* this.say(BATTLE.StartedNightmareText);
  }
  /** BattleCommand_Curse: a Ghost type halves its HP to curse the target;
   * others lower their Speed and raise Attack and Defense. */
  private *curse(): Gen {
    const user = this.user,
      target = this.target;
    if (this.isType(user, C.GHOST)) {
      if (this.hiddenOpponent() || target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || target.has(SUB1, C.SUBSTATUS_CURSE))
        return yield* this.say(BATTLE.ButItFailedText);
      target.set(SUB1, C.SUBSTATUS_CURSE);
      this.subtractHP(user, user.mon.maxHp >> 1 || 1);
      this.updateUserInParty();
      yield this.hud();
      return yield* this.say(BATTLE.PutACurseText);
    }
    if (user.levels[C.ATTACK] >= C.MAX_STAT_LEVEL && user.levels[C.DEFENSE] >= C.MAX_STAT_LEVEL) {
      // GetStatName's eighth name: "ABILITY won't rise anymore!"
      this.loweredStat = C.ABILITY;
      this.statName();
      return yield* this.say(BATTLE.WontRiseAnymoreText);
    }
    this.animParam = 1;
    this.lowerOwnStat(C.SPEED);
    this.turn ^= 1;
    yield* this.statDownMessage();
    this.attackMissed = 0;
    this.turn ^= 1;
    this.statUp(C.ATTACK);
    yield* this.statUpMessage();
    this.attackMissed = 0;
    this.statUp(C.DEFENSE);
    yield* this.statUpMessage();
  }
  /** LowerStat: a stat of the side whose turn it is, without Mist or a
   * random failure. */
  private lowerOwnStat(stat: number) {
    this.loweredStat = stat;
    const side = this.user,
      index = stat & 0xf;
    let level = side.levels[index] - 1;
    if (!level) {
      this.failedMessage = 2;
      return;
    }
    if (stat & 0xf0) level = level - 1 || 1;
    side.levels[index] = level;
    if (index < C.ACCURACY) {
      if (side.mon.stats[index] === 1) {
        side.levels[index] = level + 1;
        this.failedMessage = 2;
        return;
      }
      this.calcStats(side);
    }
    this.failedMessage = 0;
  }
  /** BattleCommand_Protect and BattleCommand_Endure (ProtectChance): fails
   * for the side that moves last or behind a substitute; each use in a row
   * halves the chance. */
  private *protect(endure: boolean): Gen {
    const user = this.user;
    let chance = 0xff;
    let failed = Boolean(this.enemyGoesFirst ^ this.turn) || user.has(SUB4, C.SUBSTATUS_SUBSTITUTE);
    for (let count = user.protectCount; !failed && count; count--) {
      chance >>= 1;
      if (!chance) failed = true;
    }
    if (!failed) {
      let roll: number;
      do roll = this.random();
      while (!roll);
      failed = roll - 1 >= chance;
    }
    if (failed) {
      user.protectCount = 0;
      return yield* this.say(BATTLE.ButItFailedText);
    }
    user.protectCount = (user.protectCount + 1) & 0xff;
    user.set(SUB1, endure ? C.SUBSTATUS_ENDURE : C.SUBSTATUS_PROTECT);
    yield* this.say(endure ? BATTLE.BracedItselfText : BATTLE.ProtectedItselfText);
  }
  /** BattleCommand_Spite: 2-5 PP off the target's last move, in its party
   * struct too unless it is transformed (a wild Pokémon's kept PP). */
  private *spite(): Gen {
    const target = this.target,
      last = target.lastCounterMove;
    if (this.attackMissed || !last || last === C.STRUGGLE) return yield* this.didntAffect2();
    const slot = this.moveSlot(target, last),
      pp = target.mon.pp[slot];
    if (!(pp & C.PP_MASK)) return yield* this.didntAffect2();
    this.strings[RAM.stringBuffer1] = this.options.data.moveName(last);
    const amount = Math.min(pp & C.PP_MASK, (this.random() & 3) + 2);
    target.mon.pp[slot] = pp - amount;
    if (!target.has(SUB5, C.SUBSTATUS_TRANSFORMED)) {
      if (this.turn === 1) this.partyMon.pp[slot] = pp - amount;
      else if (this.battleMode === C.WILD_BATTLE) this.wildPP[slot] = pp - amount;
      else this.options.trainer!.party[this.curOTMon].pp[slot] = pp - amount;
    }
    this.numbers[RAM.textDecimalByte] = amount;
    yield* this.say(BATTLE.SpiteEffectText);
  }
  /** BattleCommand_HealBell: the user and all six party slots lose their
   * status; Nightmare ends, Toxic's flag does not. */
  private *healBell(): Gen {
    const user = this.user;
    user.reset(SUB1, C.SUBSTATUS_NIGHTMARE);
    user.mon.status = 0;
    for (const mon of (this.turn === 0 ? this.options.party : this.options.trainer?.party) ?? []) mon.status = 0;
    yield this.hud();
    yield* this.say(BATTLE.BellChimedText);
    this.calcStats(user);
  }
  /** BattleCommand_Disable: the target's last move for 1-7 more turns. */
  private *disable(): Gen {
    const target = this.target,
      last = target.lastCounterMove;
    if (this.attackMissed || target.disableCount || !last || last === C.STRUGGLE) return yield* this.failMove();
    const slot = this.moveSlot(target, last);
    if (!target.mon.pp[slot]) return yield* this.failMove();
    let turns: number;
    do turns = this.random() & 7;
    while (!turns);
    target.disableCount = turns + 1 + ((slot + 1) << 4);
    target.disabledMove = last;
    this.strings[RAM.stringBuffer1] = this.options.data.moveName(last);
    yield* this.say(BATTLE.WasDisabledText);
  }
  /** BattleCommand_Encore: the target repeats its last move for 3-6 turns;
   * if it has not moved yet this turn, it switches to that move now. */
  private *encore(): Gen {
    const target = this.target,
      last = target.lastMove;
    if (!last || last === C.STRUGGLE || last === C.ENCORE || last === C.MIRROR_MOVE) return yield* this.didntAffect2();
    if (!(target.mon.pp[this.moveSlot(target, last)] & C.PP_MASK)) return yield* this.didntAffect2();
    if (this.attackMissed || target.has(SUB5, C.SUBSTATUS_ENCORED)) return yield* this.didntAffect2();
    target.set(SUB5, C.SUBSTATUS_ENCORED);
    target.encoreCount = (this.random() & 3) + 3;
    if (!(this.enemyGoesFirst ^ this.turn)) {
      target.moveNum = this.moveSlot(target, last);
      target.curMove = last;
      target.move = this.moveStruct(last);
    }
    yield* this.say(BATTLE.GotAnEncoreText);
  }
  /** GetMoveData into a move struct. */
  private moveStruct(id: number): MoveStruct {
    const move = this.options.data.move(id);
    return {
      anim: move.id,
      effect: move.effect,
      power: move.power,
      type: move.type,
      accuracy: move.accuracy,
      pp: move.pp,
      chance: move.chance,
    };
  }
  /** BattleCommand_Attract: the opposite gender falls in love. The
   * player's side counts its party Pokémon's gender. */
  private *attract(): Gen {
    const target = this.target;
    if (this.attackMissed || !this.oppositeGender() || this.hiddenOpponent() || target.has(SUB1, C.SUBSTATUS_IN_LOVE))
      return yield* this.failMove();
    target.set(SUB1, C.SUBSTATUS_IN_LOVE);
    yield* this.say(BATTLE.FellInLoveText);
  }
  /** CheckOppositeGender. */
  private oppositeGender() {
    if (this.enemy.has(SUB5, C.SUBSTATUS_TRANSFORMED))
      throw new UnsupportedBattle("Attract against a transformed Pokémon is not ported yet.");
    const data = this.options.data,
      player = data.gender(this.partyMon.species, this.partyMon.dvs),
      enemy = data.gender(this.enemy.mon.species, this.enemy.mon.dvs);
    return player !== undefined && enemy !== undefined && player !== enemy;
  }
  /** BattleCommand_ResetStats (Haze): every stat level back to normal. */
  private *resetStats(): Gen {
    const turn = this.turn;
    for (const [side, sideTurn] of [[this.player, 0], [this.enemy, 1]] as const) {
      side.levels = [7, 7, 7, 7, 7, 7, 7];
      this.turn = sideTurn;
      this.calcStats(side);
    }
    this.turn = turn;
    yield* this.say(BATTLE.EliminatedStatsText);
  }
  /** BattleCommand_Heal: half the maximum HP, or all of it with Rest,
   * which also puts the user to sleep for two turns. */
  private *heal(): Gen {
    const user = this.user,
      mon = user.mon;
    if (mon.hp === mon.maxHp) return yield* this.say(BATTLE.HPIsFullText);
    const rest = user.move.anim === C.REST;
    if (rest) {
      user.reset(SUB5, C.SUBSTATUS_TOXIC);
      const statused = mon.status !== 0;
      mon.status = C.REST_SLEEP_TURNS + 1;
      yield this.hud();
      yield* this.say(statused ? BATTLE.RestedText : BATTLE.WentToSleepText);
      this.calcStats(user);
    }
    mon.hp = Math.min(mon.maxHp, (mon.hp + (rest ? mon.maxHp : mon.maxHp >> 1 || 1)) & 0xffff);
    this.updateUserInParty();
    yield this.hud();
    yield* this.say(BATTLE.RegainedHealthText);
  }
  /** BattleCommand_PainSplit: both take the average of their HP, up to
   * their maximum. The party structs are left as they were. */
  private *painSplit(): Gen {
    if (this.attackMissed || this.target.has(SUB4, C.SUBSTATUS_SUBSTITUTE)) return yield* this.didntAffect2();
    const average = (this.player.mon.hp + this.enemy.mon.hp) >> 1;
    for (const side of [this.player, this.enemy]) side.mon.hp = Math.min(side.mon.maxHp, average);
    this.curDamage = 0;
    yield this.hud();
    yield* this.say(BATTLE.SharedPainText);
  }
  /** BattleCommand_BellyDrum: half the maximum HP for the highest Attack.
   * The first two stages are raised before the HP check, so they stay
   * even when it fails (a kept bug). */
  private *bellyDrum(): Gen {
    const user = this.user;
    this.statUp(C.ATTACK | 0x10);
    const half = user.mon.maxHp >> 1 || 1;
    if (this.attackMissed || half >= user.mon.hp) return yield* this.say(BATTLE.ButItFailedText);
    this.subtractHP(user, half);
    this.updateUserInParty();
    yield this.hud();
    for (let times = C.MAX_STAT_LEVEL - C.BASE_STAT_LEVEL - 1; times > 0; times--) this.statUp(C.ATTACK | 0x10);
    yield* this.say(BATTLE.BellyDrumText);
  }
  /** BattleCommand_PsychUp: copy the target's stat levels, unless they
   * are all normal. */
  private *psychUp(): Gen {
    const user = this.user,
      target = this.target;
    if (target.levels.every((level) => level === C.BASE_STAT_LEVEL)) return yield* this.say(BATTLE.ButItFailedText);
    user.levels = [...target.levels];
    this.calcStats(user);
    yield* this.say(BATTLE.CopiedStatsText);
  }
  /** BattleCommand_PerishSong: both sides get a count of 4, unless both
   * already have one. */
  private *perishSong(): Gen {
    const sides = [this.player, this.enemy];
    if (sides.every((side) => side.has(SUB1, C.SUBSTATUS_PERISH))) return yield* this.say(BATTLE.ButItFailedText);
    for (const side of sides)
      if (!side.has(SUB1, C.SUBSTATUS_PERISH)) {
        side.set(SUB1, C.SUBSTATUS_PERISH);
        side.perishCount = 4;
      }
    yield* this.say(BATTLE.StartPerishText);
  }
  /** BattleCommand_ClearHazards (Rapid Spin): the user sheds Leech Seed,
   * its side's Spikes and a trap. */
  private *clearHazards(): Gen {
    const user = this.user;
    if (user.has(SUB4, C.SUBSTATUS_LEECH_SEED)) {
      user.reset(SUB4, C.SUBSTATUS_LEECH_SEED);
      yield* this.say(BATTLE.ShedLeechSeedText);
    }
    if (user.screens & (1 << C.SCREENS_SPIKES)) {
      user.screens &= ~(1 << C.SCREENS_SPIKES);
      yield* this.say(BATTLE.BlewSpikesText);
    }
    if (!user.wrapCount) return;
    user.wrapCount = 0;
    yield* this.say(BATTLE.ReleasedByText);
  }
  /** BattleCommand_CheckFutureSight: on the turn it strikes, the stored
   * damage skips to after `futuresight`. */
  private checkFutureSight() {
    const user = this.user;
    if (user.futureSightCount !== 1) return;
    user.futureSightCount = 0;
    this.curDamage = user.futureSightDamage;
    this.skipTo(COMMAND.futuresight);
  }
  /** BattleCommand_FutureSight: store this turn's damage for three turns
   * later, unless one is already coming. */
  private *futureSight(): Gen {
    const user = this.user;
    if (!user.charging) {
      user.lastCounterMove = user.move.anim;
      user.lastMove = user.move.anim;
    }
    if (user.futureSightCount) {
      this.curDamage = 0;
      yield* this.say(BATTLE.ButItFailedText);
      return this.endMoveEffect();
    }
    user.futureSightCount = 4;
    this.requireNoSubstitute(); // BattleCommand_LowerSub and RaiseSub
    yield* this.say(BATTLE.ForesawAttackText);
    user.futureSightDamage = this.curDamage;
    this.curDamage = 0;
    this.endMoveEffect();
  }

  /** SkipToBattleCommand: go on after the next `command`. */
  private skipTo(command: number) {
    while (this.script[this.scriptIndex++] !== command)
      if (this.scriptIndex >= this.script.length)
        throw new UnsupportedBattle(`Battle script has no command 0x${command.toString(16)}.`);
  }

  // ------------------------------------------------------ multi-turn moves

  /** BattleCommand_CheckCharge: a charged move's second turn skips to
   * after `charge`. */
  private checkCharge() {
    const user = this.user;
    if (!user.has(SUB3, C.SUBSTATUS_CHARGED)) return;
    user.reset(SUB3, C.SUBSTATUS_CHARGED);
    user.reset(SUB3, C.SUBSTATUS_UNDERGROUND);
    user.reset(SUB3, C.SUBSTATUS_FLYING);
    this.skipTo(COMMAND.charge);
  }
  /** BattleCommand_Charge: the charging turn. Fly and Dig take the user
   * out of reach; Skull Bash goes on to its Defense raise. A sleeping
   * user (through Sleep Talk) fails. */
  private *charge(): Gen {
    const user = this.user;
    if (user.mon.status & C.SLP_MASK) {
      this.requireNoSubstitute(); // BattleCommand_RaiseSub
      yield* this.say(BATTLE.ButItFailedText);
      return this.endMoveEffect();
    }
    user.set(SUB3, C.SUBSTATUS_CHARGED);
    if (this.alreadyDisobeyed) yield* this.say(BATTLE.IgnoredOrders2Text);
    this.requireNoSubstitute(); // BattleCommand_LowerSub and RaiseSub
    this.animParam = 1;
    const anim = user.move.anim;
    if (anim === C.FLY) user.set(SUB3, C.SUBSTATUS_FLYING);
    else if (anim === C.DIG) user.set(SUB3, C.SUBSTATUS_UNDERGROUND);
    if (!user.charging) {
      user.lastCounterMove = anim;
      user.lastMove = anim;
    }
    this.curDamage = 0;
    yield* this.say(BATTLE["BattleCommand_Charge.UsedText"]);
    if (user.move.effect === C.EFFECT_SKULL_BASH) return this.skipTo(COMMAND.endturn);
    this.endMoveEffect();
  }
  /** BattleCommand_CheckRampage: a rampage's later turns skip to after
   * `rampage`; the last one confuses the user for 2-3 turns unless its
   * side has Safeguard. */
  private checkRampage() {
    const user = this.user;
    if (!user.has(SUB3, C.SUBSTATUS_RAMPAGE)) return;
    user.rolloutCount = (user.rolloutCount - 1) & 0xff;
    if (!user.rolloutCount) {
      user.reset(SUB3, C.SUBSTATUS_RAMPAGE);
      if (!(user.screens & (1 << C.SCREENS_SAFEGUARD))) {
        user.set(SUB3, C.SUBSTATUS_CONFUSED);
        user.confuseCount = (this.random() & 1) + 2;
      }
    }
    this.skipTo(COMMAND.rampage);
  }
  /** BattleCommand_Rampage: 1 or 2 more turns, not while asleep. */
  private rampage() {
    const user = this.user;
    if (user.mon.status & C.SLP_MASK) return;
    user.set(SUB3, C.SUBSTATUS_RAMPAGE);
    user.rolloutCount = (this.random() & 1) + 1;
  }
  /** BattleCommand_CheckRollout: a rolling Pokémon skips to after doturn. */
  private checkRollout() {
    const user = this.user;
    if (user.has(SUB1, C.SUBSTATUS_ROLLOUT)) return this.skipTo(COMMAND.doturn);
    user.rolloutCount = 0;
  }
  /** BattleCommand_RolloutPower: the damage doubles for each hit so far
   * (once more after Defense Curl), for up to five hits; a miss stops. */
  private rolloutPower() {
    const user = this.user;
    if (user.mon.status & C.SLP_MASK) return;
    if (this.attackMissed) return user.reset(SUB1, C.SUBSTATUS_ROLLOUT);
    user.rolloutCount = (user.rolloutCount + 1) & 0xff;
    let doublings = user.rolloutCount;
    if (doublings >= 5) user.reset(SUB1, C.SUBSTATUS_ROLLOUT);
    else user.set(SUB1, C.SUBSTATUS_ROLLOUT);
    if (user.has(SUB2, C.SUBSTATUS_CURLED)) doublings++;
    this.doubleDamage(doublings - 1);
  }
  /** BattleCommand_FuryCutter: doubles for each hit in a row, up to 16×;
   * a miss starts over. */
  private furyCutter() {
    const user = this.user;
    if (this.attackMissed) {
      user.furyCutterCount = 0;
      return;
    }
    user.furyCutterCount = (user.furyCutterCount + 1) & 0xff;
    this.doubleDamage(Math.min(user.furyCutterCount, 5) - 1);
  }
  /** Double wCurDamage `times` times, stopping at $ffff. */
  private doubleDamage(times: number) {
    for (; times > 0; times--) {
      this.curDamage *= 2;
      if (this.curDamage > 0xffff) {
        this.curDamage = 0xffff;
        return;
      }
    }
  }
  /** BattleCommand_StoreEnergy: while biding, the user stores energy; on
   * the last turn it unleashes twice the damage it took. */
  private *storeEnergy(): Gen {
    const user = this.user;
    if (!user.has(SUB3, C.SUBSTATUS_BIDE)) return;
    user.rolloutCount = (user.rolloutCount - 1) & 0xff;
    if (user.rolloutCount) {
      yield* this.say(BATTLE.StoringEnergyText);
      return this.endMoveEffect();
    }
    user.reset(SUB3, C.SUBSTATUS_BIDE);
    yield* this.say(BATTLE.UnleashedEnergyText);
    user.move.power = 1;
    this.curDamage = Math.min(0xffff, user.damageTaken * 2);
    if (!this.curDamage) this.attackMissed = 1;
    user.damageTaken = 0;
    user.charging = 0;
    user.move.anim = C.BIDE;
    this.skipTo(COMMAND.unleashenergy);
  }
  /** BattleCommand_UnleashEnergy: Bide's first turn. It also clears both
   * move structs' effects. */
  private unleashEnergy() {
    const user = this.user;
    user.set(SUB3, C.SUBSTATUS_BIDE);
    user.damageTaken = 0;
    this.player.move.effect = 0;
    this.enemy.move.effect = 0;
    user.rolloutCount = (this.random() & 1) + 2;
    this.animParam = 1;
    this.endMoveEffect();
  }
  /** BattleCommand_TrapTarget: trapped for 2-5 more turns, unless already
   * trapped or behind a substitute. */
  private *trapTarget(): Gen {
    if (this.attackMissed) return;
    const target = this.target;
    if (target.wrapCount || target.has(SUB4, C.SUBSTATUS_SUBSTITUTE)) return;
    target.wrapCount = (this.random() & 3) + 3;
    const anim = this.user.move.anim;
    target.trappingMove = anim;
    const text = {
      [C.BIND]: BATTLE.UsedBindText,
      [C.WRAP]: BATTLE.WrappedByText,
      [C.FIRE_SPIN]: BATTLE.FireSpinTrapText,
      [C.CLAMP]: BATTLE.ClampedByText,
      [C.WHIRLPOOL]: BATTLE.WhirlpoolTrapText,
    }[anim];
    if (text === undefined) throw new UnsupportedBattle("Unknown trapping move.");
    yield* this.say(text);
  }
  /** BattleCommand_LockOn: the user's next move cannot miss the target. */
  private *lockOn(): Gen {
    const target = this.target;
    if (target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || this.attackMissed)
      return yield* this.say(BATTLE.DidntAffect1Text);
    target.set(SUB5, C.SUBSTATUS_LOCK_ON);
    yield* this.say(BATTLE.TookAimText);
  }

  /** BattleCommand_HeldFlinch (kingsrock). */
  private kingsRock() {
    if (this.attackMissed) return;
    const item = this.data.heldEffect(this.user.mon.item);
    if (item.effect !== C.HELD_FLINCH || this.target.has(SUB4, C.SUBSTATUS_SUBSTITUTE)) return;
    if (this.random() >= item.parameter) return;
    this.target.reset(SUB4, C.SUBSTATUS_RECHARGE);
    this.target.set(SUB3, C.SUBSTATUS_FLINCHED);
  }

  // ------------------------------------------------------------- statuses

  private safeguarded() {
    return Boolean(this.target.screens & (1 << C.SCREENS_SAFEGUARD));
  }
  private isType(side: Side, type: number) {
    return side.mon.types[0] === type || side.mon.types[1] === type;
  }
  /** CheckMoveTypeMatchesTarget: the move shares a type with the target,
   * unless it is Normal (Tri Attack). */
  private moveTypeMatchesTarget() {
    const type = this.user.move.type;
    return type !== C.NORMAL && this.isType(this.target, type);
  }
  /** Defrost: a fire move thaws a frozen target, in the party struct too
   * (wOTPartyMons for a trainer; a wild Pokémon has none to keep). */
  private *defrostOpponent(): Gen {
    const target = this.target;
    if (!(target.mon.status & (1 << C.FRZ))) return;
    target.mon.status = 0;
    if (this.turn === 1) this.partyMon.status = 0;
    else if (this.options.trainer) this.options.trainer.party[this.curOTMon].status = 0;
    this.updateOpponentInParty();
    yield this.hud();
    yield* this.say(BATTLE.DefrostedOpponentText);
  }
  /** BattleCommand_Defrost: Flame Wheel and Sacred Fire thaw their user;
   * a wild Pokémon's party struct is left alone. */
  private *defrostUser(): Gen {
    const user = this.user;
    if (!(user.mon.status & (1 << C.FRZ))) return;
    user.mon.status &= ~(1 << C.FRZ);
    if (this.turn === 0) this.partyMon.status &= ~(1 << C.FRZ);
    else if (this.battleMode !== C.WILD_BATTLE)
      this.options.trainer!.party[this.curOTMon].status &= ~(1 << C.FRZ);
    yield this.hud();
    yield* this.say(BATTLE.WasDefrostedText);
  }
  /** BattleCommand_FreezeTarget. */
  private *freezeTarget(): Gen {
    const target = this.target;
    if (target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || target.mon.status) return;
    if (!(this.typeModifier & C.EFFECTIVENESS_MASK)) return;
    if (this.weather === C.WEATHER_SUN) return;
    if (this.moveTypeMatchesTarget()) return; // no freezing an Ice type
    if (this.data.heldEffect(target.mon.item).effect === C.HELD_PREVENT_FREEZE) return;
    if (this.effectFailed || this.safeguarded()) return;
    target.mon.status |= 1 << C.FRZ;
    this.updateOpponentInParty();
    yield this.hud();
    yield* this.say(BATTLE.WasFrozenText);
    if (yield* this.useHeldStatusHealingItem()) return;
    // OpponentCantMove and EndRechargeOpp; a freeze this turn skips
    // HandleDefrost.
    this.turn ^= 1;
    this.cantMove();
    this.turn ^= 1;
    target.reset(SUB4, C.SUBSTATUS_RECHARGE);
    target.justGotFrozen = 1;
  }
  /** BattleCommand_TriStatusChance: one of paralysis, freeze or burn. */
  private *triStatusChance(): Gen {
    this.effectChance();
    let choice: number;
    do choice = (this.random() >> 4) & 3;
    while (!choice);
    if (choice === 1) yield* this.paralyzeTarget();
    else if (choice === 2) yield* this.freezeTarget();
    else yield* this.burnTarget();
  }
  /** UseHeldStatusHealingItem for the opponent. Returns true if it cured. */
  private *useHeldStatusHealingItem(): Gen<boolean> {
    const side = this.target,
      held = this.data.heldEffect(side.mon.item);
    const mask = this.data.heldStatusHealing(held.effect);
    if (mask === undefined || !(side.mon.status & mask)) return false;
    side.mon.status = 0;
    this.updateOpponentInParty();
    side.reset(SUB5, C.SUBSTATUS_TOXIC);
    side.reset(SUB1, C.SUBSTATUS_NIGHTMARE);
    // ALL_STATUS (a Miracle Berry) also cures confusion.
    if (mask === this.data.heldStatusHealing(C.HELD_HEAL_STATUS)) side.reset(SUB3, C.SUBSTATUS_CONFUSED);
    this.calcStats(side);
    yield this.hud();
    yield* this.useOpponentItem();
    return true;
  }
  /** UseOpponentItem: name the item, consume it and report the recovery. */
  private *useOpponentItem(): Gen {
    const side = this.target;
    this.strings[RAM.stringBuffer1] = this.options.data.itemName(side.mon.item);
    this.consumeHeldItem(side);
    yield* this.say(BATTLE.RecoveredUsingText);
  }
  /** ConsumeHeldItem: consumable held items are used up for good. */
  private consumeHeldItem(side: Side) {
    const effect = this.data.heldEffect(side.mon.item).effect;
    if (!this.data.byteList(BATTLE.ConsumableEffects).includes(effect)) return;
    side.mon.item = 0;
    if (side === this.player) this.partyMon.item = 0;
  }
  /** HandleHPHealingItem for the opponent: a Berry below half HP. */
  private *handleHPHealingItem(): Gen {
    const side = this.target,
      mon = side.mon,
      held = this.data.heldEffect(mon.item);
    if (held.effect !== C.HELD_BERRY) return;
    if (((mon.hp * 2) & 0xffff) >= mon.maxHp) return;
    mon.hp = Math.min(mon.maxHp, mon.hp + held.parameter);
    if (side === this.player) this.updateBattleMonInParty();
    yield this.hud();
    yield* this.useOpponentItem();
  }
  /** UseConfusionHealingItem for the opponent. */
  private *useConfusionHealingItem(): Gen {
    const side = this.target;
    if (!side.has(SUB3, C.SUBSTATUS_CONFUSED)) return;
    const effect = this.data.heldEffect(side.mon.item).effect;
    if (effect !== C.HELD_HEAL_CONFUSION && effect !== C.HELD_HEAL_STATUS) return;
    side.reset(SUB3, C.SUBSTATUS_CONFUSED);
    this.strings[RAM.stringBuffer1] = this.options.data.itemName(side.mon.item);
    yield* this.say(BATTLE.BattleText_ItemHealedConfusion);
    side.mon.item = 0;
    if (side === this.player) this.partyMon.item = 0;
  }
  private *poisonTarget(): Gen {
    const target = this.target;
    if (target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || target.mon.status) return;
    if (!(this.typeModifier & C.EFFECTIVENESS_MASK) || this.isType(target, C.POISON)) return;
    if (this.data.heldEffect(target.mon.item).effect === C.HELD_PREVENT_POISON) return;
    if (this.effectFailed || this.safeguarded()) return;
    target.mon.status |= 1 << C.PSN;
    this.updateOpponentInParty();
    yield this.hud();
    yield* this.say(BATTLE.WasPoisonedText);
    yield* this.useHeldStatusHealingItem();
  }
  private *burnTarget(): Gen {
    const target = this.target;
    if (target.has(SUB4, C.SUBSTATUS_SUBSTITUTE)) return;
    if (target.mon.status) return yield* this.defrostOpponent();
    if (!(this.typeModifier & C.EFFECTIVENESS_MASK)) return;
    if (this.moveTypeMatchesTarget()) return; // no burning a Fire type
    if (this.data.heldEffect(target.mon.item).effect === C.HELD_PREVENT_BURN) return;
    if (this.effectFailed || this.safeguarded()) return;
    target.mon.status |= 1 << C.BRN;
    this.updateOpponentInParty();
    this.applyStatusEffects(target);
    yield this.hud();
    yield* this.say(BATTLE.WasBurnedText);
    yield* this.useHeldStatusHealingItem();
  }
  private *paralyzeTarget(): Gen {
    const target = this.target;
    if (target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || target.mon.status) return;
    if (!(this.typeModifier & C.EFFECTIVENESS_MASK)) return;
    if (this.data.heldEffect(target.mon.item).effect === C.HELD_PREVENT_PARALYZE) return;
    if (this.effectFailed || this.safeguarded()) return;
    target.mon.status |= 1 << C.PAR;
    this.updateOpponentInParty();
    this.applyStatusEffects(target);
    yield this.hud();
    yield* this.say(BATTLE.ParalyzedText);
    yield* this.useHeldStatusHealingItem();
  }
  private flinchTarget() {
    const target = this.target;
    if (target.has(SUB4, C.SUBSTATUS_SUBSTITUTE)) return;
    if (target.mon.status & ((1 << C.FRZ) | C.SLP_MASK)) return;
    if (this.enemyGoesFirst ^ this.turn) return;
    if (this.effectFailed) return;
    target.set(SUB3, C.SUBSTATUS_FLINCHED);
    target.reset(SUB4, C.SUBSTATUS_RECHARGE);
  }
  /** The AI's 25% failure for status moves (not for the player). */
  private aiRandomFail() {
    if (this.turn === 0 || this.player.has(SUB5, C.SUBSTATUS_LOCK_ON)) return false;
    return this.random() < percent(25) + 1;
  }
  private *didntAffect2(): Gen {
    yield* this.say(this.target.has(SUB1, C.SUBSTATUS_PROTECT) ? BATTLE.DidntAffect2Text : BATTLE.DidntAffect1Text);
  }
  private *sleepTarget(): Gen {
    const target = this.target;
    const item = this.data.heldEffect(target.mon.item);
    if (item.effect === C.HELD_PREVENT_SLEEP) {
      this.strings[RAM.stringBuffer1] = this.options.data.itemName(target.mon.item);
      return yield* this.say(BATTLE.ProtectedByText);
    }
    if (target.mon.status & C.SLP_MASK) return yield* this.say(BATTLE.AlreadyAsleepText);
    if (this.attackMissed) return yield* this.didntAffect2();
    if (this.aiRandomFail() || target.mon.status || target.has(SUB4, C.SUBSTATUS_SUBSTITUTE))
      return yield* this.say(BATTLE.DidntAffect1Text);
    let turns: number;
    do turns = this.random() & C.SLP_MASK;
    while (!turns || turns === C.SLP_MASK);
    target.mon.status = turns + 1;
    this.updateOpponentInParty();
    yield this.hud();
    yield* this.say(BATTLE.FellAsleepText);
    // A sleeping opponent cannot finish a move that spans turns.
    if (!(yield* this.useHeldStatusHealingItem())) {
      this.turn ^= 1;
      this.cantMove();
      this.turn ^= 1;
    }
  }
  private *poisonCommand(): Gen {
    const target = this.target;
    if (!(this.typeModifier & C.EFFECTIVENESS_MASK) || this.isType(target, C.POISON))
      return yield* this.say(BATTLE.DoesntAffectText);
    if (target.mon.status & (1 << C.PSN)) return yield* this.say(BATTLE.AlreadyPoisonedText);
    if (this.data.heldEffect(target.mon.item).effect === C.HELD_PREVENT_POISON) {
      this.strings[RAM.stringBuffer1] = this.options.data.itemName(target.mon.item);
      return yield* this.say(BATTLE.ProtectedByText);
    }
    if (target.mon.status || this.aiRandomFail() || target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || this.attackMissed)
      return yield* this.say(BATTLE.DidntAffect1Text);
    // Toxic badly poisons, starting its damage counter over.
    const toxic = this.user.move.effect === C.EFFECT_TOXIC;
    if (toxic) {
      target.set(SUB5, C.SUBSTATUS_TOXIC);
      target.toxicCount = 0;
    }
    target.mon.status |= 1 << C.PSN;
    this.updateOpponentInParty();
    yield this.hud();
    yield* this.say(toxic ? BATTLE.BadlyPoisonedText : BATTLE.WasPoisonedText);
    yield* this.useHeldStatusHealingItem();
  }
  private *paralyzeCommand(): Gen {
    const target = this.target;
    if (target.mon.status & (1 << C.PAR)) return yield* this.say(BATTLE.AlreadyParalyzedText);
    if (!(this.typeModifier & C.EFFECTIVENESS_MASK)) return yield* this.say(BATTLE.DoesntAffectText);
    if (this.data.heldEffect(target.mon.item).effect === C.HELD_PREVENT_PARALYZE) {
      this.strings[RAM.stringBuffer1] = this.options.data.itemName(target.mon.item);
      return yield* this.say(BATTLE.ProtectedByText);
    }
    if (this.aiRandomFail() || target.mon.status || this.attackMissed || target.has(SUB4, C.SUBSTATUS_SUBSTITUTE))
      return yield* this.didntAffect2();
    target.mon.status |= 1 << C.PAR;
    this.updateOpponentInParty();
    this.applyStatusEffects(target);
    yield this.hud();
    yield* this.say(BATTLE.ParalyzedText);
    yield* this.useHeldStatusHealingItem();
  }
  private *confuseCommand(): Gen {
    const target = this.target;
    if (this.data.heldEffect(target.mon.item).effect === C.HELD_PREVENT_CONFUSE) {
      this.strings[RAM.stringBuffer1] = this.options.data.itemName(target.mon.item);
      return yield* this.say(BATTLE.ProtectedByText);
    }
    if (target.has(SUB3, C.SUBSTATUS_CONFUSED)) return yield* this.say(BATTLE.AlreadyConfusedText);
    if (target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || this.attackMissed) {
      const effect = this.user.move.effect;
      if (effect === C.EFFECT_CONFUSE_HIT || effect === C.EFFECT_SNORE || effect === C.EFFECT_SWAGGER) return;
      return yield* this.didntAffect2();
    }
    yield* this.finishConfusingTarget();
  }
  /** BattleCommand_ConfuseTarget: a move's added confusion, silent when
   * it fails. */
  private *confuseTarget(): Gen {
    const target = this.target;
    if (this.data.heldEffect(target.mon.item).effect === C.HELD_PREVENT_CONFUSE) return;
    if (this.effectFailed || this.safeguarded() || target.has(SUB4, C.SUBSTATUS_SUBSTITUTE)) return;
    if (target.has(SUB3, C.SUBSTATUS_CONFUSED)) return;
    yield* this.finishConfusingTarget();
  }
  /** BattleCommand_FinishConfusingTarget: confused for 2-5 turns. */
  private *finishConfusingTarget(): Gen {
    const target = this.target;
    target.set(SUB3, C.SUBSTATUS_CONFUSED);
    target.confuseCount = (this.random() & 3) + 2;
    yield* this.say(BATTLE.BecameConfusedText);
    yield* this.useConfusionHealingItem();
  }
  /** BattleCommand_DrainTarget and BattleCommand_EatDream: SapHealth
   * restores half the damage. */
  private *drainTarget(text: number = BATTLE.SuckedHealthText): Gen {
    const mon = this.user.mon;
    const amount = this.curDamage >> 1 || 1;
    mon.hp = Math.min(mon.maxHp, mon.hp + amount);
    if (this.turn === 0) this.updateBattleMonInParty();
    yield this.hud();
    yield* this.say(text);
  }
  /** BattleCommand_Recoil: a quarter of the damage dealt, at least 1 HP. */
  private *recoil(): Gen {
    const mon = this.user.mon;
    mon.hp = Math.max(0, mon.hp - (this.curDamage >> 2 || 1));
    if (this.turn === 0) this.updateBattleMonInParty();
    yield this.hud();
    yield* this.say(BATTLE.RecoilText);
  }
  private *checkSafeguard(): Gen {
    if (!this.safeguarded()) return;
    this.attackMissed = 1;
    yield* this.say(BATTLE.SafeguardProtectText);
    this.endMoveEffect();
  }
  private *foresight(): Gen {
    const target = this.target;
    if (this.attackMissed || target.sub[SUB3] & ((1 << C.SUBSTATUS_FLYING) | (1 << C.SUBSTATUS_UNDERGROUND)) || target.has(SUB1, C.SUBSTATUS_IDENTIFIED))
      return yield* this.say(target.has(SUB1, C.SUBSTATUS_PROTECT) ? BATTLE.ItFailedText : BATTLE.ButItFailedText);
    target.set(SUB1, C.SUBSTATUS_IDENTIFIED);
    yield* this.say(BATTLE.IdentifiedText);
  }
  /** BattleCommand_TimeBasedHealContinue (Morning Sun, Synthesis, Moonlight). */
  private *timeBasedHeal(time: number): Gen {
    const mon = this.user.mon;
    if (mon.hp === mon.maxHp) return yield* this.say(BATTLE.HPIsFullText);
    let index = 2;
    if (this.options.timeOfDay !== time) index--;
    if (this.weather) throw new UnsupportedBattle("Weather is not ported yet.");
    const quarter = mon.maxHp >> 2 || 1;
    const amount = [quarter >> 1 || 1, quarter, mon.maxHp >> 1 || 1, mon.maxHp][index];
    mon.hp = Math.min(mon.maxHp, mon.hp + amount);
    this.updateUserInParty();
    yield this.hud();
    yield* this.say(BATTLE.RegainedHealthText);
  }
  /** UpdateOpponentInParty and UpdateUserInParty. */
  private updateOpponentInParty() {
    if (this.turn === 1) this.updateBattleMonInParty();
    else this.updateEnemyMonInParty();
  }
  private updateUserInParty() {
    if (this.turn === 0) this.updateBattleMonInParty();
    else this.updateEnemyMonInParty();
  }
  /** UpdateEnemyMonInParty: a trainer's Pokémon's level, status and HP go
   * back to wOTPartyMons; wild Pokémon have none. */
  private updateEnemyMonInParty() {
    if (this.battleMode === C.WILD_BATTLE) return;
    const mon = this.options.trainer?.party[this.curOTMon];
    if (!mon) return;
    mon.level = this.enemy.mon.level;
    mon.status = this.enemy.mon.status;
    mon.hp = this.enemy.mon.hp;
  }

  // ------------------------------------------------------ stat changes

  /** RaiseStat (BattleCommand_StatUp). */
  private raiseStat(stat: number) {
    this.loweredStat = stat;
    const user = this.user,
      index = stat & 0xf;
    if (this.attackMissed || this.effectFailed) {
      this.failedMessage = 1;
      return;
    }
    let level = user.levels[index] + 1;
    if (level > C.MAX_STAT_LEVEL) {
      this.failedMessage = 2;
      this.attackMissed = 1;
      return;
    }
    if (stat & 0xf0) level = Math.min(C.MAX_STAT_LEVEL, level + 1);
    user.levels[index] = level;
    if (index < C.ACCURACY) {
      if (user.mon.stats[index] === 999) {
        user.levels[index]--;
        this.failedMessage = 2;
        this.attackMissed = 1;
        return;
      }
      this.calcStats(user);
    }
    this.failedMessage = 0;
  }
  /** BattleCommand_StatUp: RaiseStat, then MinimizeDropSub records a
   * successful Minimize for Stomp. */
  private statUp(stat: number) {
    this.raiseStat(stat);
    if (!this.failedMessage && this.user.move.anim === C.MINIMIZE) this.user.minimized = 1;
  }
  /** BattleCommand_StatDown. */
  private statDown(stat: number) {
    this.loweredStat = stat;
    const effect = this.user.move.effect;
    const mistEffect =
      (effect >= C.EFFECT_ATTACK_DOWN && effect <= C.EFFECT_EVASION_DOWN) ||
      (effect >= C.EFFECT_ATTACK_DOWN_2 && effect <= C.EFFECT_EVASION_DOWN_2) ||
      (effect >= C.EFFECT_ATTACK_DOWN_HIT && effect <= C.EFFECT_EVASION_DOWN_HIT);
    const target = this.target;
    if (mistEffect && target.has(SUB4, C.SUBSTATUS_MIST)) {
      this.failedMessage = 2;
      this.attackMissed = 1;
      return;
    }
    const index = stat & 0xf;
    let level = target.levels[index] - 1;
    const cantLower = () => {
      this.failedMessage = 3;
      this.attackMissed = 1;
    };
    if (!level) return cantLower();
    if (stat & 0xf0) {
      level--;
      if (!level) level = 1;
    }
    const failed = () => {
      this.failedMessage = 1;
      this.attackMissed = 1;
    };
    if (this.turn === 1 && effect !== C.EFFECT_ACCURACY_DOWN_HIT && !this.player.has(SUB5, C.SUBSTATUS_LOCK_ON))
      if (this.random() < percent(25) + 1) return failed();
    if (target.has(SUB4, C.SUBSTATUS_SUBSTITUTE) || this.attackMissed || this.effectFailed) return failed();
    if (target.sub[SUB3] & ((1 << C.SUBSTATUS_FLYING) | (1 << C.SUBSTATUS_UNDERGROUND))) return failed();
    target.levels[index] = level;
    if (index < C.ACCURACY) {
      // TryLowerStat: a stat already at 1 cannot drop further. The level is
      // raised back by one, even after a two-stage drop.
      if (target.mon.stats[index] === 1) {
        target.levels[index] = level + 1;
        return cantLower();
      }
      this.calcStats(target);
    }
    this.failedMessage = 0;
  }
  /** CalcPlayerStats / CalcEnemyStats: stages, then status penalties. */
  private calcStats(side: Side) {
    for (let stat = 0; stat < 5; stat++) {
      const [numerator, denominator] = this.data.statMultiplier(side.levels[stat]);
      const value = Math.floor((side.stats[stat] * numerator) / denominator);
      side.mon.stats[stat] = value === 0 ? 1 : Math.min(999, value);
    }
    this.applyStatusEffects(side);
  }
  private statName() {
    this.strings[RAM.stringBuffer2] = readString(
      this.reader,
      this.data.statNameAddress(this.loweredStat & 0xf),
      this.context(),
    );
  }
  private *statUpMessage(): Gen {
    if (this.failedMessage) return;
    this.statName();
    yield* this.say(BATTLE["BattleCommand_StatUpMessage.stat"]);
  }
  private *statDownMessage(): Gen {
    if (this.failedMessage) return;
    this.statName();
    yield* this.say(BATTLE["BattleCommand_StatDownMessage.stat"]);
  }
  private *statUpFailText(): Gen {
    if (!this.failedMessage) return;
    if (this.failedMessage === 1) {
      if (!this.alreadyFailed) yield* this.say(BATTLE.ButItFailedText);
      return;
    }
    this.statName();
    yield* this.say(BATTLE.WontRiseAnymoreText);
  }
  private *statDownFailText(): Gen {
    if (!this.failedMessage) return;
    if (this.failedMessage === 1) {
      if (!this.alreadyFailed) yield* this.say(BATTLE.ButItFailedText);
      return;
    }
    if (this.failedMessage === 2) return yield* this.say(BATTLE.ProtectedByMistText);
    this.statName();
    yield* this.say(BATTLE.WontDropAnymoreText);
  }

  // ------------------------------------------------------- turn ending

  /** ResidualDamage for the side whose turn it is: poison and burn (Toxic
   * a growing number of sixteenths), Leech Seed, Nightmare and Curse.
   * Returns false if it fainted. */
  private *residualDamage(): Gen<boolean> {
    const user = this.user,
      mon = user.mon,
      quarter = mon.maxHp >> 2 || 1;
    if (!mon.hp) return false;
    if (mon.status & ((1 << C.PSN) | (1 << C.BRN))) {
      yield* this.say(mon.status & (1 << C.BRN) ? BATTLE.HurtByBurnText : BATTLE.HurtByPoisonText);
      let damage = quarter >> 1 || 1;
      if (user.has(SUB5, C.SUBSTATUS_TOXIC)) {
        user.toxicCount = (user.toxicCount + 1) & 0xff;
        damage = ((quarter >> 2 || 1) * (user.toxicCount || 0x100)) & 0xffff;
      }
      this.subtractHP(user, damage);
      yield this.hud();
    }
    if (!mon.hp) return false;
    if (user.has(SUB4, C.SUBSTATUS_LEECH_SEED)) {
      // The seeder regains the HP actually drained.
      const drained = Math.min(mon.hp, quarter >> 1 || 1);
      this.subtractHP(user, drained);
      const seeder = this.target;
      seeder.mon.hp = Math.min(seeder.mon.maxHp, seeder.mon.hp + drained);
      if (seeder === this.player) this.updateBattleMonInParty();
      yield this.hud();
      yield* this.say(BATTLE.LeechSeedSapsText);
    }
    if (!mon.hp) return false;
    if (user.has(SUB1, C.SUBSTATUS_NIGHTMARE)) {
      this.subtractHP(user, quarter);
      yield this.hud();
      yield* this.say(BATTLE.HasANightmareText);
    }
    if (!mon.hp) return false;
    if (user.has(SUB1, C.SUBSTATUS_CURSE)) {
      this.subtractHP(user, quarter);
      yield this.hud();
      yield* this.say(BATTLE.HurtByCurseText);
    }
    return mon.hp > 0;
  }
  private subtractHP(side: Side, amount: number) {
    side.mon.hp = Math.max(0, side.mon.hp - amount);
    if (side === this.player) this.updateBattleMonInParty();
  }
  /** HandleBetweenTurnEffects. Effects no early move can cause are refused. */
  private *handleBetweenTurnEffects(): Gen {
    if (yield* this.checkFaintPlayerThenEnemy()) return;
    yield* this.handleFutureSight();
    if (yield* this.checkFaintPlayerThenEnemy()) return;
    if (this.weather) throw new UnsupportedBattle("Weather is not ported yet.");
    yield* this.handleWrap();
    if (yield* this.checkFaintPlayerThenEnemy()) return;
    yield* this.handlePerishSong();
    if (yield* this.checkFaintPlayerThenEnemy()) return;
    for (const side of [this.player, this.enemy]) {
      const effect = this.data.heldEffect(side.mon.item).effect;
      if (effect === C.HELD_RESTORE_PP || (effect >= C.HELD_ATTACK_UP && effect <= C.HELD_EVASION_UP))
        throw new UnsupportedBattle("Mystery Berry and stat-raising held items are not ported yet.");
    }
    // HandleLeftovers: each side heals itself; the text names it as target.
    for (const side of [this.player, this.enemy]) {
      const mon = side.mon;
      if (this.data.heldEffect(mon.item).effect !== C.HELD_LEFTOVERS || mon.hp === mon.maxHp) continue;
      this.strings[RAM.stringBuffer1] = this.options.data.itemName(mon.item);
      const quarter = mon.maxHp >> 2 || 1;
      mon.hp = Math.min(mon.maxHp, mon.hp + (quarter >> 2 || 1));
      if (side === this.player) this.updateBattleMonInParty();
      this.turn = side === this.player ? 1 : 0;
      yield this.hud();
      yield* this.say(BATTLE.BattleText_TargetRecoveredWithItem);
    }
    // HandleDefrost: a 10% thaw for a side that did not just freeze.
    for (const side of [this.player, this.enemy]) {
      if (!(side.mon.status & (1 << C.FRZ)) || side.justGotFrozen) continue;
      if (this.random() >= percent(10)) continue;
      side.mon.status = 0;
      if (side === this.player) this.updateBattleMonInParty();
      this.turn = side === this.player ? 1 : 0;
      yield this.hud();
      yield* this.say(BATTLE.DefrostedOpponentText);
    }
    yield* this.handleSafeguard();
    yield* this.handleScreens();
    // HandleHealingItems: turn 0 handles the enemy's items, then turn 1.
    for (const turn of [0, 1]) {
      this.turn = turn;
      yield* this.handleHPHealingItem();
      yield* this.useHeldStatusHealingItem();
      yield* this.useConfusionHealingItem();
    }
    this.updateBattleMonInParty();
    yield* this.handleEncore();
  }
  /** HandleFutureSight: three turns after its use, the stored attack hits
   * through DoMove, without CheckTurn. */
  private *handleFutureSight(): Gen {
    for (const [turn, side] of [this.player, this.enemy].entries()) {
      this.turn = turn;
      if (!side.futureSightCount) continue;
      side.futureSightCount--;
      if (side.futureSightCount !== 1) continue;
      yield* this.say(BATTLE.BattleText_TargetWasHitByFutureSight);
      const move = side.curMove;
      side.curMove = C.FUTURE_SIGHT;
      this.updateMoveData();
      this.attackMissed = 0;
      this.alreadyDisobeyed = 0;
      this.typeModifier = C.EFFECTIVE;
      yield* this.doMove();
      this.curDamage = 0;
      side.curMove = move;
      this.updateBattleMonInParty();
      this.updateEnemyMonInParty();
    }
  }
  /** HandlePerishSong: each count goes down; at 0 the Pokémon faints. */
  private *handlePerishSong(): Gen {
    for (const [turn, side] of [this.player, this.enemy].entries()) {
      this.turn = turn;
      if (!side.has(SUB1, C.SUBSTATUS_PERISH)) continue;
      side.perishCount = (side.perishCount - 1) & 0xff;
      this.numbers[RAM.textDecimalByte] = side.perishCount;
      yield* this.say(BATTLE.PerishCountText);
      if (side.perishCount) continue;
      side.reset(SUB1, C.SUBSTATUS_PERISH);
      side.mon.hp = 0;
      if (turn === 0) this.partyMon.hp = 0;
      else if (this.battleMode !== C.WILD_BATTLE) this.options.trainer!.party[this.curOTMon].hp = 0;
      yield this.hud();
    }
  }
  /** HandleSafeguard: five turns, the use included. */
  private *handleSafeguard(): Gen {
    for (const [turn, side] of [this.player, this.enemy].entries()) {
      if (!(side.screens & (1 << C.SCREENS_SAFEGUARD))) continue;
      side.safeguardCount = (side.safeguardCount - 1) & 0xff;
      if (side.safeguardCount) continue;
      side.screens &= ~(1 << C.SCREENS_SAFEGUARD);
      this.turn = turn;
      yield* this.say(BATTLE.BattleText_SafeguardFaded);
    }
  }
  /** HandleEncore: an encore ends after its turns, or when the move in
   * the chosen slot runs out of PP. */
  private *handleEncore(): Gen {
    for (const [turn, side] of [this.player, this.enemy].entries()) {
      if (!side.has(SUB5, C.SUBSTATUS_ENCORED)) continue;
      side.encoreCount = (side.encoreCount - 1) & 0xff;
      if (side.encoreCount && side.mon.pp[side.moveNum] & C.PP_MASK) continue;
      side.reset(SUB5, C.SUBSTATUS_ENCORED);
      this.turn = turn ^ 1;
      yield* this.say(BATTLE.BattleText_TargetsEncoreEnded);
    }
  }
  /** SpikesDamage: a Pokémon sent out onto Spikes loses an eighth of its
   * maximum HP, unless it is a Flying type. */
  private *spikesDamage(side: Side): Gen {
    if (!(side.screens & (1 << C.SCREENS_SPIKES)) || this.isType(side, C.FLYING)) return;
    yield* this.say(BATTLE.BattleText_UserHurtBySpikes);
    this.subtractHP(side, (side.mon.maxHp >> 2 || 1) >> 1 || 1);
    yield this.hud();
  }
  /** HandleWrap: a trapped side loses 1/16 of its maximum HP, or is
   * released on its last turn. A substitute shields it and stops the
   * count. */
  private *handleWrap(): Gen {
    for (const [turn, side] of [this.player, this.enemy].entries()) {
      this.turn = turn;
      if (!side.wrapCount || side.has(SUB4, C.SUBSTATUS_SUBSTITUTE)) continue;
      this.strings[RAM.stringBuffer1] = this.options.data.moveName(side.trappingMove);
      side.wrapCount--;
      if (!side.wrapCount) {
        yield* this.say(BATTLE.BattleText_UserWasReleasedFromStringBuffer1);
        continue;
      }
      // GetSixteenthMaxHP
      this.subtractHP(side, (side.mon.maxHp >> 2 || 1) >> 2 || 1);
      yield this.hud();
      yield* this.say(BATTLE.BattleText_UsersHurtByStringBuffer1);
    }
  }
  private *checkFaintPlayerThenEnemy(): Gen<boolean> {
    if (this.hasFainted(this.player)) {
      yield* this.handlePlayerMonFaint();
      if (this.battleEnded) return true;
    }
    if (this.hasFainted(this.enemy)) {
      yield* this.handleEnemyMonFaint();
      if (this.battleEnded) return true;
    }
    return false;
  }

  private *handleEnemyMonFaint(): Gen {
    yield* this.say(BATTLE.BattleText_EnemyMonFainted);
    if (!this.player.mon.hp) yield* this.faintYourPokemon();
    yield* this.updateStateAndExperienceAfterEnemyFaint(false);
    if (!this.options.party.some((mon) => mon.hp > 0)) return yield* this.lostBattle();
    yield this.hud();
    // A wild battle ends; so does a trainer's with no Pokémon left (WinTrainerBattle).
    if (!this.options.trainer || this.enemyTrainerDefeated()) {
      this.battleEnded = true;
      return;
    }
    if (!this.player.mon.hp) {
      // Trainer battles never ask, so both sides send out a new Pokémon.
      yield* this.askUseNextPokemon();
      yield* this.forcePlayerMonChoice();
      this.battlePlayerAction = C.BATTLEPLAYERACTION_USEITEM;
      return yield* this.doubleSwitch();
    }
    // HandleEnemySwitch: the player's Pokémon stays in.
    this.battlePlayerAction = C.BATTLEPLAYERACTION_USEITEM;
    yield* this.enemyPartyMonEntrance(false);
    this.battlePlayerAction = 0;
  }
  /** CheckEnemyTrainerDefeated: every party HP is zero. */
  private enemyTrainerDefeated() {
    return this.options.trainer!.party.every((mon) => mon.hp === 0);
  }
  /** EnemyPartyMonEntrance. `setMode` skips Shift mode's offer, as after a
   * double faint. */
  private *enemyPartyMonEntrance(setMode: boolean): Gen {
    this.enemySwitchMonIndex = 0;
    this.newEnemyMonStatus();
    this.enemy.levels = [7, 7, 7, 7, 7, 7, 7]; // ResetEnemyStatLevels
    this.breakAttraction();
    if (setMode) yield* this.enemySwitchSetMode();
    else yield* this.enemySwitch();
    this.resetBattleParticipants();
    this.turn = 1;
    yield* this.spikesDamage(this.enemy);
    this.enemy.move.anim = 0;
    this.battlePlayerAction = 0;
  }
  /** EnemySwitch: in Shift mode the player may switch too (OfferSwitch). */
  private *enemySwitch(): Gen {
    if (!this.checkWhetherToAskSwitch()) return yield* this.enemySwitchSetMode();
    this.loadEnemyMonToSwitchTo();
    const switching = yield* this.offerSwitch();
    yield* this.say(BATTLE.BattleText_EnemySentOut);
    yield this.hud();
    if (!switching) return;
    this.participants = this.participantsAll = 0;
    this.battlePlayerAction = 0;
    this.enemyIsSwitching = 1;
    yield* this.playerSwitch();
  }
  private *enemySwitchSetMode(): Gen {
    this.loadEnemyMonToSwitchTo();
    this.enemyIsSwitching = 1;
    yield* this.say(BATTLE.BattleText_EnemySentOut);
    yield this.hud();
  }
  /** ResetEnemyBattleVars, CheckWhetherSwitchmonIsPredetermined (else the
   * type-matchup choice) and LoadEnemyMonToSwitchTo. */
  private loadEnemyMonToSwitchTo() {
    this.resetEnemyBattleVars();
    const index = this.enemySwitchMonIndex
      ? this.enemySwitchMonIndex - 1
      : this.battleHasJustStarted
        ? 0
        : this.findMonInOTPartyToSwitchIntoBattle();
    if (!this.options.trainer!.party[index]?.hp)
      throw new UnsupportedBattle("Invalid trainer switch.");
    // LoadEnemyMon records wCurOTMon.
    this.curOTMon = index;
    this.loadEnemyMon();
  }
  /** CheckWhetherToAskSwitch: the SHIFT battle style asks when the player
   * has another Pokémon and its own is still up. */
  private checkWhetherToAskSwitch() {
    return (
      !this.battleHasJustStarted &&
      this.options.shift !== false &&
      this.options.party.length > 1 &&
      this.partyMon.hp > 0
    );
  }
  /** OfferSwitch. Returns true if the player chose a Pokémon to send out. */
  private *offerSwitch(): Gen<boolean> {
    yield* this.say(BATTLE.BattleText_EnemyIsAboutToUseWillPlayerChangeMon);
    if (!(yield { kind: "yesno", text: "" })) return false;
    const slot = yield* this.pickSwitchMon();
    if (slot < 0) return false;
    this.lastPlayerMon = this.curBattleMon;
    this.curBattleMon = slot;
    this.enemy.curMove = 0;
    this.player.curMove = 0;
    return true;
  }

  // ------------------------------------------------------------ switching

  /** The battle party menu. Returns a party index, or -1 if cancelled;
   * without `cancel`, B is refused (ForcePickPartyMonInBattle's SFX_WRONG). */
  private *partyMenu(text: number, menu: boolean, cancel: boolean): Gen<number> {
    const prompt = readString(this.reader, text, this.context());
    for (;;) {
      const answer = yield { kind: "party", text: prompt, menu, cancel };
      if (typeof answer === "number" && Number.isInteger(answer) && answer >= 0 && answer < this.options.party.length)
      {
        this.partyMenuCursor = answer + 1; // PartyMenuSelect
        return (this.curPartyMon = answer);
      }
      if (cancel) return -1;
    }
  }
  /** CheckIfCurPartyMonIsFitToFight, with its texts. */
  private *checkFitToFight(slot: number): Gen<boolean> {
    const mon = this.options.party[slot];
    if (mon.hp) return true;
    if (!this.battleHasJustStarted)
      yield* this.say(mon.species === C.EGG ? BATTLE.BattleText_AnEGGCantBattle : BATTLE.BattleText_TheresNoWillToBattle);
    return false;
  }
  /** PickSwitchMonInBattle: a fit Pokémon other than the one out, or -1. */
  private *pickSwitchMon(): Gen<number> {
    for (;;) {
      const slot = yield* this.partyMenu(BATTLE.WhichPKMNString, false, true);
      if (slot < 0) return -1;
      if (!(yield* this.checkFitToFight(slot))) continue;
      if (slot === this.curBattleMon) {
        yield* this.say(BATTLE.BattleText_MonIsAlreadyOut);
        continue;
      }
      return slot;
    }
  }
  /** BattleMenu_PKMN with BattleMonMenu's SWITCH, then TryPlayerSwitch.
   * Returns true if the player switched, which takes the turn. STATS is
   * a presentation screen, and CANCEL returns to the party menu. */
  private *battleMenuPKMN(): Gen<boolean> {
    for (;;) {
      const slot = yield* this.partyMenu(BATTLE.ChooseAMonString, true, true);
      if (slot < 0) return false;
      if (slot === this.curBattleMon) {
        yield* this.say(BATTLE.BattleText_MonIsAlreadyOut);
        continue;
      }
      if (this.player.wrapCount || this.enemy.has(SUB5, C.SUBSTATUS_CANT_RUN)) {
        yield* this.say(BATTLE.BattleText_MonCantBeRecalled);
        continue;
      }
      if (!(yield* this.checkFitToFight(slot))) continue;
      this.lastPlayerMon = this.curBattleMon;
      this.battlePlayerAction = C.BATTLEPLAYERACTION_SWITCH;
      this.curBattleMon = slot;
      yield* this.playerSwitch();
      return true;
    }
  }
  /** PlayerSwitch: the enemy chooses its move, then BattleMonEntrance. */
  private *playerSwitch(): Gen {
    this.playerIsSwitching = 1;
    this.parseEnemyAction();
    yield* this.say(BATTLE["WithdrawMonText.WithdrawMonText"]);
    this.player.reset(SUB4, C.SUBSTATUS_RAGE);
    this.turn = 1;
    yield* this.pursuitSwitch();
    this.curPartyMon = this.curBattleMon;
    yield* this.sendOutPlayerMon();
  }
  /** PursuitSwitch: an opponent that chose Pursuit uses it on the Pokémon
   * being withdrawn, then cannot move this turn. A withdrawn Pokémon that
   * faints skips the usual faint handling and keeps its status (a kept
   * bug). Returns true if it fainted. */
  private *pursuitSwitch(): Gen<boolean> {
    const user = this.user,
      turn = this.turn;
    // GetMoveEffect, which reads past the table for no move.
    if (this.reader.byte(SYMBOLS.moves + ((user.curMove - 1) & 0xff) * 7 + 1) !== C.EFFECT_PURSUIT)
      return false;
    const current = this.curBattleMon;
    if (turn === 1) this.curBattleMon = this.lastPlayerMon;
    // DoPlayerTurn does nothing after an item or a switch.
    if (turn === 1 || !this.battlePlayerAction) yield* this.doTurn();
    this.turn = turn;
    user.curMove = 0xff; // CANNOT_MOVE
    this.curBattleMon = current;
    if (turn === 0) {
      if (this.enemy.mon.hp) return false;
      yield* this.say(BATTLE.BattleText_EnemyMonFainted);
      return true;
    }
    // UpdateBattleMon: the withdrawn Pokémon's level, status and HP.
    const outgoing = this.options.party[this.lastPlayerMon];
    outgoing.level = this.player.mon.level;
    outgoing.status = this.player.mon.status;
    outgoing.hp = this.player.mon.hp;
    if (this.player.mon.hp) return false;
    this.participants &= ~(1 << this.lastPlayerMon);
    yield* this.say(BATTLE.BattleText_MonFainted);
    return true;
  }
  /** PlayerPartyMonEntrance: send out wCurPartyMon. */
  private *playerPartyMonEntrance(): Gen {
    this.lastPlayerMon = this.curBattleMon;
    this.curBattleMon = this.curPartyMon;
    yield* this.sendOutPlayerMon();
  }
  /** The send-out shared by BattleMonEntrance, ForcePlayerMonChoice and
   * PlayerPartyMonEntrance. */
  private *sendOutPlayerMon(): Gen {
    this.addBattleParticipant();
    this.initBattleMon();
    this.checkAmuletCoin();
    yield* this.sendOutMonText();
    this.newStatus(this.player); // with ResetPlayerStatLevels
    this.breakAttraction();
    yield this.hud();
    this.turn = 0;
    yield* this.spikesDamage(this.player);
  }
  /** SendOutMonText: the cheer depends on the enemy's remaining HP. */
  private *sendOutMonText(): Gen {
    const { hp, maxHp } = this.enemy.mon;
    if (hp) this.enemyHPAtSwitch = hp;
    const text = sendOutText(hp, maxHp);
    if (!text) throw new UnsupportedBattle("A maximum HP below 4 freezes the original here.");
    yield* this.say(BATTLE[text]);
  }
  /** AskUseNextPokemon: only wild battles ask. NO tries to run, measured
   * with the first party Pokémon's Speed. Returns true if the player fled. */
  private *askUseNextPokemon(): Gen<boolean> {
    if (this.battleMode !== C.WILD_BATTLE) return false;
    yield* this.say(BATTLE.BattleText_UseNextMon);
    if (yield { kind: "yesno", text: "" }) return false;
    return yield* this.tryToRunAway(this.options.party[0].stats[3]);
  }
  /** ForcePlayerMonChoice. Returns false when the enemy fainted too: the
   * choice is then sent out by DoubleSwitch. */
  private *forcePlayerMonChoice(): Gen<boolean> {
    for (;;) {
      const slot = yield* this.partyMenu(BATTLE.WhichPKMNString, false, false);
      if (yield* this.checkFitToFight(slot)) break;
    }
    this.battlePlayerAction = 0;
    if (!this.enemy.mon.hp) return false;
    yield* this.playerPartyMonEntrance();
    return true;
  }
  /** DoubleSwitch: the player's choice, then the trainer's next Pokémon. */
  private *doubleSwitch(): Gen {
    yield* this.playerPartyMonEntrance();
    yield* this.enemyPartyMonEntrance(true);
    this.battlePlayerAction = 0;
  }
  /** ResetEnemyBattleVars. wEnemyItemState is unused while trainer items are refused. */
  private resetEnemyBattleVars() {
    this.player.lastCounterMove = 0;
    this.enemy.lastCounterMove = 0;
    this.enemy.lastMove = 0;
    this.enemy.curMove = 0;
    this.player.wrapCount = 0;
  }
  /** NewEnemyMonStatus: also clears the player's counter move, both wrap
   * counts and the player's inability to run. */
  private newEnemyMonStatus() {
    const enemy = this.enemy;
    this.player.lastCounterMove = 0;
    enemy.lastCounterMove = 0;
    enemy.lastMove = 0;
    enemy.sub = [0, 0, 0, 0, 0, 0];
    enemy.disableCount = 0;
    enemy.furyCutterCount = 0;
    enemy.protectCount = 0;
    enemy.rageCounter = 0;
    enemy.disabledMove = 0;
    enemy.minimized = 0;
    this.player.wrapCount = 0;
    enemy.wrapCount = 0;
    enemy.turnsTaken = 0;
    this.player.reset(SUB5, C.SUBSTATUS_CANT_RUN);
  }
  private breakAttraction() {
    this.player.reset(SUB1, C.SUBSTATUS_IN_LOVE);
    this.enemy.reset(SUB1, C.SUBSTATUS_IN_LOVE);
  }
  /** UpdateUsedMoves: append a new move, dropping the oldest when full. */
  private updateUsedMoves(move: number) {
    const used = this.playerUsedMoves;
    if (used.includes(move) && move) return;
    const empty = used.indexOf(0);
    if (empty >= 0) used[empty] = move;
    else this.playerUsedMoves = [used[1], used[2], used[3], move];
  }
  /** CheckTypeMatchup's wTypeMatchup (EFFECTIVE is 10). */
  private typeMatchup(moveType: number, types: readonly number[], identified: boolean) {
    return applyTypeMatchups(this.matchups, {
      damage: 0,
      modifier: 0,
      moveType,
      userTypes: [],
      targetTypes: types,
      identified,
    }).matchup;
  }

  /** FindMonInOTPartyToSwitchIntoBattle and ScoreMonTypeMatchups: prefer
   * the first Pokémon with a super-effective move that the player's types
   * don't also threaten, then the first unthreatened one, else a random
   * standing one (drawn with BattleRandom). */
  private findMonInOTPartyToSwitchIntoBattle(): number {
    const party = this.options.trainer!.party,
      data = this.options.data,
      count = party.length;
    // wEnemyEffectivenessVsPlayerMons / wPlayerEffectivenessVsEnemyMons,
    // each shifted left once per Pokémon from a sentinel bit.
    let enemyBits = 1,
      playerBits = 1;
    for (let index = 0; index < count; index++) {
      enemyBits = (enemyBits << 1) & 0xff;
      playerBits = (playerBits << 1) & 0xff;
      const mon = party[index];
      if (index === this.curOTMon || !mon.hp) {
        playerBits |= 1;
        continue;
      }
      // LookUpTheEffectivenessOfEveryMove, on the enemy's turn.
      for (const move of mon.moves) {
        if (!move) break;
        const identified = this.player.has(SUB1, C.SUBSTATUS_IDENTIFIED);
        if (this.typeMatchup(data.move(move).type, this.player.mon.types, identified) > C.EFFECTIVE) {
          enemyBits |= 1;
          break;
        }
      }
      // IsThePlayerMonTypesEffectiveAgainstOTMon, on the player's turn.
      const types = data.baseData(mon.species).types,
        identified = this.enemy.has(SUB1, C.SUBSTATUS_IDENTIFIED);
      if (this.player.mon.types.some((type) => this.typeMatchup(type, types, identified) > C.EFFECTIVE)) {
        if (enemyBits & 1) enemyBits &= ~1;
        else playerBits |= 1;
      }
    }
    enemyBits = (enemyBits << 1) & 0xff;
    playerBits = (playerBits << 1) & 0xff;
    // Align the first Pokémon to bit 7 by shifting the sentinel out.
    for (;;) {
      const carry = playerBits & 0x80;
      enemyBits = (enemyBits << 1) & 0xff;
      playerBits = (playerBits << 1) & 0xff;
      if (carry) break;
    }
    let discouraged = 0;
    while (discouraged < count && playerBits & (0x80 >> discouraged)) discouraged++;
    if (discouraged < count) {
      const bits = enemyBits || (~playerBits & 0xff);
      for (let index = 0; index < 8; index++) if (bits & (0x80 >> index)) return index;
    }
    for (let guard = 0; guard < 4096; guard++) {
      const index = this.random() & 7;
      if (index < count && index !== this.curOTMon && party[index].hp) return index;
    }
    throw new UnsupportedBattle("The trainer has no Pokémon to send out.");
  }

  /** AI_SwitchOrTryItem (engine/battle/ai/items.asm). Returns true when the
   * enemy spent its turn. Trainers holding items are refused before battle,
   * so AI_TryItem finds none. */
  private *aiSwitchOrTryItem(): Gen<boolean> {
    const trainer = this.options.trainer;
    if (!trainer || this.checkEnemyLockedIn()) return false;
    if (this.player.has(SUB5, C.SUBSTATUS_CANT_RUN) || this.enemy.wrapCount) return false;
    const style = [SWITCH_OFTEN, SWITCH_RARELY, SWITCH_SOMETIMES].findIndex(
      (bit) => trainer.switchFlags & bit,
    );
    if (style < 0) return false;
    const param = this.checkAbleToSwitch(),
      tier = param & 0xf0;
    if (!tier) return false;
    const [threshold, below] = SWITCH_CHANCES[style][Math.min(tier >> 4, 3) - 1];
    if (this.random() < threshold !== below) return false;
    this.enemySwitchMonIndex = (param & 0x0f) + 1;
    // AI_TrySwitch: the withdrawn Pokémon's stale party HP still counts.
    if (trainer.party.filter((mon) => mon.hp).length < 2) return false;
    yield* this.aiSwitch();
    return true;
  }
  /** AI_Switch: withdraw the enemy Pokémon and send out the chosen one. */
  private *aiSwitch(): Gen {
    const trainer = this.options.trainer!;
    this.enemyIsSwitching = 1;
    this.enemyGoesFirst = 1;
    this.enemy.reset(SUB4, C.SUBSTATUS_RAGE);
    this.turn = 0;
    const fainted = yield* this.pursuitSwitch();
    // Status and HP go back to the party (MON_STATUS through MON_HP).
    const outgoing = trainer.party[this.curOTMon];
    outgoing.status = this.enemy.mon.status;
    outgoing.hp = this.enemy.mon.hp;
    if (!fainted) yield* this.say(BATTLE.EnemyWithdrewText);
    this.battleHasJustStarted = 1;
    this.newEnemyMonStatus();
    this.enemy.levels = [7, 7, 7, 7, 7, 7, 7];
    this.player.reset(SUB1, C.SUBSTATUS_IN_LOVE);
    yield* this.enemySwitch();
    this.resetBattleParticipants();
    this.battleHasJustStarted = 0;
  }

  /** CheckAbleToSwitch (engine/battle/ai/switch.asm): wEnemySwitchMonParam,
   * a chance tier in the high nibble and a party index in the low one.
   * CheckTypeMatchup reads BATTLE_VARS_MOVE_TYPE rather than the type its
   * callers load, so with hBattleTurn on the enemy every matchup here uses
   * the enemy's chosen move type (docs/bugs_and_glitches.md). */
  private checkAbleToSwitch(): number {
    const party = this.options.trainer!.party,
      data = this.options.data;
    const matchup = (types: readonly number[]) =>
      this.typeMatchup(this.enemy.move.type, types, this.player.has(SUB1, C.SUBSTATUS_IDENTIFIED));
    const bit = (index: number) => 0x20 >> index;
    const damaging = (move: number) => data.move(move).power !== 0;
    const baseTypes = (index: number) => data.baseData(party[index].species).types;
    // FindAliveEnemyMons: the others still standing.
    const aliveOthers = () => {
      let mask = 0;
      if (party.length >= 2)
        party.forEach((mon, index) => {
          if (index !== this.curOTMon && mon.hp) mask |= bit(index);
        });
      return mask;
    };
    // FindEnemyMonsWithAtLeastQuarterMaxHP. BUG: srl c / rl b rotate the low
    // HP byte into the high byte instead of multiplying the HP by four.
    const quarterHP = (mask: number) => {
      let chosen = 0;
      party.forEach((mon, index) => {
        const high = mon.hp >> 8,
          low = mon.hp & 0xff;
        const rotated = ((((high << 2) | ((low & 1) << 1) | ((low >> 1) & 1)) & 0xff) << 8) | (low >> 2);
        if (rotated > mon.stats[0]) chosen |= bit(index);
      });
      return mask & chosen;
    };
    // FindEnemyMonsThatResistPlayer: every branch reduces to one matchup.
    const resisting = (mask: number) => {
      let chosen = 0;
      party.forEach((_, index) => {
        if (matchup(baseTypes(index)) <= C.EFFECTIVE) chosen |= bit(index);
      });
      return mask & chosen;
    };
    // FindEnemyMonsWithASuperEffectiveMove. `e` is not reset between
    // Pokémon, so one neutral move encourages every later candidate.
    const superEffective = (mask: number) => {
      let e = 0,
        encouraged = 0;
      for (let index = 0; index < 6; index++) {
        if (!(mask & bit(index))) continue;
        for (const move of party[index].moves) {
          if (!move) break;
          if (!damaging(move)) continue;
          const value = matchup(this.player.mon.types);
          if (value < C.EFFECTIVE) continue;
          e = 1;
          if (value === C.EFFECTIVE) continue;
          e = 2;
          break;
        }
        if (e === 2) return { e, score: index };
        if (e === 1) encouraged |= bit(index);
      }
      for (let index = 0; index < 6; index++) if (encouraged & bit(index)) return { e, score: index };
      return { e, score: 0xff };
    };
    // FindAliveEnemyMonsWithASuperEffectiveMove: standing, including the
    // current Pokémon.
    const standingSuperEffective = (mask: number) => {
      let standing = 0;
      party.forEach((mon, index) => {
        if (mon.hp) standing |= bit(index);
      });
      return superEffective(mask & standing);
    };

    if (!aliveOthers()) return 0;
    if (this.enemy.has(SUB1, C.SUBSTATUS_PERISH) && this.enemy.perishCount === 1) {
      // A last Perish count switches at the maximum chance, to the best
      // candidate or else the first one standing.
      const { e, score } = standingSuperEffective(resisting(quarterHP(aliveOthers())));
      if (e === 2) return (score + 0x30) & 0xff;
      const alive = aliveOthers();
      for (let index = 0; index < 6; index++) if (alive & bit(index)) return index + 0x30;
    }
    if (this.checkPlayerMoveTypeMatchups() > C.EFFECTIVE) return 0;
    const lastCounter = this.player.lastCounterMove;
    if (lastCounter) {
      // FindEnemyMonsImmuneToLastCounterMove.
      let immune = 0;
      party.forEach((mon, index) => {
        if (index === this.curOTMon || !mon.hp || !damaging(lastCounter)) return;
        if (matchup(baseTypes(index)) === 0) immune |= bit(index);
      });
      if (immune) {
        const { e, score } = superEffective(immune);
        if (score === 0xff) return 0;
        if (e !== 2) {
          if (this.checkPlayerMoveTypeMatchups() >= C.EFFECTIVE) return 0;
          return score + 0x10;
        }
        return score + (this.checkPlayerMoveTypeMatchups() < C.EFFECTIVE ? 0x20 : 0x10);
      }
    }
    if (this.checkPlayerMoveTypeMatchups() >= C.EFFECTIVE) return 0;
    const { e, score } = standingSuperEffective(resisting(quarterHP(aliveOthers())));
    return e === 2 ? score + 0x10 : 0;
  }
  /** CheckPlayerMoveTypeMatchups: wEnemyAISwitchScore from BASE_AI_SWITCH_SCORE
   * (10); lower means the enemy is worse off. Matchups use the enemy's move
   * type (see checkAbleToSwitch). */
  private checkPlayerMoveTypeMatchups(): number {
    const data = this.options.data,
      identified = this.player.has(SUB1, C.SUBSTATUS_IDENTIFIED),
      type = this.enemy.move.type;
    const vsEnemy = () => this.typeMatchup(type, this.enemy.mon.types, identified),
      vsPlayer = () => this.typeMatchup(type, this.player.mon.types, identified);
    let score = 10;
    const used = this.playerUsedMoves;
    if (!used[0]) {
      if (vsEnemy() > C.EFFECTIVE) score--;
      if (this.player.mon.types[1] !== this.player.mon.types[0] && vsEnemy() > C.EFFECTIVE) score--;
    } else {
      let e = 0,
        superEffective = false;
      for (const move of used) {
        if (!move) break;
        if (!data.move(move).power) continue;
        const value = vsEnemy();
        if (value > C.EFFECTIVE) {
          score--;
          superEffective = true;
          break;
        }
        if (!value) continue;
        if (value === C.EFFECTIVE) e = 2;
        else if (e < 1) e = 1;
      }
      if (!superEffective && e !== 2) score += e ? 1 : 2;
    }
    // .CheckEnemyMoveMatchups
    let c = 0;
    for (const move of this.enemy.mon.moves) {
      if (!move) break;
      if (!data.move(move).power) continue;
      const value = vsPlayer();
      if (!value) continue;
      c++;
      if (value < C.EFFECTIVE) continue;
      c += 5;
      if (value > C.EFFECTIVE) c = 100;
    }
    if (!c) score -= 2;
    else if (c < 5) score--;
    else if (c >= 100) score++;
    return score & 0xff;
  }
  private *faintYourPokemon(): Gen {
    yield* this.say(BATTLE.BattleText_MonFainted);
  }
  private *handlePlayerMonFaint(): Gen {
    yield* this.faintYourPokemon();
    if (!this.enemy.mon.hp) yield* this.say(BATTLE.BattleText_EnemyMonFainted);
    this.updateFaintedPlayerMon();
    if (!this.options.party.some((mon) => mon.hp > 0)) return yield* this.lostBattle();
    if (!this.enemy.mon.hp) {
      yield* this.updateStateAndExperienceAfterEnemyFaint(true);
      if (!this.options.trainer || this.enemyTrainerDefeated()) {
        this.battleEnded = true;
        return;
      }
    }
    if (yield* this.askUseNextPokemon()) {
      this.battleEnded = true;
      return;
    }
    if (yield* this.forcePlayerMonChoice()) return;
    this.battlePlayerAction = C.BATTLEPLAYERACTION_USEITEM;
    yield* this.doubleSwitch();
  }
  private updateFaintedPlayerMon() {
    this.participants &= ~(1 << this.curBattleMon);
    this.enemy.reset(SUB3, C.SUBSTATUS_IN_LOOP);
    this.player.damageTaken = 0;
    this.player.mon.status = 0;
    this.updateBattleMonInParty();
    // ChangeHappiness: fainting, or fainting to a much stronger foe.
    const strong = this.enemy.mon.level >= this.player.mon.level + 30;
    this.changeHappiness(this.curBattleMon, strong ? C.HAPPINESS_BEATENBYSTRONGFOE : C.HAPPINESS_FAINTED);
    this.battleResult = (this.battleResult & 0xc0) + C.LOSE;
  }
  /** ChangeHappiness: HappinessChanges by tier (below 100, below 200,
   * above). Eggs are skipped. In battle the battle Pokémon's copy follows
   * only when wCurPartyMon equals wPartyMenuCursor, which is 1-based. */
  private changeHappiness(index: number, action: number) {
    const mon = this.options.party[index];
    if (mon.species === C.EGG) return;
    const tier = mon.happiness < 100 ? 0 : mon.happiness < 200 ? 1 : 2;
    mon.happiness = changedHappiness(
      mon.happiness,
      this.reader.byte(BATTLE.HappinessChanges + (action - 1) * 3 + tier),
    );
    if (index === this.partyMenuCursor) this.player.mon.happiness = mon.happiness;
  }
  /** ResetBattleParticipants: only the Pokémon out, in both sets. */
  private resetBattleParticipants() {
    this.participants = this.participantsAll = 0;
    this.addBattleParticipant();
  }
  /** AddBattleParticipant. */
  private addBattleParticipant() {
    this.participants |= 1 << this.curBattleMon;
    this.participantsAll |= 1 << this.curBattleMon;
  }
  private *lostBattle(): Gen {
    this.battleEnded = true;
    this.battleResult = (this.battleResult & 0xc0) + C.LOSE;
  }

  /** UpdateBattleStateAndExperienceAfterEnemyFaint and GiveExperiencePoints. */
  private *updateStateAndExperienceAfterEnemyFaint(playerFaintedFirst: boolean): Gen {
    this.updateBattleMonInParty();
    const trainer = this.options.trainer;
    if (trainer) trainer.party[this.curOTMon].hp = 0;
    this.player.reset(SUB3, C.SUBSTATUS_IN_LOOP);
    this.enemy.damageTaken = 0;
    this.newEnemyMonStatus();
    this.breakAttraction();
    if (!this.player.mon.hp && !playerFaintedFirst) this.updateFaintedPlayerMon();
    if (!this.options.party.some((mon) => mon.hp > 0)) return;
    this.battleResult &= 0xc0; // WIN
    if (this.options.party.some((mon) => mon.hp > 0 && mon.item === C.EXP_SHARE))
      throw new UnsupportedBattle("Exp. Share is not ported yet.");
    yield* this.giveExperience();
  }
  private *giveExperience(): Gen {
    const party = this.options.party,
      data = this.options.data;
    const count = [0, 1, 2, 3, 4, 5].filter((index) => this.participants & (1 << index)).length;
    const base = { ...this.enemyBase, stats: [...this.enemyBase.stats] };
    if (count >= 2) {
      base.stats = base.stats.map((value) => Math.floor(value / count));
      base.catchRate = Math.floor(base.catchRate / count);
      base.exp = Math.floor(base.exp / count);
    }
    for (let index = 0; index < party.length; index++) {
      const mon = party[index];
      if (!mon.hp || !(this.participants & (1 << index))) continue;
      // Stat experience: the defeated Pokémon's base stats, twice with Pokérus.
      for (let stat = 0; stat < 5; stat++) {
        let value = mon.statExp[stat] + base.stats[stat];
        if (mon.pokerus) value += base.stats[stat];
        mon.statExp[stat] = Math.min(0xffff, value);
      }
      let exp = Math.floor((base.exp * this.enemy.mon.level) / 7);
      const traded = mon.otId !== this.options.playerId;
      const boost = (value: number) => value + (value >> 1);
      if (traded) exp = boost(exp);
      if (this.battleMode !== C.WILD_BATTLE) exp = boost(exp);
      if (mon.item === C.LUCKY_EGG) exp = boost(exp);
      exp &= 0xffff;
      this.numbers[RAM.stringBuffer2] = exp;
      this.numbers[RAM.stringBuffer2 + 2] = traded ? 1 : 0;
      this.strings[RAM.stringBuffer1] = mon.nickname;
      yield* this.say(BATTLE.Text_MonGainedExpPoint);
      const growth = data.baseData(mon.species).growthRate;
      mon.exp = Math.min(data.expAtLevel(growth, C.MAX_LEVEL), Math.min(0xffffff, mon.exp + exp));
      yield this.hud();
      const newLevel = this.levelForExp(mon.species, mon.exp);
      if (mon.level >= C.MAX_LEVEL || newLevel === mon.level) continue;
      const oldLevel = mon.level;
      mon.level = newLevel;
      const oldMax = mon.stats[0];
      mon.stats = calcStats(data, mon.species, mon.dvs, newLevel, mon.statExp);
      mon.hp = Math.min(mon.stats[0], mon.hp + (mon.stats[0] - oldMax));
      if (index === this.curBattleMon) {
        const side = this.player;
        side.mon.hp = mon.hp;
        side.mon.maxHp = mon.stats[0];
        side.mon.level = newLevel;
        side.stats = mon.stats.slice(1);
        this.calcStats(side);
      }
      // LevelUpHappinessMod: more where it was caught.
      this.changeHappiness(
        index,
        (mon.caughtData & 0x7f) === this.options.landmark ? C.HAPPINESS_GAINLEVELATHOME : C.HAPPINESS_GAINLEVEL,
      );
      this.strings[RAM.stringBuffer1] = mon.nickname;
      this.numbers[RAM.curPartyLevel] = newLevel;
      yield* this.say(BATTLE.BattleText_StringBuffer1GrewToLevel);
      yield this.hud();
      // PrintTempMonStats: Attack, Defense, Sp. Atk, Sp. Def, Speed.
      yield {
        kind: "stats",
        labels: readString(this.reader, BATTLE["PrintTempMonStats.StatNames"], this.context(), 64).split("\n").filter(Boolean),
        values: [mon.stats[1], mon.stats[2], mon.stats[4], mon.stats[5], mon.stats[3]],
      };
      for (let level = oldLevel + 1; level <= newLevel; level++) yield* this.learnLevelMoves(mon, index, level);
      this.evolvable |= 1 << index;
    }
    this.resetBattleParticipants();
  }
  /** CalcLevel: the highest level whose exp does not exceed the total. */
  private levelForExp(species: number, exp: number) {
    return levelForExp(this.options.data, species, exp);
  }
  /** LearnLevelMoves: moves the species learns at exactly this level. */
  private *learnLevelMoves(mon: PartyMon, index: number, level: number): Gen {
    for (const learned of this.options.data.learnset(mon.species)) {
      if (learned.level !== level || mon.moves.includes(learned.move)) continue;
      yield* this.learnMove(mon, index, learned.move);
    }
  }
  /** LearnMove, including the choice of a move to forget. */
  private *learnMove(mon: PartyMon, index: number, move: number): Gen {
    const data = this.options.data;
    this.strings[RAM.stringBuffer1] = mon.nickname;
    this.strings[RAM.monOrItemNameBuffer] = mon.nickname;
    this.strings[RAM.stringBuffer2] = data.moveName(move);
    for (;;) {
      let slot = mon.moves.indexOf(0);
      if (slot < 0) {
        slot = yield* this.forgetMove(mon);
        if (slot < 0) {
          yield* this.say(BATTLE.StopLearningMoveText);
          if (!(yield { kind: "yesno", text: "" })) continue;
          yield* this.say(BATTLE.DidNotLearnMoveText);
          return;
        }
        const forgotten = mon.moves[slot];
        if (this.player.disabledMove === forgotten) {
          this.player.disabledMove = 0;
          this.player.disableCount = 0;
        }
        this.strings[RAM.stringBuffer1] = data.moveName(forgotten);
        yield* this.say(BATTLE.Text_1_2_and_Poof);
      }
      mon.moves[slot] = move;
      mon.pp[slot] = data.move(move).pp;
      if (index === this.curBattleMon && !this.player.has(SUB5, C.SUBSTATUS_TRANSFORMED)) {
        this.player.mon.moves = [...mon.moves];
        this.player.mon.pp = [...mon.pp];
      }
      yield* this.say(BATTLE.LearnedMoveText);
      return;
    }
  }
  /** ForgetMove: returns the slot to replace, or -1 to stop. */
  private *forgetMove(mon: PartyMon): Gen<number> {
    yield* this.say(BATTLE.AskForgetMoveText);
    if (!(yield { kind: "yesno", text: "" })) return -1;
    for (;;) {
      yield* this.say(BATTLE.MoveAskForgetText);
      const choice = yield { kind: "forget", moves: [...mon.moves], learning: 0 };
      if (typeof choice !== "number" || choice < 0 || choice > 3) return -1;
      if (this.data.byteList(BATTLE["IsHMMove.HMMoves"]).includes(mon.moves[choice])) {
        yield* this.say(BATTLE.MoveCantForgetHMText);
        continue;
      }
      return choice;
    }
  }
}