"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var battle_actions_exports = {};
__export(battle_actions_exports, {
  BattleActions: () => BattleActions
});
module.exports = __toCommonJS(battle_actions_exports);
var import_dex = require("./dex");
const CHOOSABLE_TARGETS = /* @__PURE__ */ new Set(["normal", "any", "adjacentAlly", "adjacentAllyOrSelf", "adjacentFoe"]);
class BattleActions {
  constructor(battle) {
    this.MAX_MOVES = {
      Flying: "Max Airstream",
      Dark: "Max Darkness",
      Fire: "Max Flare",
      Bug: "Max Flutterby",
      Water: "Max Geyser",
      Status: "Max Guard",
      Ice: "Max Hailstorm",
      Fighting: "Max Knuckle",
      Electric: "Max Lightning",
      Psychic: "Max Mindstorm",
      Poison: "Max Ooze",
      Grass: "Max Overgrowth",
      Ghost: "Max Phantasm",
      Ground: "Max Quake",
      Rock: "Max Rockfall",
      Fairy: "Max Starfall",
      Steel: "Max Steelspike",
      Normal: "Max Strike",
      Dragon: "Max Wyrmwind"
    };
    this.Z_MOVES = {
      Poison: "Acid Downpour",
      Fighting: "All-Out Pummeling",
      Dark: "Black Hole Eclipse",
      Grass: "Bloom Doom",
      Normal: "Breakneck Blitz",
      Rock: "Continental Crush",
      Steel: "Corkscrew Crash",
      Dragon: "Devastating Drake",
      Electric: "Gigavolt Havoc",
      Water: "Hydro Vortex",
      Fire: "Inferno Overdrive",
      Ghost: "Never-Ending Nightmare",
      Bug: "Savage Spin-Out",
      Psychic: "Shattered Psyche",
      Ice: "Subzero Slammer",
      Flying: "Supersonic Skystrike",
      Ground: "Tectonic Rage",
      Fairy: "Twinkle Tackle"
    };
    this.battle = battle;
    this.dex = battle.dex;
    if (this.dex.data.Scripts.actions)
      Object.assign(this, this.dex.data.Scripts.actions);
    if (battle.format.actions)
      Object.assign(this, battle.format.actions);
  }
  // #region SWITCH
  // ==================================================================
  switchIn(pokemon, pos, sourceEffect = null, isDrag) {
    if (!pokemon || pokemon.isActive) {
      this.battle.hint("A switch failed because the Pok\xE9mon trying to switch in is already in.");
      return false;
    }
    const side = pokemon.side;
    if (pos >= side.active.length) {
      throw new Error(`Invalid switch position ${pos} / ${side.active.length}`);
    }
    const oldActive = side.active[pos];
    const unfaintedActive = oldActive?.hp ? oldActive : null;
    if (unfaintedActive) {
      oldActive.beingCalledBack = true;
      let switchCopyFlag = false;
      if (sourceEffect && typeof sourceEffect.selfSwitch === "string") {
        switchCopyFlag = sourceEffect.selfSwitch;
      }
      if (!oldActive.skipBeforeSwitchOutEventFlag && !isDrag) {
        this.battle.runEvent("BeforeSwitchOut", oldActive);
        if (this.battle.gen >= 5) {
          this.battle.eachEvent("Update");
        }
      }
      oldActive.skipBeforeSwitchOutEventFlag = false;
      if (!this.battle.runEvent("SwitchOut", oldActive)) {
        return false;
      }
      if (!oldActive.hp) {
        return "pursuitfaint";
      }
      oldActive.illusion = null;
      this.battle.singleEvent("End", oldActive.getAbility(), oldActive.abilityState, oldActive);
      this.battle.singleEvent("End", oldActive.getItem(), oldActive.itemState, oldActive);
      this.battle.queue.cancelAction(oldActive);
      let newMove = null;
      if (this.battle.gen === 4 && sourceEffect) {
        newMove = oldActive.lastMove;
      }
      if (switchCopyFlag) {
        pokemon.copyVolatileFrom(oldActive, switchCopyFlag);
      }
      if (newMove)
        pokemon.lastMove = newMove;
      oldActive.clearVolatile();
    }
    if (oldActive) {
      oldActive.isActive = false;
      oldActive.isStarted = false;
      oldActive.usedItemThisTurn = false;
      oldActive.statsRaisedThisTurn = false;
      oldActive.statsLoweredThisTurn = false;
      oldActive.position = pokemon.position;
      pokemon.position = pos;
      side.pokemon[pokemon.position] = pokemon;
      side.pokemon[oldActive.position] = oldActive;
    }
    pokemon.isActive = true;
    side.active[pos] = pokemon;
    pokemon.activeTurns = 0;
    pokemon.activeMoveActions = 0;
    for (const moveSlot of pokemon.moveSlots) {
      moveSlot.used = false;
    }
    pokemon.abilityState.effectOrder = this.battle.effectOrder++;
    pokemon.itemState.effectOrder = this.battle.effectOrder++;
    this.battle.runEvent("BeforeSwitchIn", pokemon);
    if (sourceEffect) {
      this.battle.add(isDrag ? "drag" : "switch", pokemon, pokemon.getFullDetails, `[from] ${sourceEffect}`);
    } else {
      this.battle.add(isDrag ? "drag" : "switch", pokemon, pokemon.getFullDetails);
    }
    if (isDrag && this.battle.gen === 2)
      pokemon.draggedIn = this.battle.turn;
    pokemon.previouslySwitchedIn++;
    if (isDrag && this.battle.gen >= 5) {
      this.runSwitch(pokemon);
    } else {
      this.battle.queue.insertChoice({ choice: "runSwitch", pokemon });
    }
    return true;
  }
  dragIn(side, pos) {
    const pokemon = this.battle.getRandomSwitchable(side);
    if (!pokemon || pokemon.isActive)
      return false;
    const oldActive = side.active[pos];
    if (!oldActive)
      throw new Error(`nothing to drag out`);
    if (!oldActive.hp)
      return false;
    if (!this.battle.runEvent("DragOut", oldActive)) {
      return false;
    }
    if (!this.switchIn(pokemon, pos, null, true))
      return false;
    return true;
  }
  runSwitch(pokemon) {
    const switchersIn = [pokemon];
    while (this.battle.queue.peek()?.choice === "runSwitch") {
      const nextSwitch = this.battle.queue.shift();
      switchersIn.push(nextSwitch.pokemon);
    }
    const allActive = this.battle.getAllActive(true);
    this.battle.speedSort(allActive);
    this.battle.speedOrder = allActive.map((a) => a.side.n * a.battle.sides.length + a.position);
    this.battle.fieldEvent("SwitchIn", switchersIn);
    for (const poke of switchersIn) {
      if (!poke.hp)
        continue;
      poke.isStarted = true;
      poke.draggedIn = null;
    }
    return true;
  }
  // #endregion
  // #region MOVES
  // ==================================================================
  /**
   * runMove is the "outside" move caller. It handles deducting PP,
   * flinching, full paralysis, etc. All the stuff up to and including
   * the "POKEMON used MOVE" message.
   *
   * For details of the difference between runMove and useMove, see
   * useMove's info.
   *
   * externalMove skips LockMove and PP deduction, mostly for use by
   * Dancer.
   */
  runMove(moveOrMoveName, pokemon, targetLoc, options) {
    pokemon.activeMoveActions++;
    const zMove = options?.zMove;
    const maxMove = options?.maxMove;
    const externalMove = options?.externalMove;
    const originalTarget = options?.originalTarget;
    let sourceEffect = options?.sourceEffect;
    let target = this.battle.getTarget(pokemon, maxMove || zMove || moveOrMoveName, targetLoc, originalTarget);
    let baseMove = this.dex.getActiveMove(moveOrMoveName);
    const priority = baseMove.priority;
    const pranksterBoosted = baseMove.pranksterBoosted;
    if (baseMove.id !== "struggle" && !zMove && !maxMove && !externalMove) {
      const changedMove = this.battle.runEvent("OverrideAction", pokemon, target, baseMove);
      if (changedMove && changedMove !== true) {
        baseMove = this.dex.getActiveMove(changedMove);
        baseMove.priority = priority;
        if (pranksterBoosted)
          baseMove.pranksterBoosted = pranksterBoosted;
        target = this.battle.getRandomTarget(pokemon, baseMove);
      }
    }
    let move = baseMove;
    if (zMove) {
      move = this.getActiveZMove(baseMove, pokemon);
    } else if (maxMove) {
      move = this.getActiveMaxMove(baseMove, pokemon);
    }
    move.isExternal = externalMove;
    this.battle.setActiveMove(move, pokemon, target);
    const willTryMove = this.battle.runEvent("BeforeMove", pokemon, target, move);
    if (!willTryMove) {
      this.battle.runEvent("MoveAborted", pokemon, target, move);
      this.battle.clearActiveMove(true);
      pokemon.moveThisTurnResult = willTryMove;
      return;
    }
    if (move.flags["cantusetwice"] && pokemon.lastMove?.id === move.id) {
      pokemon.addVolatile(move.id);
    }
    if (move.beforeMoveCallback) {
      if (move.beforeMoveCallback.call(this.battle, pokemon, target, move)) {
        this.battle.clearActiveMove(true);
        pokemon.moveThisTurnResult = false;
        return;
      }
    }
    pokemon.lastDamage = 0;
    let lockedMove;
    if (!externalMove) {
      lockedMove = this.battle.runEvent("LockMove", pokemon);
      if (lockedMove === true)
        lockedMove = false;
      if (!lockedMove) {
        if (!pokemon.deductPP(baseMove, null, target) && move.id !== "struggle") {
          this.battle.add("cant", pokemon, "nopp", move);
          this.battle.clearActiveMove(true);
          pokemon.moveThisTurnResult = false;
          return;
        }
      } else {
        sourceEffect = this.dex.conditions.get("lockedmove");
      }
      pokemon.moveUsed(move, targetLoc);
    }
    const noLock = externalMove && !pokemon.volatiles["lockedmove"];
    if (zMove) {
      if (pokemon.illusion) {
        this.battle.singleEvent("End", this.dex.abilities.get("Illusion"), pokemon.abilityState, pokemon);
      }
      this.battle.add("-zpower", pokemon);
      pokemon.side.zMoveUsed = true;
    }
    const oldActiveMove = move;
    const moveDidSomething = this.useMove(baseMove, pokemon, { target, sourceEffect, zMove, maxMove });
    this.battle.lastSuccessfulMoveThisTurn = moveDidSomething ? this.battle.activeMove && this.battle.activeMove.id : null;
    if (this.battle.activeMove)
      move = this.battle.activeMove;
    this.battle.singleEvent("AfterMove", move, null, pokemon, target, move);
    this.battle.runEvent("AfterMove", pokemon, target, move);
    if (move.flags["cantusetwice"] && pokemon.removeVolatile(move.id)) {
      this.battle.add("-hint", `Some effects can force a Pokemon to use ${move.name} again in a row.`);
    }
    if (move.flags["dance"] && moveDidSomething && !move.isExternal) {
      const dancers = [];
      for (const currentPoke of this.battle.getAllActive()) {
        if (pokemon === currentPoke)
          continue;
        if (currentPoke.hasAbility("dancer") && !currentPoke.isSemiInvulnerable()) {
          dancers.push(currentPoke);
        }
      }
      dancers.sort(
        (a, b) => -(b.storedStats["spe"] - a.storedStats["spe"]) || b.abilityState.effectOrder - a.abilityState.effectOrder
      );
      const targetOf1stDance = this.battle.activeTarget;
      for (const dancer of dancers) {
        if (this.battle.faintMessages())
          break;
        if (dancer.fainted)
          continue;
        this.battle.add("-activate", dancer, "ability: Dancer");
        const dancersTarget = !targetOf1stDance.isAlly(dancer) && pokemon.isAlly(dancer) ? targetOf1stDance : pokemon;
        const dancersTargetLoc = dancer.getLocOf(dancersTarget);
        this.runMove(move.id, dancer, dancersTargetLoc, { sourceEffect: this.dex.abilities.get("dancer"), externalMove: true });
      }
    }
    if (noLock && pokemon.volatiles["lockedmove"])
      delete pokemon.volatiles["lockedmove"];
    this.battle.faintMessages();
    this.battle.checkWin();
    if (this.battle.gen <= 4) {
      this.battle.activeMove = oldActiveMove;
    }
  }
  /**
   * useMove is the "inside" move caller. It handles effects of the
   * move itself, but not the idea of using the move.
   *
   * Most caller effects, like Sleep Talk, Nature Power, Magic Bounce,
   * etc use useMove.
   *
   * The only ones that use runMove are Instruct, Pursuit, and
   * Dancer.
   */
  useMove(move, pokemon, options) {
    pokemon.moveThisTurnResult = void 0;
    const oldMoveResult = pokemon.moveThisTurnResult;
    const moveResult = this.useMoveInner(move, pokemon, options);
    if (oldMoveResult === pokemon.moveThisTurnResult)
      pokemon.moveThisTurnResult = moveResult;
    return moveResult;
  }
  useMoveInner(moveOrMoveName, pokemon, options) {
    let target = options?.target;
    let sourceEffect = options?.sourceEffect;
    const zMove = options?.zMove;
    const maxMove = options?.maxMove;
    if (!sourceEffect && this.battle.effect.id)
      sourceEffect = this.battle.effect;
    if (sourceEffect && ["instruct", "custapberry"].includes(sourceEffect.id))
      sourceEffect = null;
    let move = this.dex.getActiveMove(moveOrMoveName);
    pokemon.lastMoveUsed = move;
    if (move.id === "weatherball" && zMove) {
      this.battle.singleEvent("ModifyType", move, null, pokemon, target, move, move);
      if (move.type !== "Normal")
        sourceEffect = move;
    }
    if (zMove || move.category !== "Status" && sourceEffect && sourceEffect.isZ) {
      move = this.getActiveZMove(move, pokemon);
    }
    if (maxMove && move.category !== "Status") {
      this.battle.singleEvent("ModifyType", move, null, pokemon, target, move, move);
      this.battle.runEvent("ModifyType", pokemon, target, move, move);
    }
    if (maxMove || move.category !== "Status" && sourceEffect && sourceEffect.isMax) {
      move = this.getActiveMaxMove(move, pokemon);
    }
    if (this.battle.activeMove) {
      move.priority = this.battle.activeMove.priority;
      if (!move.hasBounced)
        move.pranksterBoosted = this.battle.activeMove.pranksterBoosted;
    }
    const baseTarget = move.target;
    let targetRelayVar = { target };
    targetRelayVar = this.battle.runEvent("ModifyTarget", pokemon, target, move, targetRelayVar, true);
    if (targetRelayVar.target !== void 0)
      target = targetRelayVar.target;
    if (target === void 0)
      target = this.battle.getRandomTarget(pokemon, move);
    if (move.target === "self" || move.target === "allies") {
      target = pokemon;
    }
    if (sourceEffect) {
      move.sourceEffect = sourceEffect.id;
      move.ignoreAbility = sourceEffect.ignoreAbility;
    }
    let moveResult = false;
    this.battle.setActiveMove(move, pokemon, target);
    this.battle.singleEvent("ModifyType", move, null, pokemon, target, move, move);
    this.battle.singleEvent("ModifyMove", move, null, pokemon, target, move, move);
    if (baseTarget !== move.target) {
      target = this.battle.getRandomTarget(pokemon, move);
    }
    move = this.battle.runEvent("ModifyType", pokemon, target, move, move);
    move = this.battle.runEvent("ModifyMove", pokemon, target, move, move);
    if (baseTarget !== move.target) {
      target = this.battle.getRandomTarget(pokemon, move);
    }
    if (!move || pokemon.fainted) {
      return false;
    }
    let attrs = "";
    let movename = move.name;
    if (move.id === "hiddenpower")
      movename = "Hidden Power";
    if (sourceEffect)
      attrs += `|[from] ${sourceEffect.fullname}`;
    if (zMove && move.isZ === true) {
      attrs = `|[anim]${movename}${attrs}`;
      movename = `Z-${movename}`;
    }
    this.battle.addMove("move", pokemon, movename, `${target}${attrs}`);
    if (zMove)
      this.runZPower(move, pokemon);
    if (!target) {
      this.battle.attrLastMove("[notarget]");
      this.battle.add(this.battle.gen >= 5 ? "-fail" : "-notarget", pokemon);
      return false;
    }
    const { targets, pressureTargets } = pokemon.getMoveTargets(move, target);
    if (targets.length) {
      target = targets[targets.length - 1];
    }
    const callerMoveForPressure = sourceEffect && sourceEffect.pp ? sourceEffect : null;
    if (!sourceEffect || callerMoveForPressure || sourceEffect.id === "pursuit") {
      let extraPP = 0;
      for (const source of pressureTargets) {
        const ppDrop = this.battle.runEvent("DeductPP", source, pokemon, move);
        if (ppDrop !== true) {
          extraPP += ppDrop || 0;
        }
      }
      if (extraPP > 0) {
        pokemon.deductPP(callerMoveForPressure || moveOrMoveName, extraPP);
      }
    }
    if (!this.battle.singleEvent("TryMove", move, null, pokemon, target, move) || !this.battle.runEvent("TryMove", pokemon, target, move)) {
      move.mindBlownRecoil = false;
      return false;
    }
    this.battle.singleEvent("UseMoveMessage", move, null, pokemon, target, move);
    if (move.ignoreImmunity === void 0) {
      move.ignoreImmunity = move.category === "Status";
    }
    if (this.battle.gen !== 4 && move.selfdestruct === "always") {
      this.battle.faint(pokemon, pokemon, move);
    }
    let damage = false;
    if (move.target === "all" || move.target === "foeSide" || move.target === "allySide" || move.target === "allyTeam") {
      damage = this.tryMoveHit(targets, pokemon, move);
      if (damage === this.battle.NOT_FAIL)
        pokemon.moveThisTurnResult = null;
      if (damage || damage === 0 || damage === void 0)
        moveResult = true;
    } else {
      if (!targets.length) {
        this.battle.attrLastMove("[notarget]");
        this.battle.add(this.battle.gen >= 5 ? "-fail" : "-notarget", pokemon);
        return false;
      }
      if (this.battle.gen === 4 && move.selfdestruct === "always") {
        this.battle.faint(pokemon, pokemon, move);
      }
      moveResult = this.trySpreadMoveHit(targets, pokemon, move);
    }
    if (move.selfBoost && moveResult)
      this.moveHit(pokemon, pokemon, move, move.selfBoost, false, true);
    if (!pokemon.hp) {
      this.battle.faint(pokemon, pokemon, move);
    }
    if (!moveResult) {
      this.battle.singleEvent("MoveFail", move, null, target, pokemon, move);
      return false;
    }
    if (!move.negateSecondary && !(move.hasSheerForce && pokemon.hasAbility("sheerforce")) && !move.flags["futuremove"]) {
      const originalHp = pokemon.hp;
      this.battle.singleEvent("AfterMoveSecondarySelf", move, null, pokemon, target, move);
      this.battle.runEvent("AfterMoveSecondarySelf", pokemon, target, move);
      if (pokemon && pokemon !== target && move.category !== "Status") {
        if (pokemon.hp <= pokemon.maxhp / 2 && originalHp > pokemon.maxhp / 2) {
          this.battle.runEvent("EmergencyExit", pokemon, pokemon);
        }
      }
    }
    return true;
  }
  /** NOTE: includes single-target moves */
  trySpreadMoveHit(targets, pokemon, move, notActive) {
    if (targets.length > 1 && !move.smartTarget)
      move.spreadHit = true;
    const moveSteps = [
      // 0. check for semi invulnerability
      this.hitStepInvulnerabilityEvent,
      // 1. run the 'TryHit' event (Protect, Magic Bounce, Volt Absorb, etc.) (this is step 2 in gens 5 & 6, and step 4 in gen 4)
      this.hitStepTryHitEvent,
      // 2. check for type immunity (this is step 1 in gens 4-6)
      this.hitStepTypeImmunity,
      // 3. check for various move-specific immunities
      this.hitStepTryImmunity,
      // 4. check accuracy
      this.hitStepAccuracy,
      // 5. break protection effects
      this.hitStepBreakProtect,
      // 6. steal positive boosts (Spectral Thief)
      this.hitStepStealBoosts,
      // 7. loop that processes each hit of the move (has its own steps per iteration)
      this.hitStepMoveHitLoop
    ];
    if (this.battle.gen <= 6) {
      [moveSteps[1], moveSteps[2]] = [moveSteps[2], moveSteps[1]];
    }
    if (this.battle.gen === 4) {
      [moveSteps[2], moveSteps[4]] = [moveSteps[4], moveSteps[2]];
    }
    if (notActive)
      this.battle.setActiveMove(move, pokemon, targets[0]);
    const hitResult = this.battle.singleEvent("Try", move, null, pokemon, targets[0], move) && this.battle.singleEvent("PrepareHit", move, {}, targets[0], pokemon, move) && this.battle.runEvent("PrepareHit", pokemon, targets[0], move);
    if (!hitResult) {
      if (hitResult === false) {
        this.battle.add("-fail", pokemon);
        this.battle.attrLastMove("[still]");
      }
      return hitResult === this.battle.NOT_FAIL;
    }
    let atLeastOneFailure = false;
    for (const step of moveSteps) {
      const hitResults = step.call(this, targets, pokemon, move);
      if (!hitResults)
        continue;
      targets = targets.filter((val, i) => hitResults[i] || hitResults[i] === 0);
      atLeastOneFailure = atLeastOneFailure || hitResults.some((val) => val === false);
      if (move.smartTarget && atLeastOneFailure)
        move.smartTarget = false;
      if (!targets.length) {
        break;
      }
    }
    const moveResult = !!targets.length;
    if (!moveResult && !atLeastOneFailure)
      pokemon.moveThisTurnResult = null;
    const hitSlot = targets.map((p) => p.getSlot());
    if (move.spreadHit)
      this.battle.attrLastMove("[spread] " + hitSlot.join(","));
    return moveResult;
  }
  hitStepInvulnerabilityEvent(targets, pokemon, move) {
    if (move.id === "helpinghand")
      return new Array(targets.length).fill(true);
    const hitResults = [];
    for (const [i, target] of targets.entries()) {
      if (target.volatiles["commanding"]) {
        hitResults[i] = false;
      } else if (this.battle.gen >= 8 && move.id === "toxic" && pokemon.hasType("Poison")) {
        hitResults[i] = true;
      } else {
        hitResults[i] = this.battle.runEvent("Invulnerability", target, pokemon, move);
      }
      if (hitResults[i] === false) {
        if (move.smartTarget) {
          move.smartTarget = false;
        } else {
          if (!move.spreadHit)
            this.battle.attrLastMove("[miss]");
          this.battle.add("-miss", pokemon, target);
        }
      }
    }
    return hitResults;
  }
  hitStepTryHitEvent(targets, pokemon, move) {
    const hitResults = this.battle.runEvent("TryHit", targets, pokemon, move);
    if (!hitResults.includes(true) && hitResults.includes(false)) {
      this.battle.add("-fail", pokemon);
      this.battle.attrLastMove("[still]");
    }
    for (const i of targets.keys()) {
      if (hitResults[i] !== this.battle.NOT_FAIL)
        hitResults[i] = hitResults[i] || false;
    }
    return hitResults;
  }
  hitStepTypeImmunity(targets, pokemon, move) {
    if (move.ignoreImmunity === void 0) {
      move.ignoreImmunity = move.category === "Status";
    }
    const hitResults = [];
    for (const i of targets.keys()) {
      hitResults[i] = move.ignoreImmunity && (move.ignoreImmunity === true || move.ignoreImmunity[move.type]) || targets[i].runImmunity(move.type, !move.smartTarget);
    }
    return hitResults;
  }
  hitStepTryImmunity(targets, pokemon, move) {
    const hitResults = [];
    for (const [i, target] of targets.entries()) {
      if (this.battle.gen >= 6 && move.flags["powder"] && target !== pokemon && !this.dex.getImmunity("powder", target)) {
        this.battle.debug("natural powder immunity");
        this.battle.add("-immune", target);
        hitResults[i] = false;
      } else if (!this.battle.singleEvent("TryImmunity", move, {}, target, pokemon, move)) {
        this.battle.add("-immune", target);
        hitResults[i] = false;
      } else if (this.battle.gen >= 7 && move.pranksterBoosted && pokemon.hasAbility("prankster") && !targets[i].isAlly(pokemon) && !this.dex.getImmunity("prankster", target)) {
        this.battle.debug("natural prankster immunity");
        if (target.illusion || !(move.status && !this.dex.getImmunity(move.status, target))) {
          this.battle.hint("Since gen 7, Dark is immune to Prankster moves.");
        }
        this.battle.add("-immune", target);
        hitResults[i] = false;
      } else {
        hitResults[i] = true;
      }
    }
    return hitResults;
  }
  hitStepAccuracy(targets, pokemon, move) {
    const hitResults = [];
    for (const [i, target] of targets.entries()) {
      this.battle.activeTarget = target;
      let accuracy = move.accuracy;
      if (move.ohko) {
        if (!target.isSemiInvulnerable()) {
          accuracy = 30;
          if (move.ohko === "Ice" && this.battle.gen >= 7 && !pokemon.hasType("Ice")) {
            accuracy = 20;
          }
          if (!target.volatiles["dynamax"] && pokemon.level >= target.level && (move.ohko === true || !target.hasType(move.ohko))) {
            accuracy += pokemon.level - target.level;
          } else {
            this.battle.add("-immune", target, "[ohko]");
            hitResults[i] = false;
            continue;
          }
        }
      } else {
        accuracy = this.battle.runEvent("ModifyAccuracy", target, pokemon, move, accuracy);
        if (accuracy !== true) {
          let boost = 0;
          if (!move.ignoreAccuracy) {
            const boosts = this.battle.runEvent("ModifyBoost", pokemon, null, null, { ...pokemon.boosts });
            boost = this.battle.clampIntRange(boosts["accuracy"], -6, 6);
          }
          if (!move.ignoreEvasion) {
            const boosts = this.battle.runEvent("ModifyBoost", target, null, null, { ...target.boosts });
            boost = this.battle.clampIntRange(boost - boosts["evasion"], -6, 6);
          }
          if (boost > 0) {
            accuracy = this.battle.trunc(accuracy * (3 + boost) / 3);
          } else if (boost < 0) {
            accuracy = this.battle.trunc(accuracy * 3 / (3 - boost));
          }
        }
      }
      if (move.alwaysHit || move.id === "toxic" && this.battle.gen >= 8 && pokemon.hasType("Poison") || move.target === "self" && move.category === "Status" && !target.isSemiInvulnerable()) {
        accuracy = true;
      } else {
        accuracy = this.battle.runEvent("Accuracy", target, pokemon, move, accuracy);
      }
      if (accuracy !== true && !this.battle.randomChance(accuracy, 100)) {
        if (move.smartTarget) {
          move.smartTarget = false;
        } else {
          if (!move.spreadHit)
            this.battle.attrLastMove("[miss]");
          this.battle.add("-miss", pokemon, target);
        }
        if (!move.ohko && pokemon.hasItem("blunderpolicy") && pokemon.useItem()) {
          this.battle.boost({ spe: 2 }, pokemon);
        }
        hitResults[i] = false;
        continue;
      }
      hitResults[i] = true;
    }
    return hitResults;
  }
  hitStepBreakProtect(targets, pokemon, move) {
    if (move.breaksProtect) {
      for (const target of targets) {
        let broke = false;
        for (const effectid of [
          "banefulbunker",
          "burningbulwark",
          "kingsshield",
          "obstruct",
          "protect",
          "silktrap",
          "spikyshield"
        ]) {
          if (target.removeVolatile(effectid))
            broke = true;
        }
        if (this.battle.gen >= 6 || !target.isAlly(pokemon)) {
          for (const effectid of ["craftyshield", "matblock", "quickguard", "wideguard"]) {
            if (target.side.removeSideCondition(effectid))
              broke = true;
          }
        }
        if (broke) {
          if (move.id === "feint") {
            this.battle.add("-activate", target, "move: Feint");
          } else {
            this.battle.add("-activate", target, `move: ${move.name}`, "[broken]");
          }
          if (this.battle.gen >= 6)
            delete target.volatiles["stall"];
        }
      }
    }
    return void 0;
  }
  hitStepStealBoosts(targets, pokemon, move) {
    const target = targets[0];
    if (move.stealsBoosts) {
      const boosts = {};
      let stolen = false;
      let statName;
      for (statName in target.boosts) {
        const stage = target.boosts[statName];
        if (stage > 0) {
          boosts[statName] = stage;
          stolen = true;
        }
      }
      if (stolen) {
        this.battle.attrLastMove("[still]");
        this.battle.add("-clearpositiveboost", target, pokemon, "move: " + move.name);
        this.battle.boost(boosts, pokemon, pokemon);
        let statName2;
        for (statName2 in boosts) {
          boosts[statName2] = 0;
        }
        target.setBoost(boosts);
        if (move.id === "spectralthief") {
          this.battle.addMove("-anim", pokemon, "Spectral Thief", target);
        }
      }
    }
    return void 0;
  }
  afterMoveSecondaryEvent(targets, pokemon, move) {
    if (!move.negateSecondary && !(move.hasSheerForce && pokemon.hasAbility("sheerforce"))) {
      this.battle.singleEvent("AfterMoveSecondary", move, null, targets[0], pokemon, move);
      this.battle.runEvent("AfterMoveSecondary", targets, pokemon, move);
    }
    return void 0;
  }
  /** NOTE: used only for moves that target sides/fields rather than pokemon */
  tryMoveHit(targetOrTargets, pokemon, move) {
    const target = Array.isArray(targetOrTargets) ? targetOrTargets[0] : targetOrTargets;
    const targets = Array.isArray(targetOrTargets) ? targetOrTargets : [target];
    this.battle.setActiveMove(move, pokemon, targets[0]);
    let hitResult = this.battle.singleEvent("Try", move, null, pokemon, target, move) && this.battle.singleEvent("PrepareHit", move, {}, target, pokemon, move) && this.battle.runEvent("PrepareHit", pokemon, target, move);
    if (!hitResult) {
      if (hitResult === false) {
        this.battle.add("-fail", pokemon);
        this.battle.attrLastMove("[still]");
      }
      return false;
    }
    const isFFAHazard = move.target === "foeSide" && this.battle.gameType === "freeforall";
    if (move.target === "all") {
      hitResult = this.battle.runEvent("TryHitField", target, pokemon, move);
    } else if (isFFAHazard) {
      const hitResults = this.battle.runEvent("TryHitSide", targets, pokemon, move);
      if (hitResults.some((result) => !result))
        return false;
      hitResult = true;
    } else {
      hitResult = this.battle.runEvent("TryHitSide", target, pokemon, move);
    }
    if (!hitResult) {
      if (hitResult === false) {
        this.battle.add("-fail", pokemon);
        this.battle.attrLastMove("[still]");
      }
      return false;
    }
    return this.moveHit(isFFAHazard ? targets : target, pokemon, move);
  }
  hitStepMoveHitLoop(targets, pokemon, move) {
    let damage = [];
    for (const i of targets.keys()) {
      damage[i] = 0;
    }
    move.totalDamage = 0;
    pokemon.lastDamage = 0;
    let targetHits = move.multihit || 1;
    if (Array.isArray(targetHits)) {
      if (targetHits[0] === 2 && targetHits[1] === 5) {
        if (this.battle.gen >= 5) {
          targetHits = this.battle.sample([2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5]);
          if (targetHits < 4 && pokemon.hasItem("loadeddice")) {
            targetHits = 5 - this.battle.random(2);
          }
        } else {
          targetHits = this.battle.sample([2, 2, 2, 3, 3, 3, 4, 5]);
        }
      } else {
        targetHits = this.battle.random(targetHits[0], targetHits[1] + 1);
      }
    }
    if (targetHits === 10 && pokemon.hasItem("loadeddice"))
      targetHits -= this.battle.random(7);
    targetHits = Math.floor(targetHits);
    let nullDamage = true;
    let moveDamage = [];
    const isSleepUsable = move.sleepUsable || this.dex.moves.get(move.sourceEffect).sleepUsable;
    let targetsCopy = targets.slice(0);
    let hit;
    for (hit = 1; hit <= targetHits; hit++) {
      if (damage.includes(false))
        break;
      if (hit > 1 && pokemon.status === "slp" && (!isSleepUsable || this.battle.gen === 4))
        break;
      if (targets.every((target2) => !target2?.hp))
        break;
      move.hit = hit;
      if (move.smartTarget && targets.length > 1) {
        targetsCopy = [targets[hit - 1]];
        damage = [damage[hit - 1]];
      } else {
        targetsCopy = targets.slice(0);
      }
      const target = targetsCopy[0];
      if (target && typeof move.smartTarget === "boolean") {
        if (hit > 1) {
          this.battle.addMove("-anim", pokemon, move.name, target);
        } else {
          this.battle.retargetLastMove(target);
        }
      }
      if (target && move.multiaccuracy && hit > 1) {
        let accuracy = move.accuracy;
        const boostTable = [1, 4 / 3, 5 / 3, 2, 7 / 3, 8 / 3, 3];
        if (accuracy !== true) {
          if (!move.ignoreAccuracy) {
            const boosts = this.battle.runEvent("ModifyBoost", pokemon, null, null, { ...pokemon.boosts });
            const boost = this.battle.clampIntRange(boosts["accuracy"], -6, 6);
            if (boost > 0) {
              accuracy *= boostTable[boost];
            } else {
              accuracy /= boostTable[-boost];
            }
          }
          if (!move.ignoreEvasion) {
            const boosts = this.battle.runEvent("ModifyBoost", target, null, null, { ...target.boosts });
            const boost = this.battle.clampIntRange(boosts["evasion"], -6, 6);
            if (boost > 0) {
              accuracy /= boostTable[boost];
            } else if (boost < 0) {
              accuracy *= boostTable[-boost];
            }
          }
        }
        accuracy = this.battle.runEvent("ModifyAccuracy", target, pokemon, move, accuracy);
        if (!move.alwaysHit) {
          accuracy = this.battle.runEvent("Accuracy", target, pokemon, move, accuracy);
          if (accuracy !== true && !this.battle.randomChance(accuracy, 100))
            break;
        }
      }
      const moveData = move;
      if (!moveData.flags)
        moveData.flags = {};
      let moveDamageThisHit;
      [moveDamageThisHit, targetsCopy] = this.spreadMoveHit(targetsCopy, pokemon, move, moveData);
      if (move.smartTarget) {
        moveDamage.push(...moveDamageThisHit);
      } else {
        moveDamage = moveDamageThisHit;
      }
      if (!moveDamage.some((val) => val !== false))
        break;
      nullDamage = false;
      for (const [i, md] of moveDamage.entries()) {
        if (move.smartTarget && i !== hit - 1)
          continue;
        damage[i] = md === true || !md ? 0 : md;
        move.totalDamage += damage[i];
      }
      if (move.mindBlownRecoil) {
        const hpBeforeRecoil = pokemon.hp;
        this.battle.damage(Math.round(pokemon.maxhp / 2), pokemon, pokemon, this.dex.conditions.get(move.id), true);
        move.mindBlownRecoil = false;
        if (pokemon.hp <= pokemon.maxhp / 2 && hpBeforeRecoil > pokemon.maxhp / 2) {
          this.battle.runEvent("EmergencyExit", pokemon, pokemon);
        }
      }
      this.battle.eachEvent("Update");
      if (!pokemon.hp && targets.length === 1) {
        hit++;
        break;
      }
    }
    if (hit === 1)
      return damage.fill(false);
    if (nullDamage)
      damage.fill(false);
    this.battle.faintMessages(false, false, !pokemon.hp);
    if (move.multihit && typeof move.smartTarget !== "boolean") {
      this.battle.add("-hitcount", targets[0], hit - 1);
    }
    if ((move.recoil || move.id === "chloroblast") && move.totalDamage) {
      const hpBeforeRecoil = pokemon.hp;
      this.battle.damage(this.calcRecoilDamage(move.totalDamage, move, pokemon), pokemon, pokemon, "recoil");
      if (pokemon.hp <= pokemon.maxhp / 2 && hpBeforeRecoil > pokemon.maxhp / 2) {
        this.battle.runEvent("EmergencyExit", pokemon, pokemon);
      }
    }
    if (move.struggleRecoil) {
      const hpBeforeRecoil = pokemon.hp;
      let recoilDamage;
      if (this.dex.gen >= 5) {
        recoilDamage = this.battle.clampIntRange(Math.round(pokemon.baseMaxhp / 4), 1);
      } else {
        recoilDamage = this.battle.clampIntRange(this.battle.trunc(pokemon.maxhp / 4), 1);
      }
      this.battle.directDamage(recoilDamage, pokemon, pokemon, { id: "strugglerecoil" });
      if (pokemon.hp <= pokemon.maxhp / 2 && hpBeforeRecoil > pokemon.maxhp / 2) {
        this.battle.runEvent("EmergencyExit", pokemon, pokemon);
      }
    }
    if (move.smartTarget) {
      targetsCopy = targets.slice(0);
    }
    for (const [i, target] of targetsCopy.entries()) {
      if (target && pokemon !== target) {
        target.gotAttacked(move, moveDamage[i], pokemon);
        if (typeof moveDamage[i] === "number") {
          target.timesAttacked += move.smartTarget ? 1 : hit - 1;
        }
      }
    }
    if (move.ohko && !targets[0].hp)
      this.battle.add("-ohko");
    if (!damage.some((val) => !!val || val === 0))
      return damage;
    this.battle.eachEvent("Update");
    this.afterMoveSecondaryEvent(targetsCopy.filter((val) => !!val), pokemon, move);
    if (!move.negateSecondary && !(move.hasSheerForce && pokemon.hasAbility("sheerforce"))) {
      for (const [i, d] of damage.entries()) {
        const curDamage = targets.length === 1 ? move.totalDamage : d;
        if (typeof curDamage === "number" && targets[i].hp) {
          const targetHPBeforeDamage = (targets[i].hurtThisTurn || 0) + curDamage;
          if (targets[i].hp <= targets[i].maxhp / 2 && targetHPBeforeDamage > targets[i].maxhp / 2) {
            this.battle.runEvent("EmergencyExit", targets[i], pokemon);
          }
        }
      }
    }
    return damage;
  }
  spreadMoveHit(targets, pokemon, moveOrMoveName, hitEffect, isSecondary, isSelf) {
    const target = targets[0];
    let damage = [];
    for (const i of targets.keys()) {
      damage[i] = true;
    }
    const move = this.dex.getActiveMove(moveOrMoveName);
    let hitResult = true;
    let moveData = hitEffect;
    if (!moveData)
      moveData = move;
    if (!moveData.flags)
      moveData.flags = {};
    if (move.target === "all" && !isSelf) {
      hitResult = this.battle.singleEvent("TryHitField", moveData, {}, target || null, pokemon, move);
    } else if ((move.target === "foeSide" || move.target === "allySide" || move.target === "allyTeam") && !isSelf) {
      hitResult = this.battle.singleEvent("TryHitSide", moveData, {}, target || null, pokemon, move);
    } else if (target) {
      hitResult = this.battle.singleEvent("TryHit", moveData, {}, target, pokemon, move);
    }
    if (!hitResult) {
      if (hitResult === false) {
        this.battle.add("-fail", pokemon);
        this.battle.attrLastMove("[still]");
      }
      return [[false], targets];
    }
    if (!isSecondary && !isSelf) {
      if (move.target !== "all" && move.target !== "allyTeam" && move.target !== "allySide" && move.target !== "foeSide") {
        damage = this.tryPrimaryHitEvent(damage, targets, pokemon, move, moveData, isSecondary);
      }
    }
    for (const i of targets.keys()) {
      if (damage[i] === this.battle.HIT_SUBSTITUTE) {
        damage[i] = true;
        targets[i] = null;
      }
      if (targets[i] && isSecondary && !moveData.self) {
        damage[i] = true;
      }
      if (!damage[i])
        targets[i] = false;
    }
    damage = this.getSpreadDamage(damage, targets, pokemon, move, moveData, isSecondary, isSelf);
    for (const i of targets.keys()) {
      if (damage[i] === false)
        targets[i] = false;
    }
    damage = this.battle.spreadDamage(damage, targets, pokemon, move);
    for (const i of targets.keys()) {
      if (damage[i] === false)
        targets[i] = false;
    }
    damage = this.runMoveEffects(damage, targets, pokemon, move, moveData, isSecondary, isSelf);
    for (const i of targets.keys()) {
      if (!damage[i] && damage[i] !== 0)
        targets[i] = false;
    }
    const activeTarget = this.battle.activeTarget;
    if (moveData.self && !move.selfDropped)
      this.selfDrops(targets, pokemon, move, moveData, isSecondary);
    if (moveData.secondaries)
      this.secondaries(targets, pokemon, move, moveData, isSelf);
    this.battle.activeTarget = activeTarget;
    if (moveData.forceSwitch)
      damage = this.forceSwitch(damage, targets, pokemon, move);
    for (const i of targets.keys()) {
      if (!damage[i] && damage[i] !== 0)
        targets[i] = false;
    }
    const damagedTargets = [];
    const damagedDamage = [];
    for (const [i, t] of targets.entries()) {
      if (typeof damage[i] === "number" && t) {
        damagedTargets.push(t);
        damagedDamage.push(damage[i]);
      }
    }
    const pokemonOriginalHP = pokemon.hp;
    if (damagedDamage.length && !isSecondary && !isSelf) {
      this.battle.runEvent("DamagingHit", damagedTargets, pokemon, move, damagedDamage);
      if (moveData.onAfterHit) {
        for (const t of damagedTargets) {
          this.battle.singleEvent("AfterHit", moveData, {}, t, pokemon, move);
        }
      }
      if (pokemon.hp && pokemon.hp <= pokemon.maxhp / 2 && pokemonOriginalHP > pokemon.maxhp / 2) {
        this.battle.runEvent("EmergencyExit", pokemon);
      }
    }
    return [damage, targets];
  }
  tryPrimaryHitEvent(damage, targets, pokemon, move, moveData, isSecondary) {
    for (const [i, target] of targets.entries()) {
      if (!target)
        continue;
      damage[i] = this.battle.runEvent("TryPrimaryHit", target, pokemon, moveData);
    }
    return damage;
  }
  getSpreadDamage(damage, targets, source, move, moveData, isSecondary, isSelf) {
    for (const [i, target] of targets.entries()) {
      if (!target)
        continue;
      this.battle.activeTarget = target;
      damage[i] = void 0;
      const curDamage = this.getDamage(source, target, moveData);
      if (curDamage === false || curDamage === null) {
        if (damage[i] === false && !isSecondary && !isSelf) {
          this.battle.add("-fail", source);
          this.battle.attrLastMove("[still]");
        }
        this.battle.debug("damage calculation interrupted");
        damage[i] = false;
        continue;
      }
      damage[i] = curDamage;
    }
    return damage;
  }
  runMoveEffects(damage, targets, source, move, moveData, isSecondary, isSelf) {
    let didAnything = damage.reduce(this.combineResults);
    for (const [i, target] of targets.entries()) {
      if (target === false)
        continue;
      let hitResult;
      let didSomething = void 0;
      if (target) {
        if (moveData.boosts && !target.fainted) {
          hitResult = this.battle.boost(moveData.boosts, target, source, move, isSecondary, isSelf);
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (moveData.heal && !target.fainted) {
          if (target.hp >= target.maxhp) {
            this.battle.add("-fail", target, "heal");
            this.battle.attrLastMove("[still]");
            damage[i] = this.combineResults(damage[i], false);
            didAnything = this.combineResults(didAnything, null);
            continue;
          }
          const amount = target.baseMaxhp * moveData.heal[0] / moveData.heal[1];
          const d = target.heal((this.battle.gen < 5 ? Math.floor : Math.round)(amount));
          if (!d && d !== 0) {
            this.battle.add("-fail", source);
            this.battle.attrLastMove("[still]");
            this.battle.debug("heal interrupted");
            damage[i] = this.combineResults(damage[i], false);
            didAnything = this.combineResults(didAnything, null);
            continue;
          }
          this.battle.add("-heal", target, target.getHealth);
          didSomething = true;
        }
        if (moveData.status) {
          hitResult = target.trySetStatus(moveData.status, source, moveData.ability ? moveData.ability : move);
          if (!hitResult && move.status) {
            damage[i] = this.combineResults(damage[i], false);
            didAnything = this.combineResults(didAnything, null);
            continue;
          }
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (moveData.forceStatus) {
          hitResult = target.setStatus(moveData.forceStatus, source, move);
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (moveData.volatileStatus) {
          hitResult = target.addVolatile(moveData.volatileStatus, source, move);
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (moveData.sideCondition) {
          hitResult = target.side.addSideCondition(moveData.sideCondition, source, move);
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (moveData.slotCondition) {
          hitResult = target.side.addSlotCondition(target, moveData.slotCondition, source, move);
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (moveData.weather) {
          hitResult = this.battle.field.setWeather(moveData.weather, source, move);
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (moveData.terrain) {
          hitResult = this.battle.field.setTerrain(moveData.terrain, source, move);
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (moveData.pseudoWeather) {
          hitResult = this.battle.field.addPseudoWeather(moveData.pseudoWeather, source, move);
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (moveData.forceSwitch) {
          hitResult = !!this.battle.canSwitch(target.side);
          didSomething = this.combineResults(didSomething, hitResult);
        }
        if (move.target === "all" && !isSelf) {
          if (moveData.onHitField) {
            hitResult = this.battle.singleEvent("HitField", moveData, {}, target, source, move);
            didSomething = this.combineResults(didSomething, hitResult);
          }
        } else if ((move.target === "foeSide" || move.target === "allySide") && !isSelf) {
          if (moveData.onHitSide) {
            hitResult = this.battle.singleEvent("HitSide", moveData, {}, target.side, source, move);
            didSomething = this.combineResults(didSomething, hitResult);
          }
        } else {
          if (moveData.onHit) {
            hitResult = this.battle.singleEvent("Hit", moveData, {}, target, source, move);
            didSomething = this.combineResults(didSomething, hitResult);
          }
          if (!isSelf && !isSecondary) {
            this.battle.runEvent("Hit", target, source, move);
          }
        }
      }
      if (moveData.selfdestruct === "ifHit" && damage[i] !== false) {
        this.battle.faint(source, source, move);
      }
      if (moveData.selfSwitch) {
        if (this.battle.canSwitch(source.side) && !source.volatiles["commanded"]) {
          didSomething = true;
        } else {
          didSomething = this.combineResults(didSomething, false);
        }
      }
      if (didSomething === void 0)
        didSomething = true;
      damage[i] = this.combineResults(damage[i], didSomething === null ? false : didSomething);
      didAnything = this.combineResults(didAnything, didSomething);
    }
    if (!didAnything && didAnything !== 0 && !moveData.self && !moveData.selfdestruct) {
      if (!isSelf && !isSecondary) {
        if (didAnything === false) {
          this.battle.add("-fail", source);
          this.battle.attrLastMove("[still]");
        }
      }
      this.battle.debug("move failed because it did nothing");
    } else if (move.selfSwitch && source.hp && !source.volatiles["commanded"]) {
      source.switchFlag = move.id;
    }
    return damage;
  }
  selfDrops(targets, source, move, moveData, isSecondary) {
    for (const target of targets) {
      if (target === false)
        continue;
      if (moveData.self && !move.selfDropped) {
        if (!isSecondary && moveData.self.boosts) {
          const secondaryRoll = this.battle.random(100);
          if (typeof moveData.self.chance === "undefined" || secondaryRoll < moveData.self.chance) {
            this.moveHit(source, source, move, moveData.self, isSecondary, true);
          }
          if (!move.multihit)
            move.selfDropped = true;
        } else {
          this.moveHit(source, source, move, moveData.self, isSecondary, true);
        }
      }
    }
  }
  secondaries(targets, source, move, moveData, isSelf) {
    if (!moveData.secondaries)
      return;
    for (const target of targets) {
      if (target === false)
        continue;
      const secondaries = this.battle.runEvent("ModifySecondaries", target, source, moveData, moveData.secondaries.slice());
      for (const secondary of secondaries) {
        const secondaryRoll = this.battle.random(100);
        const secondaryOverflow = (secondary.boosts || secondary.self) && this.battle.gen <= 8;
        if (typeof secondary.chance === "undefined" || secondaryRoll < (secondaryOverflow ? secondary.chance % 256 : secondary.chance)) {
          this.moveHit(target, source, move, secondary, true, isSelf);
        }
      }
    }
  }
  forceSwitch(damage, targets, source, move) {
    for (const [i, target] of targets.entries()) {
      if (target && target.hp > 0 && source.hp > 0 && this.battle.canSwitch(target.side)) {
        const hitResult = this.battle.runEvent("DragOut", target, source, move);
        if (hitResult) {
          target.forceSwitchFlag = true;
        } else if (hitResult === false && move.category === "Status") {
          this.battle.add("-fail", source);
          this.battle.attrLastMove("[still]");
          damage[i] = false;
        }
      }
    }
    return damage;
  }
  moveHit(targets, pokemon, moveOrMoveName, moveData, isSecondary, isSelf) {
    if (!Array.isArray(targets))
      targets = [targets];
    const retVal = this.spreadMoveHit(targets, pokemon, moveOrMoveName, moveData, isSecondary, isSelf)[0][0];
    return retVal === true ? void 0 : retVal;
  }
  calcRecoilDamage(damageDealt, move, pokemon) {
    if (move.id === "chloroblast")
      return Math.round(pokemon.maxhp / 2);
    return this.battle.clampIntRange(Math.round(damageDealt * move.recoil[0] / move.recoil[1]), 1);
  }
  getZMove(move, pokemon, skipChecks) {
    const item = pokemon.getItem();
    if (!skipChecks) {
      if (pokemon.side.zMoveUsed)
        return;
      if (!item.zMove)
        return;
      if (item.itemUser && !item.itemUser.includes(pokemon.species.name))
        return;
      const moveData = pokemon.getMoveData(move);
      if (!moveData?.pp)
        return;
    }
    if (item.zMoveFrom) {
      if (move.name === item.zMoveFrom)
        return item.zMove;
    } else if (item.zMove === true) {
      if (move.type === item.zMoveType) {
        if (move.category === "Status") {
          return move.name;
        } else if (move.zMove?.basePower) {
          return this.Z_MOVES[move.type];
        }
      }
    }
  }
  getActiveZMove(move, pokemon) {
    if (pokemon) {
      const item = pokemon.getItem();
      if (move.name === item.zMoveFrom) {
        const zMove2 = this.dex.getActiveMove(item.zMove);
        zMove2.isZOrMaxPowered = true;
        return zMove2;
      }
    }
    if (move.category === "Status") {
      const zMove2 = this.dex.getActiveMove(move);
      zMove2.isZ = true;
      zMove2.isZOrMaxPowered = true;
      return zMove2;
    }
    const zMove = this.dex.getActiveMove(this.Z_MOVES[move.type]);
    zMove.basePower = move.zMove.basePower;
    zMove.category = move.category;
    zMove.priority = move.priority;
    zMove.isZOrMaxPowered = true;
    return zMove;
  }
  canZMove(pokemon) {
    if (pokemon.side.zMoveUsed || pokemon.transformed && (pokemon.species.isMega || pokemon.species.isPrimal || pokemon.species.forme === "Ultra"))
      return;
    const item = pokemon.getItem();
    if (!item.zMove)
      return;
    if (item.itemUser && !item.itemUser.includes(pokemon.species.name))
      return;
    let atLeastOne = false;
    let mustStruggle = true;
    const zMoves = [];
    for (const moveSlot of pokemon.moveSlots) {
      if (moveSlot.pp <= 0) {
        zMoves.push(null);
        continue;
      }
      if (!moveSlot.disabled) {
        mustStruggle = false;
      }
      const move = this.dex.moves.get(moveSlot.move);
      let zMoveName = this.getZMove(move, pokemon, true) || "";
      if (zMoveName) {
        const zMove = this.dex.moves.get(zMoveName);
        if (!zMove.isZ && zMove.category === "Status")
          zMoveName = "Z-" + zMoveName;
        zMoves.push({ move: zMoveName, target: zMove.target });
      } else {
        zMoves.push(null);
      }
      if (zMoveName)
        atLeastOne = true;
    }
    if (atLeastOne && !mustStruggle)
      return zMoves;
  }
  getMaxMove(move, pokemon) {
    if (typeof move === "string")
      move = this.dex.moves.get(move);
    if (move.name === "Struggle")
      return move;
    if (pokemon.gigantamax && pokemon.canGigantamax && move.category !== "Status") {
      const gMaxMove = this.dex.moves.get(pokemon.canGigantamax);
      if (gMaxMove.exists && gMaxMove.type === move.type)
        return gMaxMove;
    }
    const maxMove = this.dex.moves.get(this.MAX_MOVES[move.category === "Status" ? move.category : move.type]);
    if (maxMove.exists)
      return maxMove;
  }
  getActiveMaxMove(move, pokemon) {
    if (typeof move === "string")
      move = this.dex.getActiveMove(move);
    if (move.name === "Struggle")
      return this.dex.getActiveMove(move);
    let maxMove = this.dex.getActiveMove(this.MAX_MOVES[move.category === "Status" ? move.category : move.type]);
    if (move.category !== "Status") {
      if (pokemon.gigantamax && pokemon.canGigantamax) {
        const gMaxMove = this.dex.getActiveMove(pokemon.canGigantamax);
        if (gMaxMove.exists && gMaxMove.type === move.type)
          maxMove = gMaxMove;
      }
      if (!move.maxMove?.basePower)
        throw new Error(`${move.name} doesn't have a maxMove basePower`);
      if (!["gmaxdrumsolo", "gmaxfireball", "gmaxhydrosnipe"].includes(maxMove.id)) {
        maxMove.basePower = move.maxMove.basePower;
      }
      maxMove.category = move.category;
    }
    maxMove.baseMove = move.id;
    maxMove.priority = move.priority;
    maxMove.isZOrMaxPowered = true;
    return maxMove;
  }
  runZPower(move, pokemon) {
    const zPower = this.dex.conditions.get("zpower");
    if (move.category !== "Status") {
      this.battle.attrLastMove("[zeffect]");
    } else if (move.zMove?.boost) {
      this.battle.boost(move.zMove.boost, pokemon, pokemon, zPower);
    } else if (move.zMove?.effect) {
      switch (move.zMove.effect) {
        case "heal":
          this.battle.heal(pokemon.maxhp, pokemon, pokemon, zPower);
          break;
        case "healreplacement":
          pokemon.side.addSlotCondition(pokemon, "healreplacement", pokemon, move);
          break;
        case "clearnegativeboost":
          const boosts = {};
          let i;
          for (i in pokemon.boosts) {
            if (pokemon.boosts[i] < 0) {
              boosts[i] = 0;
            }
          }
          pokemon.setBoost(boosts);
          this.battle.add("-clearnegativeboost", pokemon, "[zeffect]");
          break;
        case "redirect":
          pokemon.addVolatile("followme", pokemon, zPower);
          break;
        case "crit2":
          pokemon.addVolatile("focusenergy", pokemon, zPower);
          break;
        case "curse":
          if (pokemon.hasType("Ghost")) {
            this.battle.heal(pokemon.maxhp, pokemon, pokemon, zPower);
          } else {
            this.battle.boost({ atk: 1 }, pokemon, pokemon, zPower);
          }
      }
    }
  }
  targetTypeChoices(targetType) {
    return CHOOSABLE_TARGETS.has(targetType);
  }
  combineResults(left, right) {
    const NOT_FAILURE = "string";
    const NULL = "object";
    const resultsPriorities = ["undefined", NOT_FAILURE, NULL, "boolean", "number"];
    if (resultsPriorities.indexOf(typeof left) > resultsPriorities.indexOf(typeof right)) {
      return left;
    } else if (left && !right && right !== 0) {
      return left;
    } else if (typeof left === "number" && typeof right === "number") {
      return left + right;
    } else {
      return right;
    }
  }
  /**
   * 0 is a success dealing 0 damage, such as from False Swipe at 1 HP.
   *
   * Normal PS return value rules apply:
   * undefined = success, null = silent failure, false = loud failure
   */
  getDamage(source, target, move, suppressMessages = false) {
    if (typeof move === "string")
      move = this.dex.getActiveMove(move);
    if (typeof move === "number") {
      const basePower2 = move;
      move = new import_dex.Dex.Move({
        basePower: basePower2,
        type: "???",
        category: "Physical",
        willCrit: false
      });
      move.hit = 0;
    }
    if (!move.ignoreImmunity || move.ignoreImmunity !== true && !move.ignoreImmunity[move.type]) {
      if (!target.runImmunity(move.type, !suppressMessages)) {
        return false;
      }
    }
    if (move.ohko)
      return target.maxhp;
    if (move.damageCallback)
      return move.damageCallback.call(this.battle, source, target);
    if (move.damage === "level") {
      return source.level;
    } else if (move.damage) {
      return move.damage;
    }
    const category = this.battle.getCategory(move);
    let basePower = move.basePower;
    if (move.basePowerCallback) {
      basePower = move.basePowerCallback.call(this.battle, source, target, move);
    }
    if (!basePower)
      return basePower === 0 ? void 0 : basePower;
    basePower = this.battle.clampIntRange(basePower, 1);
    let critMult;
    let critRatio = this.battle.runEvent("ModifyCritRatio", source, target, move, move.critRatio || 0);
    if (this.battle.gen <= 5) {
      critRatio = this.battle.clampIntRange(critRatio, 0, 5);
      critMult = [0, 16, 8, 4, 3, 2];
    } else {
      critRatio = this.battle.clampIntRange(critRatio, 0, 4);
      if (this.battle.gen === 6) {
        critMult = [0, 16, 8, 2, 1];
      } else {
        critMult = [0, 24, 8, 2, 1];
      }
    }
    const moveHit = target.getMoveHitData(move);
    moveHit.crit = move.willCrit || false;
    if (move.willCrit === void 0) {
      if (critRatio) {
        moveHit.crit = this.battle.randomChance(1, critMult[critRatio]);
      }
    }
    if (moveHit.crit) {
      moveHit.crit = this.battle.runEvent("CriticalHit", target, null, move);
    }
    basePower = this.battle.runEvent("BasePower", source, target, move, basePower, true);
    if (!basePower)
      return 0;
    basePower = this.battle.clampIntRange(basePower, 1);
    if (!source.volatiles["dynamax"] && move.isMax || move.isMax && this.dex.moves.get(move.baseMove).isMax) {
      basePower = 0;
    }
    const dexMove = this.dex.moves.get(move.id);
    if (basePower < 60 && source.getTypes(true).includes(move.type) && source.terastallized && dexMove.priority <= 0 && !dexMove.multihit && // Hard move.basePower check for moves like Dragon Energy that have variable BP
    !((move.basePower === 0 || move.basePower === 150) && move.basePowerCallback)) {
      basePower = 60;
    }
    const level = source.level;
    const attacker = move.overrideOffensivePokemon === "target" ? target : source;
    const defender = move.overrideDefensivePokemon === "source" ? source : target;
    const isPhysical = move.category === "Physical";
    let attackStat = move.overrideOffensiveStat || (isPhysical ? "atk" : "spa");
    const defenseStat = move.overrideDefensiveStat || (isPhysical ? "def" : "spd");
    const statTable = { atk: "Atk", def: "Def", spa: "SpA", spd: "SpD", spe: "Spe" };
    let atkBoosts = attacker.boosts[attackStat];
    let defBoosts = defender.boosts[defenseStat];
    let ignoreNegativeOffensive = !!move.ignoreNegativeOffensive;
    let ignorePositiveDefensive = !!move.ignorePositiveDefensive;
    if (moveHit.crit) {
      ignoreNegativeOffensive = true;
      ignorePositiveDefensive = true;
    }
    const ignoreOffensive = !!(move.ignoreOffensive || ignoreNegativeOffensive && atkBoosts < 0);
    const ignoreDefensive = !!(move.ignoreDefensive || ignorePositiveDefensive && defBoosts > 0);
    if (ignoreOffensive) {
      this.battle.debug("Negating (sp)atk boost/penalty.");
      atkBoosts = 0;
    }
    if (ignoreDefensive) {
      this.battle.debug("Negating (sp)def boost/penalty.");
      defBoosts = 0;
    }
    let attack = attacker.calculateStat(attackStat, atkBoosts, 1, source);
    let defense = defender.calculateStat(defenseStat, defBoosts, 1, target);
    attackStat = category === "Physical" ? "atk" : "spa";
    attack = this.battle.runEvent("Modify" + statTable[attackStat], source, target, move, attack);
    defense = this.battle.runEvent("Modify" + statTable[defenseStat], target, source, move, defense);
    if (this.battle.gen <= 4 && ["explosion", "selfdestruct"].includes(move.id) && defenseStat === "def") {
      defense = this.battle.clampIntRange(Math.floor(defense / 2), 1);
    }
    const tr = this.battle.trunc;
    const baseDamage = tr(tr(tr(tr(2 * level / 5 + 2) * basePower * attack) / defense) / 50);
    return this.modifyDamage(baseDamage, source, target, move, suppressMessages);
  }
  modifyDamage(baseDamage, pokemon, target, move, suppressMessages = false) {
    const tr = this.battle.trunc;
    if (!move.type)
      move.type = "???";
    const type = move.type;
    baseDamage += 2;
    if (move.spreadHit) {
      const spreadModifier = move.spreadModifier || (this.battle.gameType === "freeforall" ? 0.5 : 0.75);
      this.battle.debug(`Spread modifier: ${spreadModifier}`);
      baseDamage = this.battle.modify(baseDamage, spreadModifier);
    } else if (move.multihitType === "parentalbond" && move.hit > 1) {
      const bondModifier = this.battle.gen > 6 ? 0.25 : 0.5;
      this.battle.debug(`Parental Bond modifier: ${bondModifier}`);
      baseDamage = this.battle.modify(baseDamage, bondModifier);
    }
    baseDamage = this.battle.runEvent("WeatherModifyDamage", pokemon, target, move, baseDamage);
    const isCrit = target.getMoveHitData(move).crit;
    if (isCrit) {
      baseDamage = tr(baseDamage * (move.critModifier || (this.battle.gen >= 6 ? 1.5 : 2)));
    }
    baseDamage = this.battle.randomizer(baseDamage);
    if (type !== "???") {
      let stab = 1;
      const isSTAB = move.forceSTAB || pokemon.hasType(type) || pokemon.getTypes(false, true).includes(type);
      if (isSTAB) {
        stab = 1.5;
      }
      if (pokemon.terastallized === "Stellar") {
        if (!pokemon.stellarBoostedTypes.includes(type) || move.stellarBoosted) {
          stab = isSTAB ? 2 : [4915, 4096];
          move.stellarBoosted = true;
          if (pokemon.species.name !== "Terapagos-Stellar") {
            pokemon.stellarBoostedTypes.push(type);
          }
        }
      } else {
        if (pokemon.terastallized === type && pokemon.getTypes(false, true).includes(type)) {
          stab = 2;
        }
        stab = this.battle.runEvent("ModifySTAB", pokemon, target, move, stab);
      }
      baseDamage = this.battle.modify(baseDamage, stab);
    }
    let typeMod = target.runEffectiveness(move);
    typeMod = this.battle.clampIntRange(typeMod, -6, 6);
    target.getMoveHitData(move).typeMod = typeMod;
    if (typeMod > 0) {
      if (!suppressMessages)
        this.battle.add("-supereffective", target);
      for (let i = 0; i < typeMod; i++) {
        baseDamage *= 2;
      }
    }
    if (typeMod < 0) {
      if (!suppressMessages)
        this.battle.add("-resisted", target);
      for (let i = 0; i > typeMod; i--) {
        baseDamage = tr(baseDamage / 2);
      }
    }
    if (isCrit && !suppressMessages)
      this.battle.add("-crit", target);
    if (pokemon.status === "brn" && move.category === "Physical" && !pokemon.hasAbility("guts")) {
      if (this.battle.gen < 6 || move.id !== "facade") {
        baseDamage = this.battle.modify(baseDamage, 0.5);
      }
    }
    if (this.battle.gen === 5 && !baseDamage)
      baseDamage = 1;
    baseDamage = this.battle.runEvent("ModifyDamage", pokemon, target, move, baseDamage);
    if (move.isZOrMaxPowered && target.getMoveHitData(move).zBrokeProtect) {
      baseDamage = this.battle.modify(baseDamage, 0.25);
      this.battle.add("-zbroken", target);
    }
    if (this.battle.gen !== 5 && !baseDamage)
      return 1;
    return tr(baseDamage, 16);
  }
  /**
   * Confusion damage is unique - most typical modifiers that get run when calculating
   * damage (e.g. Huge Power, Life Orb, critical hits) don't apply. It also uses a 16-bit
   * context for its damage, unlike the regular damage formula (though this only comes up
   * for base damage).
   */
  getConfusionDamage(pokemon, basePower) {
    const tr = this.battle.trunc;
    const attack = pokemon.calculateStat("atk", pokemon.boosts["atk"]);
    const defense = pokemon.calculateStat("def", pokemon.boosts["def"]);
    const level = pokemon.level;
    const baseDamage = tr(tr(tr(tr(2 * level / 5 + 2) * basePower * attack) / defense) / 50) + 2;
    let damage = tr(baseDamage, 16);
    damage = this.battle.randomizer(damage);
    return Math.max(1, damage);
  }
  // #endregion
  // #region MEGA EVOLUTION
  // ==================================================================
  canMegaEvo(pokemon) {
    const species = pokemon.baseSpecies;
    const altForme = species.otherFormes && this.dex.species.get(species.otherFormes[0]);
    const item = pokemon.getItem();
    if ((this.battle.gen <= 7 || this.battle.ruleTable.has("+pokemontag:past")) && altForme?.isMega && altForme?.requiredMove && pokemon.baseMoves.includes((0, import_dex.toID)(altForme.requiredMove)) && !item.zMove) {
      return altForme.name;
    }
    if (item.megaEvolves === species.baseSpecies && item.megaStone !== species.name) {
      return item.megaStone;
    }
    return null;
  }
  canUltraBurst(pokemon) {
    if (["Necrozma-Dawn-Wings", "Necrozma-Dusk-Mane"].includes(pokemon.baseSpecies.name) && pokemon.getItem().id === "ultranecroziumz") {
      return "Necrozma-Ultra";
    }
    return null;
  }
  runMegaEvo(pokemon) {
    const speciesid = pokemon.canMegaEvo || pokemon.canUltraBurst;
    if (!speciesid)
      return false;
    pokemon.formeChange(speciesid, pokemon.getItem(), true);
    const wasMega = pokemon.canMegaEvo;
    for (const ally of pokemon.side.pokemon) {
      if (wasMega) {
        ally.canMegaEvo = null;
      } else {
        ally.canUltraBurst = null;
      }
    }
    this.battle.runEvent("AfterMega", pokemon);
    return true;
  }
  canTerastallize(pokemon) {
    if (pokemon.getItem().zMove || pokemon.canMegaEvo || this.dex.gen !== 9) {
      return null;
    }
    return pokemon.teraType;
  }
  terastallize(pokemon) {
    if (pokemon.illusion && ["Ogerpon", "Terapagos"].includes(pokemon.illusion.species.baseSpecies)) {
      this.battle.singleEvent("End", this.dex.abilities.get("Illusion"), pokemon.abilityState, pokemon);
    }
    const type = pokemon.teraType;
    this.battle.add("-terastallize", pokemon, type);
    pokemon.terastallized = type;
    for (const ally of pokemon.side.pokemon) {
      ally.canTerastallize = null;
    }
    pokemon.addedType = "";
    pokemon.knownType = true;
    pokemon.apparentType = type;
    if (pokemon.species.baseSpecies === "Ogerpon") {
      const tera = pokemon.species.id === "ogerpon" ? "tealtera" : "tera";
      pokemon.formeChange(pokemon.species.id + tera, null, true);
    }
    if (pokemon.species.name === "Terapagos-Terastal" && type === "Stellar") {
      pokemon.formeChange("Terapagos-Stellar", null, true);
      pokemon.baseMaxhp = Math.floor(Math.floor(
        2 * pokemon.species.baseStats["hp"] + pokemon.set.ivs["hp"] + Math.floor(pokemon.set.evs["hp"] / 4) + 100
      ) * pokemon.level / 100 + 10);
      const newMaxHP = pokemon.baseMaxhp;
      pokemon.hp = newMaxHP - (pokemon.maxhp - pokemon.hp);
      pokemon.maxhp = newMaxHP;
      this.battle.add("-heal", pokemon, pokemon.getHealth, "[silent]");
    }
    if (pokemon.species.baseSpecies === "Morpeko" && !pokemon.transformed && pokemon.baseSpecies.id !== pokemon.species.id) {
      pokemon.regressionForme = true;
      pokemon.baseSpecies = pokemon.species;
      pokemon.details = pokemon.getUpdatedDetails();
    }
    this.battle.runEvent("AfterTerastallization", pokemon);
  }
  // #endregion
}
//# sourceMappingURL=battle-actions.js.map