"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_exports = {};
__export(battle_exports, {
Battle: () => Battle,
extractChannelMessages: () => extractChannelMessages
});
module.exports = __toCommonJS(battle_exports);
var import_dex_formats = require("./dex-formats");
var import_dex = require("./dex");
var import_teams = require("./teams");
var import_field = require("./field");
var import_pokemon = require("./pokemon");
var import_prng = require("./prng");
var import_side = require("./side");
var import_state = require("./state");
var import_battle_queue = require("./battle-queue");
var import_battle_actions = require("./battle-actions");
var import_lib = require("../lib");
/**
* Simulator Battle
* Pokemon Showdown - http://pokemonshowdown.com/
*
* This file is where the battle simulation itself happens.
*
* The most important part of the simulation is the event system:
* see the `runEvent` function definition for details.
*
* General battle mechanics are in `battle-actions`; move-specific,
* item-specific, etc mechanics are in the corresponding file in
* `data`.
*
* @license MIT
*/
const splitRegex = /^\|split\|p([1234])\n(.*)\n(.*)|.+/gm;
function extractChannelMessages(message, channelIds) {
const channelIdSet = new Set(channelIds);
const channelMessages = {
[-1]: [],
0: [],
1: [],
2: [],
3: [],
4: []
};
for (const [lineMatch, playerMatch, secretMessage, sharedMessage] of message.matchAll(splitRegex)) {
const player = playerMatch ? parseInt(playerMatch) : 0;
for (const channelId of channelIdSet) {
let line = lineMatch;
if (player) {
line = channelId === -1 || player === channelId ? secretMessage : sharedMessage;
if (!line)
continue;
}
channelMessages[channelId].push(line);
}
}
return channelMessages;
}
class Battle {
constructor(options) {
this.toID = import_dex.toID;
this.log = [];
this.add("t:", Math.floor(Date.now() / 1e3));
let format = void 0;
if (!!options.format && options.format.debug == void 0) {
format = new import_dex_formats.Format(options.format);
} else {
format = options.format || import_dex.Dex.formats.get(options.formatid, true);
}
this.format = format;
this.dex = import_dex.Dex.forFormat(format);
this.gen = this.dex.gen;
this.ruleTable = this.dex.formats.getRuleTable(format);
this.trunc = this.dex.trunc;
this.clampIntRange = import_lib.Utils.clampIntRange;
for (const i in this.dex.data.Scripts) {
const entry = this.dex.data.Scripts[i];
if (typeof entry === "function")
this[i] = entry;
}
if (format.battle)
Object.assign(this, format.battle);
this.id = "";
this.debugMode = format.debug || !!options.debug;
this.forceRandomChance = this.debugMode && typeof options.forceRandomChance === "boolean" ? options.forceRandomChance : null;
this.deserialized = !!options.deserialized;
this.strictChoices = !!options.strictChoices;
this.formatData = { id: format.id };
this.gameType = format.gameType || "singles";
this.field = new import_field.Field(this);
const isFourPlayer = this.gameType === "multi" || this.gameType === "freeforall";
this.sides = Array(isFourPlayer ? 4 : 2).fill(null);
this.activePerHalf = this.gameType === "triples" ? 3 : isFourPlayer || this.gameType === "doubles" ? 2 : 1;
this.prng = options.prng || new import_prng.PRNG(options.seed || void 0);
this.prngSeed = this.prng.startingSeed.slice();
this.rated = options.rated || !!options.rated;
this.reportExactHP = !!format.debug;
this.reportPercentages = false;
this.supportCancel = false;
this.queue = new import_battle_queue.BattleQueue(this);
this.actions = new import_battle_actions.BattleActions(this);
this.faintQueue = [];
this.inputLog = [];
this.messageLog = [];
this.sentLogPos = 0;
this.sentEnd = false;
this.requestState = "";
this.turn = 0;
this.midTurn = false;
this.started = false;
this.ended = false;
this.effect = { id: "" };
this.effectState = { id: "" };
this.event = { id: "" };
this.events = null;
this.eventDepth = 0;
this.activeMove = null;
this.activePokemon = null;
this.activeTarget = null;
this.lastMove = null;
this.lastMoveLine = -1;
this.lastSuccessfulMoveThisTurn = null;
this.lastDamage = 0;
this.abilityOrder = 0;
this.quickClawRoll = false;
this.teamGenerator = null;
this.hints = /* @__PURE__ */ new Set();
this.NOT_FAIL = "";
this.HIT_SUBSTITUTE = 0;
this.FAIL = false;
this.SILENT_FAIL = null;
this.send = options.send || (() => {
});
const inputOptions = {
formatid: options.formatid,
seed: this.prng.seed
};
if (this.rated)
inputOptions.rated = this.rated;
if (typeof __version !== "undefined") {
if (__version.head) {
this.inputLog.push(`>version ${__version.head}`);
}
if (__version.origin) {
this.inputLog.push(`>version-origin ${__version.origin}`);
}
}
this.inputLog.push(`>start ` + JSON.stringify(inputOptions));
this.add("gametype", this.gameType);
for (const rule of this.ruleTable.keys()) {
if ("+*-!".includes(rule.charAt(0)))
continue;
const subFormat = this.dex.formats.get(rule);
if (subFormat.exists) {
const hasEventHandler = Object.keys(subFormat).some(
// skip event handlers that are handled elsewhere
(val) => val.startsWith("on") && ![
"onBegin",
"onTeamPreview",
"onBattleStart",
"onValidateRule",
"onValidateTeam",
"onChangeSet",
"onValidateSet"
].includes(val)
);
if (hasEventHandler)
this.field.addPseudoWeather(rule);
}
}
const sides = ["p1", "p2", "p3", "p4"];
for (const side of sides) {
if (options[side]) {
this.setPlayer(side, options[side]);
}
}
}
toJSON() {
return import_state.State.serializeBattle(this);
}
static fromJSON(serialized) {
return import_state.State.deserializeBattle(serialized);
}
get p1() {
return this.sides[0];
}
get p2() {
return this.sides[1];
}
get p3() {
return this.sides[2];
}
get p4() {
return this.sides[3];
}
toString() {
return `Battle: ${this.format}`;
}
random(m, n) {
return this.prng.next(m, n);
}
randomChance(numerator, denominator) {
if (this.forceRandomChance !== null)
return this.forceRandomChance;
return this.prng.randomChance(numerator, denominator);
}
sample(items) {
return this.prng.sample(items);
}
/** Note that passing `undefined` resets to the starting seed, but `null` will roll a new seed */
resetRNG(seed = this.prng.startingSeed) {
this.prng = new import_prng.PRNG(seed);
this.add("message", "The battle's RNG was reset.");
}
suppressingAbility(target) {
return this.activePokemon && this.activePokemon.isActive && (this.activePokemon !== target || this.gen < 8) && this.activeMove && this.activeMove.ignoreAbility && !target?.hasItem("Ability Shield");
}
setActiveMove(move, pokemon, target) {
this.activeMove = move || null;
this.activePokemon = pokemon || null;
this.activeTarget = target || pokemon || null;
}
clearActiveMove(failed) {
if (this.activeMove) {
if (!failed) {
this.lastMove = this.activeMove;
}
this.activeMove = null;
this.activePokemon = null;
this.activeTarget = null;
}
}
updateSpeed() {
for (const pokemon of this.getAllActive()) {
pokemon.updateSpeed();
}
}
/**
* The default sort order for actions, but also event listeners.
*
* 1. Order, low to high (default last)
* 2. Priority, high to low (default 0)
* 3. Speed, high to low (default 0)
* 4. SubOrder, low to high (default 0)
*
* Doesn't reference `this` so doesn't need to be bound.
*/
comparePriority(a, b) {
return -((b.order || 4294967296) - (a.order || 4294967296)) || (b.priority || 0) - (a.priority || 0) || (b.speed || 0) - (a.speed || 0) || -((b.subOrder || 0) - (a.subOrder || 0)) || 0;
}
static compareRedirectOrder(a, b) {
return (b.priority || 0) - (a.priority || 0) || (b.speed || 0) - (a.speed || 0) || (a.effectHolder && b.effectHolder ? -(b.effectHolder.abilityOrder - a.effectHolder.abilityOrder) : 0) || 0;
}
static compareLeftToRightOrder(a, b) {
return -((b.order || 4294967296) - (a.order || 4294967296)) || (b.priority || 0) - (a.priority || 0) || -((b.index || 0) - (a.index || 0)) || 0;
}
/** Sort a list, resolving speed ties the way the games do. */
speedSort(list, comparator = this.comparePriority) {
if (list.length < 2)
return;
let sorted = 0;
while (sorted + 1 < list.length) {
let nextIndexes = [sorted];
for (let i = sorted + 1; i < list.length; i++) {
const delta = comparator(list[nextIndexes[0]], list[i]);
if (delta < 0)
continue;
if (delta > 0)
nextIndexes = [i];
if (delta === 0)
nextIndexes.push(i);
}
for (let i = 0; i < nextIndexes.length; i++) {
const index = nextIndexes[i];
if (index !== sorted + i) {
[list[sorted + i], list[index]] = [list[index], list[sorted + i]];
}
}
if (nextIndexes.length > 1) {
this.prng.shuffle(list, sorted, sorted + nextIndexes.length);
}
sorted += nextIndexes.length;
}
}
/**
* Runs an event with no source on each Pokémon on the field, in Speed order.
*/
eachEvent(eventid, effect, relayVar) {
const actives = this.getAllActive();
if (!effect && this.effect)
effect = this.effect;
this.speedSort(actives, (a, b) => b.speed - a.speed);
for (const pokemon of actives) {
this.runEvent(eventid, pokemon, null, effect, relayVar);
}
if (eventid === "Weather" && this.gen >= 7) {
this.eachEvent("Update");
}
}
/**
* Runs an event with no source on each effect on the field, in Speed order.
*
* Unlike `eachEvent`, this contains a lot of other handling and is intended only for the residual step.
*/
residualEvent(eventid, relayVar) {
const callbackName = `on${eventid}`;
let handlers = this.findBattleEventHandlers(callbackName, "duration");
handlers = handlers.concat(this.findFieldEventHandlers(this.field, `onField${eventid}`, "duration"));
for (const side of this.sides) {
if (side.n < 2 || !side.allySide) {
handlers = handlers.concat(this.findSideEventHandlers(side, `onSide${eventid}`, "duration"));
}
for (const active of side.active) {
if (!active)
continue;
handlers = handlers.concat(this.findPokemonEventHandlers(active, callbackName, "duration"));
handlers = handlers.concat(this.findSideEventHandlers(side, callbackName, void 0, active));
handlers = handlers.concat(this.findFieldEventHandlers(this.field, callbackName, void 0, active));
}
}
this.speedSort(handlers);
while (handlers.length) {
const handler = handlers[0];
handlers.shift();
const effect = handler.effect;
if (handler.effectHolder.fainted)
continue;
if (handler.end && handler.state && handler.state.duration) {
handler.state.duration--;
if (!handler.state.duration) {
const endCallArgs = handler.endCallArgs || [handler.effectHolder, effect.id];
handler.end.call(...endCallArgs);
if (this.ended)
return;
continue;
}
}
let handlerEventid = eventid;
if (handler.effectHolder.sideConditions)
handlerEventid = `Side${eventid}`;
if (handler.effectHolder.pseudoWeather)
handlerEventid = `Field${eventid}`;
if (handler.callback) {
this.singleEvent(handlerEventid, effect, handler.state, handler.effectHolder, null, null, relayVar, handler.callback);
}
this.faintMessages();
if (this.ended)
return;
}
}
/** The entire event system revolves around this function and runEvent. */
singleEvent(eventid, effect, state, target, source, sourceEffect, relayVar, customCallback) {
if (this.eventDepth >= 8) {
this.add("message", "STACK LIMIT EXCEEDED");
this.add("message", "PLEASE REPORT IN BUG THREAD");
this.add("message", "Event: " + eventid);
this.add("message", "Parent event: " + this.event.id);
throw new Error("Stack overflow");
}
if (this.log.length - this.sentLogPos > 1e3) {
this.add("message", "LINE LIMIT EXCEEDED");
this.add("message", "PLEASE REPORT IN BUG THREAD");
this.add("message", "Event: " + eventid);
this.add("message", "Parent event: " + this.event.id);
throw new Error("Infinite loop");
}
let hasRelayVar = true;
if (relayVar === void 0) {
relayVar = true;
hasRelayVar = false;
}
if (effect.effectType === "Status" && target instanceof import_pokemon.Pokemon && target.status !== effect.id) {
return relayVar;
}
if (eventid !== "Start" && eventid !== "TakeItem" && eventid !== "Primal" && effect.effectType === "Item" && target instanceof import_pokemon.Pokemon && target.ignoringItem()) {
this.debug(eventid + " handler suppressed by Embargo, Klutz or Magic Room");
return relayVar;
}
if (eventid !== "End" && effect.effectType === "Ability" && target instanceof import_pokemon.Pokemon && target.ignoringAbility()) {
this.debug(eventid + " handler suppressed by Gastro Acid or Neutralizing Gas");
return relayVar;
}
if (effect.effectType === "Weather" && eventid !== "FieldStart" && eventid !== "FieldResidual" && eventid !== "FieldEnd" && this.field.suppressingWeather()) {
this.debug(eventid + " handler suppressed by Air Lock");
return relayVar;
}
const callback = customCallback || effect[`on${eventid}`];
if (callback === void 0)
return relayVar;
const parentEffect = this.effect;
const parentEffectState = this.effectState;
const parentEvent = this.event;
this.effect = effect;
this.effectState = state || {};
this.event = { id: eventid, target, source, effect: sourceEffect };
this.eventDepth++;
const args = [target, source, sourceEffect];
if (hasRelayVar)
args.unshift(relayVar);
let returnVal;
if (typeof callback === "function") {
returnVal = callback.apply(this, args);
} else {
returnVal = callback;
}
this.eventDepth--;
this.effect = parentEffect;
this.effectState = parentEffectState;
this.event = parentEvent;
return returnVal === void 0 ? relayVar : returnVal;
}
/**
* runEvent is the core of Pokemon Showdown's event system.
*
* Basic usage
* ===========
*
* this.runEvent('Blah')
* will trigger any onBlah global event handlers.
*
* this.runEvent('Blah', target)
* will additionally trigger any onBlah handlers on the target, onAllyBlah
* handlers on any active pokemon on the target's team, and onFoeBlah
* handlers on any active pokemon on the target's foe's team
*
* this.runEvent('Blah', target, source)
* will additionally trigger any onSourceBlah handlers on the source
*
* this.runEvent('Blah', target, source, effect)
* will additionally pass the effect onto all event handlers triggered
*
* this.runEvent('Blah', target, source, effect, relayVar)
* will additionally pass the relayVar as the first argument along all event
* handlers
*
* You may leave any of these null. For instance, if you have a relayVar but
* no source or effect:
* this.runEvent('Damage', target, null, null, 50)
*
* Event handlers
* ==============
*
* Items, abilities, statuses, and other effects like SR, confusion, weather,
* or Trick Room can have event handlers. Event handlers are functions that
* can modify what happens during an event.
*
* event handlers are passed:
* function (target, source, effect)
* although some of these can be blank.
*
* certain events have a relay variable, in which case they're passed:
* function (relayVar, target, source, effect)
*
* Relay variables are variables that give additional information about the
* event. For instance, the damage event has a relayVar which is the amount
* of damage dealt.
*
* If a relay variable isn't passed to runEvent, there will still be a secret
* relayVar defaulting to `true`, but it won't get passed to any event
* handlers.
*
* After an event handler is run, its return value helps determine what
* happens next:
* 1. If the return value isn't `undefined`, relayVar is set to the return
* value
* 2. If relayVar is falsy, no more event handlers are run
* 3. Otherwise, if there are more event handlers, the next one is run and
* we go back to step 1.
* 4. Once all event handlers are run (or one of them results in a falsy
* relayVar), relayVar is returned by runEvent
*
* As a shortcut, an event handler that isn't a function will be interpreted
* as a function that returns that value.
*
* You can have return values mean whatever you like, but in general, we
* follow the convention that returning `false` or `null` means
* stopping or interrupting the event.
*
* For instance, returning `false` from a TrySetStatus handler means that
* the pokemon doesn't get statused.
*
* If a failed event usually results in a message like "But it failed!"
* or "It had no effect!", returning `null` will suppress that message and
* returning `false` will display it. Returning `null` is useful if your
* event handler already gave its own custom failure message.
*
* Returning `undefined` means "don't change anything" or "keep going".
* A function that does nothing but return `undefined` is the equivalent
* of not having an event handler at all.
*
* Returning a value means that that value is the new `relayVar`. For
* instance, if a Damage event handler returns 50, the damage event
* will deal 50 damage instead of whatever it was going to deal before.
*
* Useful values
* =============
*
* In addition to all the methods and attributes of Dex, Battle, and
* Scripts, event handlers have some additional values they can access:
*
* this.effect:
* the Effect having the event handler
* this.effectState:
* the data store associated with the above Effect. This is a plain Object
* and you can use it to store data for later event handlers.
* this.effectState.target:
* the Pokemon, Side, or Battle that the event handler's effect was
* attached to.
* this.event.id:
* the event ID
* this.event.target, this.event.source, this.event.effect:
* the target, source, and effect of the event. These are the same
* variables that are passed as arguments to the event handler, but
* they're useful for functions called by the event handler.
*/
runEvent(eventid, target, source, sourceEffect, relayVar, onEffect, fastExit) {
if (this.eventDepth >= 8) {
this.add("message", "STACK LIMIT EXCEEDED");
this.add("message", "PLEASE REPORT IN BUG THREAD");
this.add("message", "Event: " + eventid);
this.add("message", "Parent event: " + this.event.id);
throw new Error("Stack overflow");
}
if (!target)
target = this;
let effectSource = null;
if (source instanceof import_pokemon.Pokemon)
effectSource = source;
const handlers = this.findEventHandlers(target, eventid, effectSource);
if (onEffect) {
if (!sourceEffect)
throw new Error("onEffect passed without an effect");
const callback = sourceEffect[`on${eventid}`];
if (callback !== void 0) {
if (Array.isArray(target))
throw new Error("");
handlers.unshift(this.resolvePriority({
effect: sourceEffect,
callback,
state: {},
end: null,
effectHolder: target
}, `on${eventid}`));
}
}
if (["Invulnerability", "TryHit", "DamagingHit", "EntryHazard"].includes(eventid)) {
handlers.sort(Battle.compareLeftToRightOrder);
} else if (fastExit) {
handlers.sort(Battle.compareRedirectOrder);
} else {
this.speedSort(handlers);
}
let hasRelayVar = 1;
const args = [target, source, sourceEffect];
if (relayVar === void 0 || relayVar === null) {
relayVar = true;
hasRelayVar = 0;
} else {
args.unshift(relayVar);
}
const parentEvent = this.event;
this.event = { id: eventid, target, source, effect: sourceEffect, modifier: 1 };
this.eventDepth++;
let targetRelayVars = [];
if (Array.isArray(target)) {
if (Array.isArray(relayVar)) {
targetRelayVars = relayVar;
} else {
for (let i = 0; i < target.length; i++)
targetRelayVars[i] = true;
}
}
for (const handler of handlers) {
if (handler.index !== void 0) {
if (!targetRelayVars[handler.index] && !(targetRelayVars[handler.index] === 0 && eventid === "DamagingHit"))
continue;
if (handler.target) {
args[hasRelayVar] = handler.target;
this.event.target = handler.target;
}
if (hasRelayVar)
args[0] = targetRelayVars[handler.index];
}
const effect = handler.effect;
const effectHolder = handler.effectHolder;
if (effect.effectType === "Status" && effectHolder.status !== effect.id) {
continue;
}
if (effect.effectType === "Ability" && effect.isBreakable !== false && this.suppressingAbility(effectHolder)) {
if (effect.isBreakable) {
this.debug(eventid + " handler suppressed by Mold Breaker");
continue;
}
if (!effect.num) {
const AttackingEvents = {
BeforeMove: 1,
BasePower: 1,
Immunity: 1,
RedirectTarget: 1,
Heal: 1,
SetStatus: 1,
CriticalHit: 1,
ModifyAtk: 1,
ModifyDef: 1,
ModifySpA: 1,
ModifySpD: 1,
ModifySpe: 1,
ModifyAccuracy: 1,
ModifyBoost: 1,
ModifyDamage: 1,
ModifySecondaries: 1,
ModifyWeight: 1,
TryAddVolatile: 1,
TryHit: 1,
TryHitSide: 1,
TryMove: 1,
Boost: 1,
DragOut: 1,
Effectiveness: 1
};
if (eventid in AttackingEvents) {
this.debug(eventid + " handler suppressed by Mold Breaker");
continue;
} else if (eventid === "Damage" && sourceEffect && sourceEffect.effectType === "Move") {
this.debug(eventid + " handler suppressed by Mold Breaker");
continue;
}
}
}
if (eventid !== "Start" && eventid !== "SwitchIn" && eventid !== "TakeItem" && effect.effectType === "Item" && effectHolder instanceof import_pokemon.Pokemon && effectHolder.ignoringItem()) {
if (eventid !== "Update") {
this.debug(eventid + " handler suppressed by Embargo, Klutz or Magic Room");
}
continue;
} else if (eventid !== "End" && effect.effectType === "Ability" && effectHolder instanceof import_pokemon.Pokemon && effectHolder.ignoringAbility()) {
if (eventid !== "Update") {
this.debug(eventid + " handler suppressed by Gastro Acid or Neutralizing Gas");
}
continue;
}
if ((effect.effectType === "Weather" || eventid === "Weather") && eventid !== "Residual" && eventid !== "End" && this.field.suppressingWeather()) {
this.debug(eventid + " handler suppressed by Air Lock");
continue;
}
let returnVal;
if (typeof handler.callback === "function") {
const parentEffect = this.effect;
const parentEffectState = this.effectState;
this.effect = handler.effect;
this.effectState = handler.state || {};
this.effectState.target = effectHolder;
returnVal = handler.callback.apply(this, args);
this.effect = parentEffect;
this.effectState = parentEffectState;
} else {
returnVal = handler.callback;
}
if (returnVal !== void 0) {
relayVar = returnVal;
if (!relayVar || fastExit) {
if (handler.index !== void 0) {
targetRelayVars[handler.index] = relayVar;
if (targetRelayVars.every((val) => !val))
break;
} else {
break;
}
}
if (hasRelayVar) {
args[0] = relayVar;
}
}
}
this.eventDepth--;
if (typeof relayVar === "number" && relayVar === Math.abs(Math.floor(relayVar))) {
relayVar = this.modify(relayVar, this.event.modifier);
}
this.event = parentEvent;
return Array.isArray(target) ? targetRelayVars : relayVar;
}
/**
* priorityEvent works just like runEvent, except it exits and returns
* on the first non-undefined value instead of only on null/false.
*/
priorityEvent(eventid, target, source, effect, relayVar, onEffect) {
return this.runEvent(eventid, target, source, effect, relayVar, onEffect, true);
}
resolvePriority(handler, callbackName) {
handler.order = handler.effect[`${callbackName}Order`] || false;
handler.priority = handler.effect[`${callbackName}Priority`] || 0;
handler.subOrder = handler.effect[`${callbackName}SubOrder`] || 0;
if (handler.effectHolder && handler.effectHolder.getStat) {
handler.speed = handler.effectHolder.speed;
}
return handler;
}
findEventHandlers(target, eventName, source) {
let handlers = [];
if (Array.isArray(target)) {
for (const [i, pokemon] of target.entries()) {
const curHandlers = this.findEventHandlers(pokemon, eventName, source);
for (const handler of curHandlers) {
handler.target = pokemon;
handler.index = i;
}
handlers = handlers.concat(curHandlers);
}
return handlers;
}
const prefixedHandlers = !["BeforeTurn", "Update", "Weather", "WeatherChange", "TerrainChange"].includes(eventName);
if (target instanceof import_pokemon.Pokemon && (target.isActive || source?.isActive)) {
handlers = this.findPokemonEventHandlers(target, `on${eventName}`);
if (prefixedHandlers) {
for (const allyActive of target.alliesAndSelf()) {
handlers.push(...this.findPokemonEventHandlers(allyActive, `onAlly${eventName}`));
handlers.push(...this.findPokemonEventHandlers(allyActive, `onAny${eventName}`));
}
for (const foeActive of target.foes()) {
handlers.push(...this.findPokemonEventHandlers(foeActive, `onFoe${eventName}`));
handlers.push(...this.findPokemonEventHandlers(foeActive, `onAny${eventName}`));
}
}
target = target.side;
}
if (source && prefixedHandlers) {
handlers.push(...this.findPokemonEventHandlers(source, `onSource${eventName}`));
}
if (target instanceof import_side.Side) {
for (const side of this.sides) {
if (side.n >= 2 && side.allySide)
break;
if (side === target || side === target.allySide) {
handlers.push(...this.findSideEventHandlers(side, `on${eventName}`));
} else if (prefixedHandlers) {
handlers.push(...this.findSideEventHandlers(side, `onFoe${eventName}`));
}
if (prefixedHandlers)
handlers.push(...this.findSideEventHandlers(side, `onAny${eventName}`));
}
}
handlers.push(...this.findFieldEventHandlers(this.field, `on${eventName}`));
handlers.push(...this.findBattleEventHandlers(`on${eventName}`));
return handlers;
}
findPokemonEventHandlers(pokemon, callbackName, getKey) {
const handlers = [];
const status = pokemon.getStatus();
let callback = status[callbackName];
if (callback !== void 0 || getKey && pokemon.statusState[getKey]) {
handlers.push(this.resolvePriority({
effect: status,
callback,
state: pokemon.statusState,
end: pokemon.clearStatus,
effectHolder: pokemon
}, callbackName));
}
for (const id in pokemon.volatiles) {
const volatileState = pokemon.volatiles[id];
const volatile = this.dex.conditions.getByID(id);
callback = volatile[callbackName];
if (callback !== void 0 || getKey && volatileState[getKey]) {
handlers.push(this.resolvePriority({
effect: volatile,
callback,
state: volatileState,
end: pokemon.removeVolatile,
effectHolder: pokemon
}, callbackName));
}
}
const ability = pokemon.getAbility();
callback = ability[callbackName];
if (callback !== void 0 || getKey && pokemon.abilityState[getKey]) {
handlers.push(this.resolvePriority({
effect: ability,
callback,
state: pokemon.abilityState,
end: pokemon.clearAbility,
effectHolder: pokemon
}, callbackName));
}
const item = pokemon.getItem();
callback = item[callbackName];
if (callback !== void 0 || getKey && pokemon.itemState[getKey]) {
handlers.push(this.resolvePriority({
effect: item,
callback,
state: pokemon.itemState,
end: pokemon.clearItem,
effectHolder: pokemon
}, callbackName));
}
const species = pokemon.baseSpecies;
callback = species[callbackName];
if (callback !== void 0) {
handlers.push(this.resolvePriority({
effect: species,
callback,
state: pokemon.speciesState,
end() {
},
effectHolder: pokemon
}, callbackName));
}
const side = pokemon.side;
for (const conditionid in side.slotConditions[pokemon.position]) {
const slotConditionState = side.slotConditions[pokemon.position][conditionid];
const slotCondition = this.dex.conditions.getByID(conditionid);
callback = slotCondition[callbackName];
if (callback !== void 0 || getKey && slotConditionState[getKey]) {
handlers.push(this.resolvePriority({
effect: slotCondition,
callback,
state: slotConditionState,
end: side.removeSlotCondition,
endCallArgs: [side, pokemon, slotCondition.id],
effectHolder: side
}, callbackName));
}
}
return handlers;
}
findBattleEventHandlers(callbackName, getKey) {
const handlers = [];
let callback;
const format = this.format;
callback = format[callbackName];
if (callback !== void 0 || getKey && this.formatData[getKey]) {
handlers.push(this.resolvePriority({
effect: format,
callback,
state: this.formatData,
end: null,
effectHolder: this
}, callbackName));
}
if (this.events && (callback = this.events[callbackName]) !== void 0) {
for (const handler of callback) {
const state = handler.target.effectType === "Format" ? this.formatData : null;
handlers.push({
effect: handler.target,
callback: handler.callback,
state,
end: null,
effectHolder: this,
priority: handler.priority,
order: handler.order,
subOrder: handler.subOrder
});
}
}
return handlers;
}
findFieldEventHandlers(field, callbackName, getKey, customHolder) {
const handlers = [];
let callback;
for (const id in field.pseudoWeather) {
const pseudoWeatherState = field.pseudoWeather[id];
const pseudoWeather = this.dex.conditions.getByID(id);
callback = pseudoWeather[callbackName];
if (callback !== void 0 || getKey && pseudoWeatherState[getKey]) {
handlers.push(this.resolvePriority({
effect: pseudoWeather,
callback,
state: pseudoWeatherState,
end: customHolder ? null : field.removePseudoWeather,
effectHolder: customHolder || field
}, callbackName));
}
}
const weather = field.getWeather();
callback = weather[callbackName];
if (callback !== void 0 || getKey && this.field.weatherState[getKey]) {
handlers.push(this.resolvePriority({
effect: weather,
callback,
state: this.field.weatherState,
end: customHolder ? null : field.clearWeather,
effectHolder: customHolder || field
}, callbackName));
}
const terrain = field.getTerrain();
callback = terrain[callbackName];
if (callback !== void 0 || getKey && field.terrainState[getKey]) {
handlers.push(this.resolvePriority({
effect: terrain,
callback,
state: field.terrainState,
end: customHolder ? null : field.clearTerrain,
effectHolder: customHolder || field
}, callbackName));
}
return handlers;
}
findSideEventHandlers(side, callbackName, getKey, customHolder) {
const handlers = [];
for (const id in side.sideConditions) {
const sideConditionData = side.sideConditions[id];
const sideCondition = this.dex.conditions.getByID(id);
const callback = sideCondition[callbackName];
if (callback !== void 0 || getKey && sideConditionData[getKey]) {
handlers.push(this.resolvePriority({
effect: sideCondition,
callback,
state: sideConditionData,
end: customHolder ? null : side.removeSideCondition,
effectHolder: customHolder || side
}, callbackName));
}
}
return handlers;
}
/**
* Use this function to attach custom event handlers to a battle. See Battle#runEvent for
* more information on how to write callbacks for event handlers.
*
* Try to use this sparingly. Most event handlers can be simply placed in a format instead.
*
* this.onEvent(eventid, target, callback)
* will set the callback as an event handler for the target when eventid is called with the
* default priority. Currently only valid formats are supported as targets but this will
* eventually be expanded to support other target types.
*
* this.onEvent(eventid, target, priority, callback)
* will set the callback as an event handler for the target when eventid is called with the
* provided priority. Priority can either be a number or an object that contains the priority,
* order, and subOrder for the event handler as needed (undefined keys will use default values)
*/
onEvent(eventid, target, ...rest) {
if (!eventid)
throw new TypeError("Event handlers must have an event to listen to");
if (!target)
throw new TypeError("Event handlers must have a target");
if (!rest.length)
throw new TypeError("Event handlers must have a callback");
if (target.effectType !== "Format") {
throw new TypeError(`${target.name} is a ${target.effectType} but only Format targets are supported right now`);
}
let callback, priority, order, subOrder, data;
if (rest.length === 1) {
[callback] = rest;
priority = 0;
order = false;
subOrder = 0;
} else {
[data, callback] = rest;
if (typeof data === "object") {
priority = data["priority"] || 0;
order = data["order"] || false;
subOrder = data["subOrder"] || 0;
} else {
priority = data || 0;
order = false;
subOrder = 0;
}
}
const eventHandler = { callback, target, priority, order, subOrder };
if (!this.events)
this.events = {};
const callbackName = `on${eventid}`;
const eventHandlers = this.events[callbackName];
if (eventHandlers === void 0) {
this.events[callbackName] = [eventHandler];
} else {
eventHandlers.push(eventHandler);
}
}
checkMoveMakesContact(move, attacker, defender, announcePads = false) {
if (move.flags["contact"] && attacker.hasItem("protectivepads")) {
if (announcePads) {
this.add("-activate", defender, this.effect.fullname);
this.add("-activate", attacker, "item: Protective Pads");
}
return false;
}
return move.flags["contact"];
}
getPokemon(fullname) {
if (typeof fullname !== "string")
fullname = fullname.fullname;
for (const side of this.sides) {
for (const pokemon of side.pokemon) {
if (pokemon.fullname === fullname)
return pokemon;
}
}
return null;
}
getPokemonByPNX(pnx) {
for (const side of this.sides) {
for (const pokemon of side.pokemon) {
if (pokemon.getSlot().toString() === pnx)
return pokemon;
}
}
return null;
}
getAllPokemon() {
const pokemonList = [];
for (const side of this.sides) {
pokemonList.push(...side.pokemon);
}
return pokemonList;
}
getAllActive() {
const pokemonList = [];
for (const side of this.sides) {
for (const pokemon of side.active) {
if (pokemon && !pokemon.fainted) {
pokemonList.push(pokemon);
}
}
}
return pokemonList;
}
makeRequest(type) {
if (type) {
this.requestState = type;
for (const side of this.sides) {
side.clearChoice();
}
} else {
type = this.requestState;
}
for (const side of this.sides) {
side.activeRequest = null;
}
if (type === "teampreview") {
const pickedTeamSize = this.ruleTable.pickedTeamSize;
this.add("teampreview" + (pickedTeamSize ? "|" + pickedTeamSize : ""));
}
const requests = this.getRequests(type);
for (let i = 0; i < this.sides.length; i++) {
this.sides[i].emitRequest(requests[i]);
}
if (this.sides.every((side) => side.isChoiceDone())) {
throw new Error(`Choices are done immediately after a request`);
}
}
clearRequest() {
this.requestState = "";
for (const side of this.sides) {
side.activeRequest = null;
side.clearChoice();
}
}
getRequests(type) {
const requests = Array(this.sides.length).fill(null);
switch (type) {
case "switch":
for (let i = 0; i < this.sides.length; i++) {
const side = this.sides[i];
if (!side.pokemonLeft)
continue;
const switchTable = side.active.map((pokemon) => !!pokemon?.switchFlag);
if (switchTable.some(Boolean)) {
requests[i] = { forceSwitch: switchTable, side: side.getRequestData() };
}
}
break;
case "teampreview":
for (let i = 0; i < this.sides.length; i++) {
const side = this.sides[i];
const maxChosenTeamSize = this.ruleTable.pickedTeamSize || void 0;
requests[i] = { teamPreview: true, maxChosenTeamSize, side: side.getRequestData() };
}
break;
default:
for (let i = 0; i < this.sides.length; i++) {
const side = this.sides[i];
if (!side.pokemonLeft)
continue;
const activeData = side.active.map((pokemon) => pokemon?.getMoveRequestData());
requests[i] = { active: activeData, side: side.getRequestData() };
if (side.allySide) {
requests[i].ally = side.allySide.getRequestData(true);
}
}
break;
}
const multipleRequestsExist = requests.filter(Boolean).length >= 2;
for (let i = 0; i < this.sides.length; i++) {
if (requests[i]) {
if (!this.supportCancel || !multipleRequestsExist)
requests[i].noCancel = true;
} else {
requests[i] = { wait: true, side: this.sides[i].getRequestData() };
}
}
return requests;
}
tiebreak() {
if (this.ended)
return false;
this.inputLog.push(`>tiebreak`);
this.add("message", "Time's up! Going to tiebreaker...");
const notFainted = this.sides.map((side) => side.pokemon.filter((pokemon) => !pokemon.fainted).length);
this.add("-message", this.sides.map((side, i) => `${side.name}: ${notFainted[i]} Pokemon left`).join("; "));
const maxNotFainted = Math.max(...notFainted);
let tiedSides = this.sides.filter((side, i) => notFainted[i] === maxNotFainted);
if (tiedSides.length <= 1) {
return this.win(tiedSides[0]);
}
const hpPercentage = tiedSides.map((side) => side.pokemon.map((pokemon) => pokemon.hp / pokemon.maxhp).reduce((a, b) => a + b) * 100 / 6);
this.add("-message", tiedSides.map((side, i) => `${side.name}: ${Math.round(hpPercentage[i])}% total HP left`).join("; "));
const maxPercentage = Math.max(...hpPercentage);
tiedSides = tiedSides.filter((side, i) => hpPercentage[i] === maxPercentage);
if (tiedSides.length <= 1) {
return this.win(tiedSides[0]);
}
const hpTotal = tiedSides.map((side) => side.pokemon.map((pokemon) => pokemon.hp).reduce((a, b) => a + b));
this.add("-message", tiedSides.map((side, i) => `${side.name}: ${Math.round(hpTotal[i])} total HP left`).join("; "));
const maxTotal = Math.max(...hpTotal);
tiedSides = tiedSides.filter((side, i) => hpTotal[i] === maxTotal);
if (tiedSides.length <= 1) {
return this.win(tiedSides[0]);
}
return this.tie();
}
forceWin(side = null) {
if (this.ended)
return false;
this.inputLog.push(side ? `>forcewin ${side}` : `>forcetie`);
return this.win(side);
}
tie() {
return this.win();
}
win(side) {
if (this.ended)
return false;
if (side && typeof side === "string") {
side = this.getSide(side);
} else if (!side || !this.sides.includes(side)) {
side = null;
}
this.winner = side ? side.name : "";
this.add("");
if (side?.allySide) {
this.add("win", side.name + " & " + side.allySide.name);
} else if (side) {
this.add("win", side.name);
} else {
this.add("tie");
}
this.updatePP();
this.ended = true;
this.requestState = "";
for (const s of this.sides) {
if (s)
s.activeRequest = null;
}
return true;
}
lose(side) {
if (typeof side === "string") {
side = this.getSide(side);
}
if (!side)
return;
if (this.gameType !== "freeforall") {
return this.win(side.foe);
}
if (!side.pokemonLeft)
return;
side.pokemonLeft = 0;
side.active[0]?.faint();
this.faintMessages(false, true);
if (!this.ended && side.requestState) {
side.emitRequest({ wait: true, side: side.getRequestData() });
side.clearChoice();
if (this.allChoicesDone())
this.commitDecisions();
}
return true;
}
canSwitch(side) {
return this.possibleSwitches(side).length;
}
getRandomSwitchable(side) {
const canSwitchIn = this.possibleSwitches(side);
return canSwitchIn.length ? this.sample(canSwitchIn) : null;
}
possibleSwitches(side) {
if (!side.pokemonLeft)
return [];
const canSwitchIn = [];
for (let i = side.active.length; i < side.pokemon.length; i++) {
const pokemon = side.pokemon[i];
if (!pokemon.fainted) {
canSwitchIn.push(pokemon);
}
}
return canSwitchIn;
}
swapPosition(pokemon, newPosition, attributes) {
if (newPosition >= pokemon.side.active.length) {
throw new Error("Invalid swap position");
}
const target = pokemon.side.active[newPosition];
if (newPosition !== 1 && (!target || target.fainted))
return false;
this.add("swap", pokemon, newPosition, attributes || "");
const side = pokemon.side;
side.pokemon[pokemon.position] = target;
side.pokemon[newPosition] = pokemon;
side.active[pokemon.position] = side.pokemon[pokemon.position];
side.active[newPosition] = side.pokemon[newPosition];
if (target)
target.position = pokemon.position;
pokemon.position = newPosition;
this.runEvent("Swap", target, pokemon);
this.runEvent("Swap", pokemon, target);
return true;
}
getAtSlot(slot) {
if (!slot)
return null;
const side = this.sides[slot.charCodeAt(1) - 49];
const position = slot.charCodeAt(2) - 97;
const positionOffset = Math.floor(side.n / 2) * side.active.length;
return side.active[position - positionOffset];
}
faint(pokemon, source, effect) {
pokemon.faint(source, effect);
}
nextTurn() {
this.turn++;
this.lastSuccessfulMoveThisTurn = null;
const dynamaxEnding = [];
for (const pokemon of this.getAllActive()) {
if (pokemon.volatiles["dynamax"]?.turns === 3) {
dynamaxEnding.push(pokemon);
}
}
if (dynamaxEnding.length > 1) {
this.updateSpeed();
this.speedSort(dynamaxEnding);
}
for (const pokemon of dynamaxEnding) {
pokemon.removeVolatile("dynamax");
}
if (this.gen === 1) {
for (const pokemon of this.getAllActive()) {
if (pokemon.volatiles["partialtrappinglock"]) {
const target = pokemon.volatiles["partialtrappinglock"].locked;
if (target.hp <= 0 || !target.volatiles["partiallytrapped"]) {
delete pokemon.volatiles["partialtrappinglock"];
}
}
if (pokemon.volatiles["partiallytrapped"]) {
const source = pokemon.volatiles["partiallytrapped"].source;
if (source.hp <= 0 || !source.volatiles["partialtrappinglock"]) {
delete pokemon.volatiles["partiallytrapped"];
}
}
}
}
const trappedBySide = [];
const stalenessBySide = [];
for (const side of this.sides) {
let sideTrapped = true;
let sideStaleness;
for (const pokemon of side.active) {
if (!pokemon)
continue;
pokemon.moveThisTurn = "";
pokemon.newlySwitched = false;
pokemon.moveLastTurnResult = pokemon.moveThisTurnResult;
pokemon.moveThisTurnResult = void 0;
if (this.turn !== 1) {
pokemon.usedItemThisTurn = false;
pokemon.statsRaisedThisTurn = false;
pokemon.statsLoweredThisTurn = false;
pokemon.hurtThisTurn = null;
}
pokemon.maybeDisabled = false;
for (const moveSlot of pokemon.moveSlots) {
moveSlot.disabled = false;
moveSlot.disabledSource = "";
}
this.runEvent("DisableMove", pokemon);
for (const moveSlot of pokemon.moveSlots) {
this.singleEvent("DisableMove", this.dex.getActiveMove(moveSlot.id), null, pokemon);
}
if (pokemon.getLastAttackedBy() && this.gen >= 7)
pokemon.knownType = true;
for (let i = pokemon.attackedBy.length - 1; i >= 0; i--) {
const attack = pokemon.attackedBy[i];
if (attack.source.isActive) {
attack.thisTurn = false;
} else {
pokemon.attackedBy.splice(pokemon.attackedBy.indexOf(attack), 1);
}
}
if (this.gen >= 7 && !pokemon.terastallized) {
const seenPokemon = pokemon.illusion || pokemon;
const realTypeString = seenPokemon.getTypes(true).join("/");
if (realTypeString !== seenPokemon.apparentType) {
this.add("-start", pokemon, "typechange", realTypeString, "[silent]");
seenPokemon.apparentType = realTypeString;
if (pokemon.addedType) {
this.add("-start", pokemon, "typeadd", pokemon.addedType, "[silent]");
}
}
}
pokemon.trapped = pokemon.maybeTrapped = false;
this.runEvent("TrapPokemon", pokemon);
if (!pokemon.knownType || this.dex.getImmunity("trapped", pokemon)) {
this.runEvent("MaybeTrapPokemon", pokemon);
}
if (this.gen > 2) {
for (const source of pokemon.foes()) {
const species = (source.illusion || source).species;
if (!species.abilities)
continue;
for (const abilitySlot in species.abilities) {
const abilityName = species.abilities[abilitySlot];
if (abilityName === source.ability) {
continue;
}
const ruleTable = this.ruleTable;
if ((ruleTable.has("+hackmons") || !ruleTable.has("obtainableabilities")) && !this.format.team) {
continue;
} else if (abilitySlot === "H" && species.unreleasedHidden) {
continue;
}
const ability = this.dex.abilities.get(abilityName);
if (ruleTable.has("-ability:" + ability.id))
continue;
if (pokemon.knownType && !this.dex.getImmunity("trapped", pokemon))
continue;
this.singleEvent("FoeMaybeTrapPokemon", ability, {}, pokemon, source);
}
}
}
if (pokemon.fainted)
continue;
sideTrapped = sideTrapped && pokemon.trapped;
const staleness = pokemon.volatileStaleness || pokemon.staleness;
if (staleness)
sideStaleness = sideStaleness === "external" ? sideStaleness : staleness;
pokemon.activeTurns++;
}
trappedBySide.push(sideTrapped);
stalenessBySide.push(sideStaleness);
side.faintedLastTurn = side.faintedThisTurn;
side.faintedThisTurn = null;
}
if (this.maybeTriggerEndlessBattleClause(trappedBySide, stalenessBySide))
return;
if (this.gameType === "triples" && this.sides.every((side) => side.pokemonLeft === 1)) {
const actives = this.getAllActive();
if (actives.length > 1 && !actives[0].isAdjacent(actives[1])) {
this.swapPosition(actives[0], 1, "[silent]");
this.swapPosition(actives[1], 1, "[silent]");
this.add("-center");
}
}
this.add("turn", this.turn);
if (this.gameType === "multi") {
for (const side of this.sides) {
if (side.canDynamaxNow()) {
if (this.turn === 1) {
this.addSplit(side.id, ["-candynamax", side.id]);
} else {
this.add("-candynamax", side.id);
}
}
}
}
this.updatePP();
if (this.gen === 2)
this.quickClawRoll = this.randomChance(60, 256);
if (this.gen === 3)
this.quickClawRoll = this.randomChance(1, 5);
if (this.ruleTable.has("crazyhouserule")) {
for (const side of this.sides) {
let buf = `raw|${side.name}'s team:<br />`;
for (const pokemon of side.pokemon) {
if (!buf.endsWith("<br />"))
buf += "/</span>​";
if (pokemon.fainted) {
buf += `<span style="white-space:nowrap;"><span style="opacity:.3"><psicon pokemon="${pokemon.species.id}" /></span>`;
} else {
buf += `<span style="white-space:nowrap"><psicon pokemon="${pokemon.species.id}" />`;
}
}
this.add(`${buf}</span>`);
}
}
this.makeRequest("move");
}
maybeTriggerEndlessBattleClause(trappedBySide, stalenessBySide) {
if (this.gen <= 1) {
const noProgressPossible = this.sides.every((side) => {
const foeAllGhosts = side.foe.pokemon.every((pokemon) => pokemon.fainted || pokemon.hasType("Ghost"));
const foeAllTransform = side.foe.pokemon.every((pokemon) => pokemon.fainted || (this.dex.currentMod !== "gen1stadium" || pokemon.species.id !== "ditto") && // there are some subtleties such as a Mew with only Transform and auto-fail moves,
// but it's unlikely to come up in a real game so there's no need to handle it
pokemon.moves.every((moveid) => moveid === "transform"));
return side.pokemon.every((pokemon) => pokemon.fainted || // frozen pokemon can't thaw in gen 1 without outside help
pokemon.status === "frz" || pokemon.moves.every((moveid) => moveid === "transform") && foeAllTransform || pokemon.moveSlots.every((slot) => slot.pp === 0) && foeAllGhosts);
});
if (noProgressPossible) {
this.add("-message", `This battle cannot progress. Endless Battle Clause activated!`);
return this.tie();
}
}
if (this.turn <= 100)
return;
if (this.turn >= 1e3) {
this.add("message", `It is turn 1000. You have hit the turn limit!`);
this.tie();
return true;
}
if (this.turn >= 500 && this.turn % 100 === 0 || this.turn >= 900 && this.turn % 10 === 0 || // every 10 turns past turn 900,
this.turn >= 990) {
const turnsLeft = 1e3 - this.turn;
const turnsLeftText = turnsLeft === 1 ? `1 turn` : `${turnsLeft} turns`;
this.add("bigerror", `You will auto-tie if the battle doesn't end in ${turnsLeftText} (on turn 1000).`);
}
if (!this.ruleTable.has("endlessbattleclause"))
return;
if (this.format.gameType === "freeforall")
return;
if (!stalenessBySide.every((s) => !!s) || !stalenessBySide.some((s) => s === "external"))
return;
const canSwitch = [];
for (const [i, trapped] of trappedBySide.entries()) {
canSwitch[i] = false;
if (trapped)
break;
const side = this.sides[i];
for (const pokemon of side.pokemon) {
if (!pokemon.fainted && !(pokemon.volatileStaleness || pokemon.staleness)) {
canSwitch[i] = true;
break;
}
}
}
if (canSwitch.every((s) => s))
return;
const losers = [];
for (const side of this.sides) {
let berry = false;
let cycle = false;
for (const pokemon of side.pokemon) {
berry = import_pokemon.RESTORATIVE_BERRIES.has((0, import_dex.toID)(pokemon.set.item));
if (["harvest", "pickup"].includes((0, import_dex.toID)(pokemon.set.ability)) || pokemon.set.moves.map(import_dex.toID).includes("recycle")) {
cycle = true;
}
if (berry && cycle)
break;
}
if (berry && cycle)
losers.push(side);
}
if (losers.length === 1) {
const loser = losers[0];
this.add("-message", `${loser.name}'s team started with the rudimentary means to perform restorative berry-cycling and thus loses.`);
return this.win(loser.foe);
}
if (losers.length === this.sides.length) {
this.add("-message", `Each side's team started with the rudimentary means to perform restorative berry-cycling.`);
}
return this.tie();
}
start() {
if (this.deserialized)
return;
if (!this.sides.every((side) => !!side))
throw new Error(`Missing sides: ${this.sides}`);
if (this.started)
throw new Error(`Battle already started`);
const format = this.format;
this.started = true;
if (this.gameType === "multi") {
this.sides[1].foe = this.sides[2];
this.sides[0].foe = this.sides[3];
this.sides[2].foe = this.sides[1];
this.sides[3].foe = this.sides[0];
this.sides[1].allySide = this.sides[3];
this.sides[0].allySide = this.sides[2];
this.sides[2].allySide = this.sides[0];
this.sides[3].allySide = this.sides[1];
this.sides[2].sideConditions = this.sides[0].sideConditions;
this.sides[3].sideConditions = this.sides[1].sideConditions;
} else {
this.sides[1].foe = this.sides[0];
this.sides[0].foe = this.sides[1];
if (this.sides.length > 2) {
this.sides[2].foe = this.sides[3];
this.sides[3].foe = this.sides[2];
}
}
for (const side of this.sides) {
this.add("teamsize", side.id, side.pokemon.length);
}
this.add("gen", this.gen);
this.add("tier", format.name);
if (this.rated) {
if (this.rated === "Rated battle")
this.rated = true;
this.add("rated", typeof this.rated === "string" ? this.rated : "");
}
if (format.onBegin)
format.onBegin.call(this);
for (const rule of this.ruleTable.keys()) {
if ("+*-!".includes(rule.charAt(0)))
continue;
const subFormat = this.dex.formats.get(rule);
if (subFormat.onBegin)
subFormat.onBegin.call(this);
}
if (this.sides.some((side) => !side.pokemon[0])) {
throw new Error("Battle not started: A player has an empty team.");
}
if (this.debugMode) {
this.checkEVBalance();
}
if (format.onTeamPreview)
format.onTeamPreview.call(this);
for (const rule of this.ruleTable.keys()) {
if ("+*-!".includes(rule.charAt(0)))
continue;
const subFormat = this.dex.formats.get(rule);
if (subFormat.onTeamPreview)
subFormat.onTeamPreview.call(this);
}
this.queue.addChoice({ choice: "start" });
this.midTurn = true;
if (!this.requestState)
this.go();
}
restart(send) {
if (!this.deserialized)
throw new Error("Attempt to restart a battle which has not been deserialized");
this.send = send;
}
checkEVBalance() {
let limitedEVs = null;
for (const side of this.sides) {
const sideLimitedEVs = !side.pokemon.some(
(pokemon) => Object.values(pokemon.set.evs).reduce((a, b) => a + b, 0) > 510
);
if (limitedEVs === null) {
limitedEVs = sideLimitedEVs;
} else if (limitedEVs !== sideLimitedEVs) {
this.add("bigerror", "Warning: One player isn't adhering to a 510 EV limit, and the other player is.");
}
}
}
boost(boost, target = null, source = null, effect = null, isSecondary = false, isSelf = false) {
if (this.event) {
if (!target)
target = this.event.target;
if (!source)
source = this.event.source;
if (!effect)
effect = this.effect;
}
if (!target?.hp)
return 0;
if (!target.isActive)
return false;
if (this.gen > 5 && !target.side.foePokemonLeft())
return false;
boost = this.runEvent("ChangeBoost", target, source, effect, { ...boost });
boost = target.getCappedBoost(boost);
boost = this.runEvent("TryBoost", target, source, effect, { ...boost });
let success = null;
let boosted = isSecondary;
let boostName;
for (boostName in boost) {
const currentBoost = {
[boostName]: boost[boostName]
};
let boostBy = target.boostBy(currentBoost);
let msg = "-boost";
if (boost[boostName] < 0 || target.boosts[boostName] === -6) {
msg = "-unboost";
boostBy = -boostBy;
}
if (boostBy) {
success = true;
switch (effect?.id) {
case "bellydrum":
case "angerpoint":
this.add("-setboost", target, "atk", target.boosts["atk"], "[from] " + effect.fullname);
break;
case "bellydrum2":
this.add(msg, target, boostName, boostBy, "[silent]");
this.hint("In Gen 2, Belly Drum boosts by 2 when it fails.");
break;
case "zpower":
this.add(msg, target, boostName, boostBy, "[zeffect]");
break;
default:
if (!effect)
break;
if (effect.effectType === "Move") {
this.add(msg, target, boostName, boostBy);
} else if (effect.effectType === "Item") {
this.add(msg, target, boostName, boostBy, "[from] item: " + effect.name);
} else {
if (effect.effectType === "Ability" && !boosted) {
this.add("-ability", target, effect.name, "boost");
boosted = true;
}
this.add(msg, target, boostName, boostBy);
}
break;
}
this.runEvent("AfterEachBoost", target, source, effect, currentBoost);
} else if (effect?.effectType === "Ability") {
if (isSecondary || isSelf)
this.add(msg, target, boostName, boostBy);
} else if (!isSecondary && !isSelf) {
this.add(msg, target, boostName, boostBy);
}
}
this.runEvent("AfterBoost", target, source, effect, boost);
if (success) {
if (Object.values(boost).some((x) => x > 0))
target.statsRaisedThisTurn = true;
if (Object.values(boost).some((x) => x < 0))
target.statsLoweredThisTurn = true;
}
return success;
}
spreadDamage(damage, targetArray = null, source = null, effect = null, instafaint = false) {
if (!targetArray)
return [0];
const retVals = [];
if (typeof effect === "string" || !effect)
effect = this.dex.conditions.getByID(effect || "");
for (const [i, curDamage] of damage.entries()) {
const target = targetArray[i];
let targetDamage = curDamage;
if (!(targetDamage || targetDamage === 0)) {
retVals[i] = targetDamage;
continue;
}
if (!target || !target.hp) {
retVals[i] = 0;
continue;
}
if (!target.isActive) {
retVals[i] = false;
continue;
}
if (targetDamage !== 0)
targetDamage = this.clampIntRange(targetDamage, 1);
if (effect.id !== "struggle-recoil") {
if (effect.effectType === "Weather" && !target.runStatusImmunity(effect.id)) {
this.debug("weather immunity");
retVals[i] = 0;
continue;
}
targetDamage = this.runEvent("Damage", target, source, effect, targetDamage, true);
if (!(targetDamage || targetDamage === 0)) {
this.debug("damage event failed");
retVals[i] = curDamage === true ? void 0 : targetDamage;
continue;
}
}
if (targetDamage !== 0)
targetDamage = this.clampIntRange(targetDamage, 1);
if (this.gen <= 1) {
if (this.dex.currentMod === "gen1stadium" || !["recoil", "drain"].includes(effect.id) && effect.effectType !== "Status") {
this.lastDamage = targetDamage;
}
}
retVals[i] = targetDamage = target.damage(targetDamage, source, effect);
if (targetDamage !== 0)
target.hurtThisTurn = target.hp;
if (source && effect.effectType === "Move")
source.lastDamage = targetDamage;
const name = effect.fullname === "tox" ? "psn" : effect.fullname;
switch (effect.id) {
case "partiallytrapped":
this.add("-damage", target, target.getHealth, "[from] " + this.effectState.sourceEffect.fullname, "[partiallytrapped]");
break;
case "powder":
this.add("-damage", target, target.getHealth, "[silent]");
break;
case "confused":
this.add("-damage", target, target.getHealth, "[from] confusion");
break;
default:
if (effect.effectType === "Move" || !name) {
this.add("-damage", target, target.getHealth);
} else if (source && (source !== target || effect.effectType === "Ability")) {
this.add("-damage", target, target.getHealth, "[from] " + name, "[of] " + source);
} else {
this.add("-damage", target, target.getHealth, "[from] " + name);
}
break;
}
if (targetDamage && effect.effectType === "Move") {
if (this.gen <= 1 && effect.recoil && source) {
if (this.dex.currentMod !== "gen1stadium" || target.hp > 0) {
const amount = this.clampIntRange(Math.floor(targetDamage * effect.recoil[0] / effect.recoil[1]), 1);
this.damage(amount, source, target, "recoil");
}
}
if (this.gen <= 4 && effect.drain && source) {
const amount = this.clampIntRange(Math.floor(targetDamage * effect.drain[0] / effect.drain[1]), 1);
if (this.gen <= 1)
this.lastDamage = amount;
this.heal(amount, source, target, "drain");
}
if (this.gen > 4 && effect.drain && source) {
const amount = Math.round(targetDamage * effect.drain[0] / effect.drain[1]);
this.heal(amount, source, target, "drain");
}
}
}
if (instafaint) {
for (const [i, target] of targetArray.entries()) {
if (!retVals[i] || !target)
continue;
if (target.hp <= 0) {
this.debug("instafaint: " + this.faintQueue.map((entry) => entry.target.name));
this.faintMessages(true);
if (this.gen <= 2) {
target.faint();
if (this.gen <= 1) {
this.queue.clear();
for (const pokemon of this.getAllActive()) {
if (pokemon.volatiles["bide"] && pokemon.volatiles["bide"].damage) {
pokemon.volatiles["bide"].damage = 0;
this.hint("Desync Clause Mod activated!");
this.hint("In Gen 1, Bide's accumulated damage is reset to 0 when a Pokemon faints.");
}
}
}
}
}
}
}
return retVals;
}
damage(damage, target = null, source = null, effect = null, instafaint = false) {
if (this.event) {
if (!target)
target = this.event.target;
if (!source)
source = this.event.source;
if (!effect)
effect = this.effect;
}
return this.spreadDamage([damage], [target], source, effect, instafaint)[0];
}
directDamage(damage, target, source = null, effect = null) {
if (this.event) {
if (!target)
target = this.event.target;
if (!source)
source = this.event.source;
if (!effect)
effect = this.effect;
}
if (!target?.hp)
return 0;
if (!damage)
return 0;
damage = this.clampIntRange(damage, 1);
if (typeof effect === "string" || !effect)
effect = this.dex.conditions.getByID(effect || "");
if (this.gen <= 1 && this.dex.currentMod !== "gen1stadium" && ["confusion", "jumpkick", "highjumpkick"].includes(effect.id)) {
this.lastDamage = damage;
if (target.volatiles["substitute"]) {
const hint = "In Gen 1, if a Pokemon with a Substitute hurts itself due to confusion or Jump Kick/Hi Jump Kick recoil and the target";
if (source?.volatiles["substitute"]) {
source.volatiles["substitute"].hp -= damage;
if (source.volatiles["substitute"].hp <= 0) {
source.removeVolatile("substitute");
source.subFainted = true;
} else {
this.add("-activate", source, "Substitute", "[damage]");
}
this.hint(hint + " has a Substitute, the target's Substitute takes the damage.");
return damage;
} else {
this.hint(hint + " does not have a Substitute there is no damage dealt.");
return 0;
}
}
}
damage = target.damage(damage, source, effect);
switch (effect.id) {
case "strugglerecoil":
this.add("-damage", target, target.getHealth, "[from] recoil");
break;
case "confusion":
this.add("-damage", target, target.getHealth, "[from] confusion");
break;
default:
this.add("-damage", target, target.getHealth);
break;
}
if (target.fainted)
this.faint(target);
return damage;
}
heal(damage, target, source = null, effect = null) {
if (this.event) {
if (!target)
target = this.event.target;
if (!source)
source = this.event.source;
if (!effect)
effect = this.effect;
}
if (effect === "drain")
effect = this.dex.conditions.getByID(effect);
if (damage && damage <= 1)
damage = 1;
damage = this.trunc(damage);
damage = this.runEvent("TryHeal", target, source, effect, damage);
if (!damage)
return damage;
if (!target?.hp)
return false;
if (!target.isActive)
return false;
if (target.hp >= target.maxhp)
return false;
const finalDamage = target.heal(damage, source, effect);
switch (effect?.id) {
case "leechseed":
case "rest":
this.add("-heal", target, target.getHealth, "[silent]");
break;
case "drain":
this.add("-heal", target, target.getHealth, "[from] drain", "[of] " + source);
break;
case "wish":
break;
case "zpower":
this.add("-heal", target, target.getHealth, "[zeffect]");
break;
default:
if (!effect)
break;
if (effect.effectType === "Move") {
this.add("-heal", target, target.getHealth);
} else if (source && source !== target) {
this.add("-heal", target, target.getHealth, "[from] " + effect.fullname, "[of] " + source);
} else {
this.add("-heal", target, target.getHealth, "[from] " + effect.fullname);
}
break;
}
this.runEvent("Heal", target, source, effect, finalDamage);
return finalDamage;
}
chain(previousMod, nextMod) {
if (Array.isArray(previousMod)) {
previousMod = this.trunc(previousMod[0] * 4096 / previousMod[1]);
} else {
previousMod = this.trunc(previousMod * 4096);
}
if (Array.isArray(nextMod)) {
nextMod = this.trunc(nextMod[0] * 4096 / nextMod[1]);
} else {
nextMod = this.trunc(nextMod * 4096);
}
return (previousMod * nextMod + 2048 >> 12) / 4096;
}
chainModify(numerator, denominator) {
const previousMod = this.trunc(this.event.modifier * 4096);
if (Array.isArray(numerator)) {
denominator = numerator[1];
numerator = numerator[0];
}
const nextMod = this.trunc(numerator * 4096 / (denominator || 1));
this.event.modifier = (previousMod * nextMod + 2048 >> 12) / 4096;
}
modify(value, numerator, denominator) {
if (!denominator)
denominator = 1;
if (Array.isArray(numerator)) {
denominator = numerator[1];
numerator = numerator[0];
}
const tr = this.trunc;
const modifier = tr(numerator * 4096 / denominator);
return tr((tr(value * modifier) + 2048 - 1) / 4096);
}
/** Given a table of base stats and a pokemon set, return the actual stats. */
spreadModify(baseStats, set) {
const modStats = { atk: 10, def: 10, spa: 10, spd: 10, spe: 10 };
const tr = this.trunc;
let statName;
for (statName in modStats) {
const stat = baseStats[statName];
modStats[statName] = tr(tr(2 * stat + set.ivs[statName] + tr(set.evs[statName] / 4)) * set.level / 100 + 5);
}
if ("hp" in baseStats) {
const stat = baseStats["hp"];
modStats["hp"] = tr(tr(2 * stat + set.ivs["hp"] + tr(set.evs["hp"] / 4) + 100) * set.level / 100 + 10);
}
return this.natureModify(modStats, set);
}
natureModify(stats, set) {
const tr = this.trunc;
const nature = this.dex.natures.get(set.nature);
let s;
if (nature.plus) {
s = nature.plus;
const stat = this.ruleTable.has("overflowstatmod") ? Math.min(stats[s], 595) : stats[s];
stats[s] = tr(tr(stat * 110, 16) / 100);
}
if (nature.minus) {
s = nature.minus;
const stat = this.ruleTable.has("overflowstatmod") ? Math.min(stats[s], 728) : stats[s];
stats[s] = tr(tr(stat * 90, 16) / 100);
}
return stats;
}
finalModify(relayVar) {
relayVar = this.modify(relayVar, this.event.modifier);
this.event.modifier = 1;
return relayVar;
}
getCategory(move) {
return this.dex.moves.get(move).category || "Physical";
}
randomizer(baseDamage) {
const tr = this.trunc;
return tr(tr(baseDamage * (100 - this.random(16))) / 100);
}
/**
* Returns whether a proposed target for a move is valid.
*/
validTargetLoc(targetLoc, source, targetType) {
if (targetLoc === 0)
return true;
const numSlots = this.activePerHalf;
const sourceLoc = source.getLocOf(source);
if (Math.abs(targetLoc) > numSlots)
return false;
const isSelf = sourceLoc === targetLoc;
const isFoe = this.gameType === "freeforall" ? !isSelf : targetLoc > 0;
const acrossFromTargetLoc = -(numSlots + 1 - targetLoc);
const isAdjacent = targetLoc > 0 ? Math.abs(acrossFromTargetLoc - sourceLoc) <= 1 : Math.abs(targetLoc - sourceLoc) === 1;
if (this.gameType === "freeforall" && targetType === "adjacentAlly") {
return isAdjacent;
}
switch (targetType) {
case "randomNormal":
case "scripted":
case "normal":
return isAdjacent;
case "adjacentAlly":
return isAdjacent && !isFoe;
case "adjacentAllyOrSelf":
return isAdjacent && !isFoe || isSelf;
case "adjacentFoe":
return isAdjacent && isFoe;
case "any":
return !isSelf;
}
return false;
}
validTarget(target, source, targetType) {
return this.validTargetLoc(source.getLocOf(target), source, targetType);
}
getTarget(pokemon, move, targetLoc, originalTarget) {
move = this.dex.moves.get(move);
let tracksTarget = move.tracksTarget;
if (pokemon.hasAbility(["stalwart", "propellertail"]))
tracksTarget = true;
if (tracksTarget && originalTarget && originalTarget.isActive) {
return originalTarget;
}
if (move.smartTarget) {
const curTarget = pokemon.getAtLoc(targetLoc);
return curTarget && !curTarget.fainted ? curTarget : this.getRandomTarget(pokemon, move);
}
const selfLoc = pokemon.getLocOf(pokemon);
if (["adjacentAlly", "any", "normal"].includes(move.target) && targetLoc === selfLoc && !pokemon.volatiles["twoturnmove"] && !pokemon.volatiles["iceball"] && !pokemon.volatiles["rollout"]) {
return move.flags["futuremove"] ? pokemon : null;
}
if (move.target !== "randomNormal" && this.validTargetLoc(targetLoc, pokemon, move.target)) {
const target = pokemon.getAtLoc(targetLoc);
if (target?.fainted) {
if (this.gameType === "freeforall") {
return target;
}
if (target.isAlly(pokemon)) {
return target;
}
}
if (target && !target.fainted) {
return target;
}
}
return this.getRandomTarget(pokemon, move);
}
getRandomTarget(pokemon, move) {
move = this.dex.moves.get(move);
if (["self", "all", "allySide", "allyTeam", "adjacentAllyOrSelf"].includes(move.target)) {
return pokemon;
} else if (move.target === "adjacentAlly") {
if (this.gameType === "singles")
return null;
const adjacentAllies = pokemon.adjacentAllies();
return adjacentAllies.length ? this.sample(adjacentAllies) : null;
}
if (this.gameType === "singles")
return pokemon.side.foe.active[0];
if (this.activePerHalf > 2) {
if (move.target === "adjacentFoe" || move.target === "normal" || move.target === "randomNormal") {
const adjacentFoes = pokemon.adjacentFoes();
if (adjacentFoes.length)
return this.sample(adjacentFoes);
return pokemon.side.foe.active[pokemon.side.foe.active.length - 1 - pokemon.position];
}
}
return pokemon.side.randomFoe() || pokemon.side.foe.active[0];
}
checkFainted() {
for (const side of this.sides) {
for (const pokemon of side.active) {
if (pokemon.fainted) {
pokemon.status = "fnt";
pokemon.switchFlag = true;
}
}
}
}
capture(pokemon) {
if (this.ended)
return;
if (!pokemon.fainted) {
this.add("capture", pokemon);
if (pokemon.side.pokemonLeft)
pokemon.side.pokemonLeft--;
this.singleEvent("End", pokemon.getAbility(), pokemon.abilityState, pokemon);
pokemon.clearVolatile(false);
pokemon.fainted = true;
pokemon.illusion = null;
pokemon.isActive = false;
pokemon.isStarted = false;
pokemon.side.faintedThisTurn = pokemon;
if (this.checkWin())
return true;
}
return false;
}
// COBBLED: Sends out the entire team with updates on each move PP
updatePP() {
for (const side of this.sides) {
for (const pokemon of side.pokemon) {
this.add("pp_update", `${side.id}: ${pokemon.uuid}`, pokemon.moveSlots.map((move) => `${move.id}: ${move.pp}`).join(", "));
}
}
}
faintMessages(lastFirst = false, forceCheck = false, checkWin = true) {
if (this.ended)
return;
const length = this.faintQueue.length;
if (!length) {
if (forceCheck && this.checkWin())
return true;
return false;
}
if (lastFirst) {
this.faintQueue.unshift(this.faintQueue[this.faintQueue.length - 1]);
this.faintQueue.pop();
}
let faintQueueLeft, faintData;
while (this.faintQueue.length) {
faintQueueLeft = this.faintQueue.length;
faintData = this.faintQueue.shift();
const pokemon = faintData.target;
if (!pokemon.fainted && this.runEvent("BeforeFaint", pokemon, faintData.source, faintData.effect)) {
this.add("faint", pokemon);
if (pokemon.side.pokemonLeft)
pokemon.side.pokemonLeft--;
if (pokemon.side.totalFainted < 100)
pokemon.side.totalFainted++;
this.runEvent("Faint", pokemon, faintData.source, faintData.effect);
this.singleEvent("End", pokemon.getAbility(), pokemon.abilityState, pokemon);
pokemon.clearVolatile(false);
pokemon.fainted = true;
pokemon.illusion = null;
pokemon.isActive = false;
pokemon.isStarted = false;
delete pokemon.terastallized;
pokemon.side.faintedThisTurn = pokemon;
if (this.faintQueue.length >= faintQueueLeft)
checkWin = true;
}
}
if (this.gen <= 1) {
this.queue.clear();
for (const pokemon of this.getAllActive()) {
if (pokemon.volatiles["bide"] && pokemon.volatiles["bide"].damage) {
pokemon.volatiles["bide"].damage = 0;
this.hint("Desync Clause Mod activated!");
this.hint("In Gen 1, Bide's accumulated damage is reset to 0 when a Pokemon faints.");
}
}
} else if (this.gen <= 3 && this.gameType === "singles") {
for (const pokemon of this.getAllActive()) {
if (this.gen <= 2) {
this.queue.cancelMove(pokemon);
} else {
this.queue.cancelAction(pokemon);
}
}
}
if (checkWin && this.checkWin(faintData))
return true;
if (faintData && length) {
this.runEvent("AfterFaint", faintData.target, faintData.source, faintData.effect, length);
}
return false;
}
checkWin(faintData) {
let team1PokemonLeft = this.sides[0].pokemonLeft;
let team2PokemonLeft = this.sides[1].pokemonLeft;
const team3PokemonLeft = this.gameType === "freeforall" && this.sides[2].pokemonLeft;
const team4PokemonLeft = this.gameType === "freeforall" && this.sides[3].pokemonLeft;
if (this.gameType === "multi") {
team1PokemonLeft += this.sides[2].pokemonLeft;
team2PokemonLeft += this.sides[3].pokemonLeft;
}
if (!team1PokemonLeft && !team2PokemonLeft && !team3PokemonLeft && !team4PokemonLeft) {
this.win(faintData && this.gen > 4 ? faintData.target.side : null);
return true;
}
for (const side of this.sides) {
if (!side.foePokemonLeft()) {
this.win(side);
return true;
}
}
}
getActionSpeed(action) {
if (action.choice === "move") {
let move = action.move;
if (action.zmove) {
const zMoveName = this.actions.getZMove(action.move, action.pokemon, true);
if (zMoveName) {
const zMove = this.dex.getActiveMove(zMoveName);
if (zMove.exists && zMove.isZ) {
move = zMove;
}
}
}
if (action.maxMove) {
const maxMoveName = this.actions.getMaxMove(action.maxMove, action.pokemon);
if (maxMoveName) {
const maxMove = this.actions.getActiveMaxMove(action.move, action.pokemon);
if (maxMove.exists && maxMove.isMax) {
move = maxMove;
}
}
}
let priority = this.dex.moves.get(move.id).priority;
priority = this.singleEvent("ModifyPriority", move, null, action.pokemon, null, null, priority);
priority = this.runEvent("ModifyPriority", action.pokemon, null, move, priority);
action.priority = priority + action.fractionalPriority;
if (this.gen > 5)
action.move.priority = priority;
}
if (!action.pokemon) {
action.speed = 1;
} else {
action.speed = action.pokemon.getActionSpeed();
}
}
runAction(action) {
const pokemonOriginalHP = action.pokemon?.hp;
let residualPokemon = [];
switch (action.choice) {
case "start": {
for (const side of this.sides) {
if (side.pokemonLeft)
side.pokemonLeft = side.pokemon.length;
}
this.add("start");
for (const pokemon of this.getAllPokemon()) {
let rawSpecies = null;
if (pokemon.species.id === "zacian" && pokemon.item === "rustedsword") {
rawSpecies = this.dex.species.get("Zacian-Crowned");
} else if (pokemon.species.id === "zamazenta" && pokemon.item === "rustedshield") {
rawSpecies = this.dex.species.get("Zamazenta-Crowned");
}
if (!rawSpecies)
continue;
const species = pokemon.setSpecies(rawSpecies);
if (!species)
continue;
pokemon.baseSpecies = rawSpecies;
pokemon.details = species.name + (pokemon.level === 100 ? "" : ", L" + pokemon.level) + (pokemon.gender === "" ? "" : ", " + pokemon.gender) + (pokemon.set.shiny ? ", shiny" : "");
pokemon.setAbility(species.abilities["0"], null, true);
pokemon.baseAbility = pokemon.ability;
const behemothMove = {
"Zacian-Crowned": "behemothblade",
"Zamazenta-Crowned": "behemothbash"
};
const ironHead = pokemon.baseMoves.indexOf("ironhead");
if (ironHead >= 0) {
const move = this.dex.moves.get(behemothMove[rawSpecies.name]);
pokemon.baseMoveSlots[ironHead] = {
move: move.name,
id: move.id,
pp: move.noPPBoosts || move.isZ ? move.pp : move.pp * 8 / 5,
maxpp: move.noPPBoosts || move.isZ ? move.pp : move.pp * 8 / 5,
target: move.target,
disabled: false,
disabledSource: "",
used: false
};
pokemon.moveSlots = pokemon.baseMoveSlots.slice();
}
}
if (this.format.onBattleStart)
this.format.onBattleStart.call(this);
for (const rule of this.ruleTable.keys()) {
if ("+*-!".includes(rule.charAt(0)))
continue;
const subFormat = this.dex.formats.get(rule);
if (subFormat.onBattleStart)
subFormat.onBattleStart.call(this);
}
for (const side of this.sides) {
for (let i = 0; i < side.active.length; i++) {
if (!side.pokemonLeft) {
side.active[i] = side.pokemon[i];
side.active[i].fainted = true;
side.active[i].hp = 0;
} else {
this.actions.switchIn(side.pokemon[i], i);
}
}
}
for (const pokemon of this.getAllPokemon()) {
this.singleEvent("Start", this.dex.conditions.getByID(pokemon.species.id), pokemon.speciesState, pokemon);
}
this.midTurn = true;
break;
}
case "move":
if (!action.pokemon.isActive)
return false;
if (action.pokemon.fainted)
return false;
this.actions.runMove(
action.move,
action.pokemon,
action.targetLoc,
action.sourceEffect,
action.zmove,
void 0,
action.maxMove,
action.originalTarget
);
break;
case "megaEvo":
this.actions.runMegaEvo(action.pokemon);
break;
case "runDynamax":
action.pokemon.addVolatile("dynamax");
action.pokemon.side.dynamaxUsed = true;
if (action.pokemon.side.allySide)
action.pokemon.side.allySide.dynamaxUsed = true;
break;
case "terastallize":
this.actions.terastallize(action.pokemon);
break;
case "beforeTurnMove":
if (!action.pokemon.isActive)
return false;
if (action.pokemon.fainted)
return false;
this.debug("before turn callback: " + action.move.id);
const target = this.getTarget(action.pokemon, action.move, action.targetLoc);
if (!target)
return false;
if (!action.move.beforeTurnCallback)
throw new Error(`beforeTurnMove has no beforeTurnCallback`);
action.move.beforeTurnCallback.call(this, action.pokemon, target);
break;
case "priorityChargeMove":
if (!action.pokemon.isActive)
return false;
if (action.pokemon.fainted)
return false;
this.debug("priority charge callback: " + action.move.id);
if (!action.move.priorityChargeCallback)
throw new Error(`priorityChargeMove has no priorityChargeCallback`);
action.move.priorityChargeCallback.call(this, action.pokemon);
break;
case "event":
this.runEvent(action.event, action.pokemon);
break;
case "team":
if (action.index === 0) {
action.pokemon.side.pokemon = [];
}
action.pokemon.side.pokemon.push(action.pokemon);
action.pokemon.position = action.index;
return;
case "pass":
return;
case "instaswitch":
case "switch":
if (action.choice === "switch" && action.pokemon.status) {
this.singleEvent("CheckShow", this.dex.abilities.getByID("naturalcure"), null, action.pokemon);
}
if (this.actions.switchIn(action.target, action.pokemon.position, action.sourceEffect) === "pursuitfaint") {
if (this.gen <= 4) {
this.hint("Previously chosen switches continue in Gen 2-4 after a Pursuit target faints.");
action.priority = -101;
this.queue.unshift(action);
break;
} else {
this.hint("A Pokemon can't switch between when it runs out of HP and when it faints");
break;
}
}
break;
case "revivalblessing":
action.pokemon.side.pokemonLeft++;
if (action.target.position < action.pokemon.side.active.length) {
this.queue.addChoice({
choice: "instaswitch",
pokemon: action.target,
target: action.target
});
}
action.target.fainted = false;
action.target.faintQueued = false;
action.target.subFainted = false;
action.target.status = "";
action.target.hp = 1;
action.target.sethp(action.target.maxhp / 2);
this.add("-heal", action.target, action.target.getHealth, "[from] move: Revival Blessing");
action.pokemon.side.removeSlotCondition(action.pokemon, "revivalblessing");
break;
case "runUnnerve":
this.singleEvent("PreStart", action.pokemon.getAbility(), action.pokemon.abilityState, action.pokemon);
break;
case "runSwitch":
this.actions.runSwitch(action.pokemon);
break;
case "runPrimal":
if (!action.pokemon.transformed) {
this.singleEvent("Primal", action.pokemon.getItem(), action.pokemon.itemState, action.pokemon);
}
break;
case "shift":
if (!action.pokemon.isActive)
return false;
if (action.pokemon.fainted)
return false;
this.swapPosition(action.pokemon, 1);
break;
case "beforeTurn":
this.eachEvent("BeforeTurn");
break;
case "residual":
this.add("");
this.clearActiveMove(true);
this.updateSpeed();
residualPokemon = this.getAllActive().map((pokemon) => [pokemon, pokemon.getUndynamaxedHP()]);
this.residualEvent("Residual");
this.add("upkeep");
break;
}
for (const side of this.sides) {
for (const pokemon of side.active) {
if (pokemon.forceSwitchFlag) {
if (pokemon.hp)
this.actions.dragIn(pokemon.side, pokemon.position);
pokemon.forceSwitchFlag = false;
}
}
}
this.clearActiveMove();
this.faintMessages();
if (this.ended)
return true;
if (!this.queue.peek() || this.gen <= 3 && ["move", "residual"].includes(this.queue.peek().choice)) {
this.checkFainted();
} else if (action.choice === "megaEvo" && this.gen === 7) {
this.eachEvent("Update");
for (const [i, queuedAction] of this.queue.list.entries()) {
if (queuedAction.pokemon === action.pokemon && queuedAction.choice === "move") {
this.queue.list.splice(i, 1);
queuedAction.mega = "done";
this.queue.insertChoice(queuedAction, true);
break;
}
}
return false;
} else if (this.queue.peek()?.choice === "instaswitch") {
return false;
}
if (this.gen >= 5) {
this.eachEvent("Update");
for (const [pokemon, originalHP] of residualPokemon) {
const maxhp = pokemon.getUndynamaxedHP(pokemon.maxhp);
if (pokemon.hp && pokemon.getUndynamaxedHP() <= maxhp / 2 && originalHP > maxhp / 2) {
this.runEvent("EmergencyExit", pokemon);
}
}
}
if (action.choice === "runSwitch") {
const pokemon = action.pokemon;
if (pokemon.hp && pokemon.hp <= pokemon.maxhp / 2 && pokemonOriginalHP > pokemon.maxhp / 2) {
this.runEvent("EmergencyExit", pokemon);
}
}
const switches = this.sides.map(
(side) => side.active.some((pokemon) => pokemon && !!pokemon.switchFlag)
);
for (let i = 0; i < this.sides.length; i++) {
let reviveSwitch = false;
if (switches[i] && !this.canSwitch(this.sides[i])) {
for (const pokemon of this.sides[i].active) {
if (this.sides[i].slotConditions[pokemon.position]["revivalblessing"]) {
reviveSwitch = true;
continue;
}
pokemon.switchFlag = false;
}
if (!reviveSwitch)
switches[i] = false;
} else if (switches[i]) {
for (const pokemon of this.sides[i].active) {
if (pokemon.switchFlag && pokemon.switchFlag !== "revivalblessing" && !pokemon.skipBeforeSwitchOutEventFlag) {
this.runEvent("BeforeSwitchOut", pokemon);
pokemon.skipBeforeSwitchOutEventFlag = true;
this.faintMessages();
if (this.ended)
return true;
if (pokemon.fainted) {
switches[i] = this.sides[i].active.some((sidePokemon) => sidePokemon && !!sidePokemon.switchFlag);
}
}
}
}
}
for (const playerSwitch of switches) {
if (playerSwitch) {
this.makeRequest("switch");
return true;
}
}
if (this.gen < 5)
this.eachEvent("Update");
if (this.gen >= 8 && (this.queue.peek()?.choice === "move" || this.queue.peek()?.choice === "runDynamax")) {
this.updateSpeed();
for (const queueAction of this.queue.list) {
if (queueAction.pokemon)
this.getActionSpeed(queueAction);
}
this.queue.sort();
}
return false;
}
go() {
this.add("");
this.add("t:", Math.floor(Date.now() / 1e3));
if (this.requestState)
this.requestState = "";
if (!this.midTurn) {
this.queue.insertChoice({ choice: "beforeTurn" });
this.queue.addChoice({ choice: "residual" });
this.midTurn = true;
}
let action;
while (action = this.queue.shift()) {
this.runAction(action);
if (this.requestState || this.ended)
return;
}
this.nextTurn();
this.midTurn = false;
this.queue.clear();
}
/**
* Takes a choice string passed from the client. Starts the next
* turn if all required choices have been made.
*/
choose(sideid, input) {
const side = this.getSide(sideid);
if (!side.choose(input))
return false;
if (!side.isChoiceDone()) {
side.emitChoiceError(`Incomplete choice: ${input} - missing other pokemon`);
return false;
}
if (this.allChoicesDone())
this.commitDecisions();
return true;
}
/**
* Convenience method for easily making choices.
*/
makeChoices(...inputs) {
if (inputs.length) {
for (const [i, input] of inputs.entries()) {
if (input)
this.sides[i].choose(input);
}
} else {
for (const side of this.sides) {
side.autoChoose();
}
}
this.commitDecisions();
}
commitDecisions() {
this.updateSpeed();
const oldQueue = this.queue.list;
this.queue.clear();
if (!this.allChoicesDone())
throw new Error("Not all choices done");
for (const side of this.sides) {
const choice = side.getChoice();
if (choice)
this.inputLog.push(`>${side.id} ${choice}`);
}
for (const side of this.sides) {
this.queue.addChoice(side.choice.actions);
}
this.clearRequest();
this.queue.sort();
this.queue.list.push(...oldQueue);
this.requestState = "";
for (const side of this.sides) {
side.activeRequest = null;
}
this.go();
if (this.log.length - this.sentLogPos > 500)
this.sendUpdates();
}
undoChoice(sideid) {
const side = this.getSide(sideid);
if (!side.requestState)
return;
if (side.choice.cantUndo) {
side.emitChoiceError(`Can't undo: A trapping/disabling effect would cause undo to leak information`);
return;
}
side.clearChoice();
}
/**
* returns true if both decisions are complete
*/
allChoicesDone() {
let totalActions = 0;
for (const side of this.sides) {
if (side.isChoiceDone()) {
if (!this.supportCancel)
side.choice.cantUndo = true;
totalActions++;
}
}
return totalActions >= this.sides.length;
}
hint(hint, once, side) {
if (this.hints.has(hint))
return;
if (side) {
this.addSplit(side.id, ["-hint", hint]);
} else {
this.add("-hint", hint);
}
if (once)
this.hints.add(hint);
}
addSplit(side, secret, shared) {
this.log.push(`|split|${side}`);
this.add(...secret);
if (shared) {
this.add(...shared);
} else {
this.log.push("");
}
}
add(...parts) {
if (!parts.some((part) => typeof part === "function")) {
this.log.push(`|${parts.join("|")}`);
return;
}
let side = null;
const secret = [];
const shared = [];
for (const part of parts) {
if (typeof part === "function") {
const split = part();
if (side && side !== split.side)
throw new Error("Multiple sides passed to add");
side = split.side;
secret.push(split.secret);
shared.push(split.shared);
} else {
secret.push(part);
shared.push(part);
}
}
this.addSplit(side, secret, shared);
}
// eslint-disable-next-line @typescript-eslint/ban-types
addMove(...args) {
this.lastMoveLine = this.log.length;
this.log.push(`|${args.join("|")}`);
}
// eslint-disable-next-line @typescript-eslint/ban-types
attrLastMove(...args) {
if (this.lastMoveLine < 0)
return;
if (this.log[this.lastMoveLine].startsWith("|-anim|")) {
if (args.includes("[still]")) {
this.log.splice(this.lastMoveLine, 1);
this.lastMoveLine = -1;
return;
}
} else if (args.includes("[still]")) {
const parts = this.log[this.lastMoveLine].split("|");
parts[4] = "";
this.log[this.lastMoveLine] = parts.join("|");
}
this.log[this.lastMoveLine] += `|${args.join("|")}`;
}
retargetLastMove(newTarget) {
if (this.lastMoveLine < 0)
return;
const parts = this.log[this.lastMoveLine].split("|");
parts[4] = newTarget.toString();
this.log[this.lastMoveLine] = parts.join("|");
}
debug(activity) {
if (this.debugMode) {
this.add("debug", activity);
}
}
getDebugLog() {
const channelMessages = extractChannelMessages(this.log.join("\n"), [-1]);
return channelMessages[-1].join("\n");
}
debugError(activity) {
this.add("debug", activity);
}
// players
getTeam(options) {
let team = options.team;
if (typeof team === "string")
team = import_teams.Teams.unpack(team);
if (team)
return team;
if (!options.seed) {
options.seed = import_prng.PRNG.generateSeed();
}
if (!this.teamGenerator) {
this.teamGenerator = import_teams.Teams.getGenerator(this.format, options.seed);
} else {
this.teamGenerator.setSeed(options.seed);
}
team = this.teamGenerator.getTeam(options);
return team;
}
setPlayer(slot, options) {
let side;
let didSomething = true;
const slotNum = parseInt(slot[1]) - 1;
if (!this.sides[slotNum]) {
const team = this.getTeam(options);
side = new import_side.Side(options.name || `Player ${slotNum + 1}`, this, slotNum, team);
if (options.avatar)
side.avatar = "" + options.avatar;
this.sides[slotNum] = side;
} else {
side = this.sides[slotNum];
didSomething = false;
if (options.name && side.name !== options.name) {
side.name = options.name;
didSomething = true;
}
if (options.avatar && side.avatar !== "" + options.avatar) {
side.avatar = "" + options.avatar;
didSomething = true;
}
if (options.team)
throw new Error(`Player ${slot} already has a team!`);
}
if (options.team && typeof options.team !== "string") {
options.team = import_teams.Teams.pack(options.team);
}
if (!didSomething)
return;
this.inputLog.push(`>player ${slot} ` + JSON.stringify(options));
this.add("player", side.id, side.name, side.avatar, options.rating || "");
if (this.sides.every((playerSide) => !!playerSide) && !this.started)
this.start();
}
/** @deprecated */
join(slot, name, avatar, team) {
this.setPlayer(slot, { name, avatar, team });
return this.getSide(slot);
}
sendUpdates() {
if (this.sentLogPos >= this.log.length)
return;
this.send("update", this.log.slice(this.sentLogPos));
this.sentLogPos = this.log.length;
if (!this.sentEnd && this.ended) {
const log = {
winner: this.winner,
seed: this.prngSeed,
turns: this.turn,
p1: this.sides[0].name,
p2: this.sides[1].name,
p3: this.sides[2] && this.sides[2].name,
p4: this.sides[3] && this.sides[3].name,
p1team: this.sides[0].team,
p2team: this.sides[1].team,
p3team: this.sides[2] && this.sides[2].team,
p4team: this.sides[3] && this.sides[3].team,
score: [this.sides[0].pokemonLeft, this.sides[1].pokemonLeft],
inputLog: this.inputLog
};
if (this.sides[2]) {
log.score.push(this.sides[2].pokemonLeft);
} else {
delete log.p3;
delete log.p3team;
}
if (this.sides[3]) {
log.score.push(this.sides[3].pokemonLeft);
} else {
delete log.p4;
delete log.p4team;
}
this.send("end", JSON.stringify(log));
this.sentEnd = true;
}
}
getSide(sideid) {
return this.sides[parseInt(sideid[1]) - 1];
}
destroy() {
this.field.destroy();
this.field = null;
for (let i = 0; i < this.sides.length; i++) {
if (this.sides[i]) {
this.sides[i].destroy();
this.sides[i] = null;
}
}
for (const action of this.queue.list) {
delete action.pokemon;
}
this.queue.battle = null;
this.queue = null;
this.log = [];
}
}
//# sourceMappingURL=battle.js.map