mirror of
https://github.com/smogon/pokemon-showdown.git
synced 2026-05-02 19:47:44 -05:00
594 lines
20 KiB
TypeScript
594 lines
20 KiB
TypeScript
/**
|
|
* Stadium 2 mechanics inherit from gen 2 mechanics, but fixes some bugs.
|
|
*/
|
|
export const Scripts: ModdedBattleScriptsData = {
|
|
inherit: 'gen2',
|
|
gen: 2,
|
|
pokemon: {
|
|
inherit: true,
|
|
getStat(statName, unboosted, unmodified, fastReturn) {
|
|
// @ts-ignore - type checking prevents 'hp' from being passed, but we're paranoid
|
|
if (statName === 'hp') throw new Error("Please read `maxhp` directly");
|
|
|
|
// base stat
|
|
let stat = this.storedStats[statName];
|
|
|
|
// Stat boosts.
|
|
if (!unboosted) {
|
|
let boost = this.boosts[statName];
|
|
if (boost > 6) boost = 6;
|
|
if (boost < -6) boost = -6;
|
|
if (boost >= 0) {
|
|
const boostTable = [1, 1.5, 2, 2.5, 3, 3.5, 4];
|
|
stat = Math.floor(stat * boostTable[boost]);
|
|
} else {
|
|
const numerators = [100, 66, 50, 40, 33, 28, 25];
|
|
stat = Math.floor(stat * numerators[-boost] / 100);
|
|
}
|
|
}
|
|
if (this.status === 'par' && statName === 'spe' && this.volatiles['parspeeddrop']) {
|
|
stat = Math.floor(stat / 4);
|
|
}
|
|
if (!unmodified) {
|
|
if (this.status === 'brn' && statName === 'atk' && this.volatiles['brnattackdrop']) {
|
|
stat = Math.floor(stat / 2);
|
|
}
|
|
}
|
|
|
|
// Gen 2 caps stats at 999 and min is 1.
|
|
stat = this.battle.clampIntRange(stat, 1, 999);
|
|
if (fastReturn) return stat;
|
|
|
|
// Screens
|
|
if (!unboosted) {
|
|
if (
|
|
(statName === 'def' && this.side.sideConditions['reflect']) ||
|
|
(statName === 'spd' && this.side.sideConditions['lightscreen'])
|
|
) {
|
|
stat *= 2;
|
|
}
|
|
}
|
|
|
|
// Handle boosting items
|
|
if (
|
|
(['Cubone', 'Marowak'].includes(this.species.name) && this.item === 'thickclub' && statName === 'atk') ||
|
|
(this.species.name === 'Pikachu' && this.item === 'lightball' && statName === 'spa')
|
|
) {
|
|
stat *= 2;
|
|
} else if (this.species.name === 'Ditto' && this.item === 'metalpowder' && ['def', 'spd'].includes(statName)) {
|
|
stat = Math.floor(stat * 1.5);
|
|
}
|
|
|
|
return stat;
|
|
},
|
|
},
|
|
// Stadium 2 shares gen 2 code but it fixes some problems with it.
|
|
actions: {
|
|
inherit: true,
|
|
tryMoveHit(target, pokemon, move) {
|
|
const positiveBoostTable = [1, 1.33, 1.66, 2, 2.33, 2.66, 3];
|
|
const negativeBoostTable = [1, 0.75, 0.6, 0.5, 0.43, 0.36, 0.33];
|
|
const doSelfDestruct = true;
|
|
let damage: number | false | undefined = 0;
|
|
|
|
if (move.selfdestruct && doSelfDestruct) {
|
|
this.battle.faint(pokemon, pokemon, move);
|
|
/**
|
|
* Keeping track of the last move used for self-ko clause,
|
|
* making sure to clear the opponents last move so that self-destruct and explosion
|
|
* does not persist between Pokemon, preventing problems caused by situations,
|
|
* such as a player from blowing up both they and their opponents second last Pokemon
|
|
* and their opponent blowing up their last Pokemon. If we did not clear here, there would be a problem.
|
|
*/
|
|
target.side.lastMove = null;
|
|
pokemon.side.lastMove = move;
|
|
}
|
|
|
|
let hitResult = this.battle.singleEvent('PrepareHit', move, {}, target, pokemon, move);
|
|
if (!hitResult) {
|
|
if (hitResult === false) this.battle.add('-fail', target);
|
|
return false;
|
|
}
|
|
this.battle.runEvent('PrepareHit', pokemon, target, move);
|
|
|
|
if (!this.battle.singleEvent('Try', move, null, pokemon, target, move)) {
|
|
return false;
|
|
}
|
|
|
|
if (move.target === 'all' || move.target === 'foeSide' || move.target === 'allySide' || move.target === 'allyTeam') {
|
|
if (move.target === 'all') {
|
|
hitResult = this.battle.runEvent('TryHitField', target, pokemon, move);
|
|
} 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(target, pokemon, move);
|
|
}
|
|
|
|
hitResult = this.battle.runEvent('Invulnerability', target, pokemon, move);
|
|
if (hitResult === false) {
|
|
this.battle.attrLastMove('[miss]');
|
|
this.battle.add('-miss', pokemon);
|
|
return false;
|
|
}
|
|
|
|
if (move.ignoreImmunity === undefined) {
|
|
move.ignoreImmunity = (move.category === 'Status');
|
|
}
|
|
|
|
if (
|
|
(!move.ignoreImmunity || (move.ignoreImmunity !== true && !move.ignoreImmunity[move.type])) &&
|
|
!target.runImmunity(move.type, true)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
hitResult = this.battle.singleEvent('TryImmunity', move, {}, target, pokemon, move);
|
|
if (hitResult === false) {
|
|
this.battle.add('-immune', target);
|
|
return false;
|
|
}
|
|
|
|
hitResult = this.battle.runEvent('TryHit', target, pokemon, move);
|
|
if (!hitResult) {
|
|
if (hitResult === false) this.battle.add('-fail', target);
|
|
return false;
|
|
}
|
|
|
|
let accuracy = move.accuracy;
|
|
if (move.alwaysHit) {
|
|
accuracy = true;
|
|
} else {
|
|
accuracy = this.battle.runEvent('Accuracy', target, pokemon, move, accuracy);
|
|
}
|
|
// Now, let's calculate the accuracy.
|
|
if (accuracy !== true) {
|
|
accuracy = Math.floor(accuracy * 255 / 100);
|
|
if (move.ohko) {
|
|
if (pokemon.level >= target.level) {
|
|
accuracy += (pokemon.level - target.level) * 2;
|
|
accuracy = Math.min(accuracy, 255);
|
|
} else {
|
|
this.battle.add('-immune', target, '[ohko]');
|
|
return false;
|
|
}
|
|
}
|
|
if (!move.ignoreAccuracy) {
|
|
if (pokemon.boosts.accuracy > 0) {
|
|
accuracy *= positiveBoostTable[pokemon.boosts.accuracy];
|
|
} else {
|
|
accuracy *= negativeBoostTable[-pokemon.boosts.accuracy];
|
|
}
|
|
}
|
|
if (!move.ignoreEvasion) {
|
|
if (target.boosts.evasion > 0 && !move.ignorePositiveEvasion) {
|
|
accuracy *= negativeBoostTable[target.boosts.evasion];
|
|
} else if (target.boosts.evasion < 0) {
|
|
accuracy *= positiveBoostTable[-target.boosts.evasion];
|
|
}
|
|
}
|
|
accuracy = Math.min(Math.floor(accuracy), 255);
|
|
accuracy = Math.max(accuracy, 1);
|
|
} else {
|
|
accuracy = this.battle.runEvent('Accuracy', target, pokemon, move, accuracy);
|
|
}
|
|
accuracy = this.battle.runEvent('ModifyAccuracy', target, pokemon, move, accuracy);
|
|
if (accuracy !== true) accuracy = Math.max(accuracy, 0);
|
|
if (move.alwaysHit) {
|
|
accuracy = true;
|
|
} else {
|
|
accuracy = this.battle.runEvent('Accuracy', target, pokemon, move, accuracy);
|
|
}
|
|
if (accuracy !== true && accuracy !== 255 && !this.battle.randomChance(accuracy, 256)) {
|
|
this.battle.attrLastMove('[miss]');
|
|
this.battle.add('-miss', pokemon);
|
|
damage = false;
|
|
return damage;
|
|
}
|
|
move.totalDamage = 0;
|
|
pokemon.lastDamage = 0;
|
|
if (move.multihit) {
|
|
let hits = move.multihit;
|
|
if (Array.isArray(hits)) {
|
|
if (hits[0] === 2 && hits[1] === 5) {
|
|
hits = this.battle.sample([2, 2, 2, 3, 3, 3, 4, 5]);
|
|
} else {
|
|
hits = this.battle.random(hits[0], hits[1] + 1);
|
|
}
|
|
}
|
|
hits = Math.floor(hits);
|
|
let nullDamage = true;
|
|
let moveDamage: number | undefined | false;
|
|
|
|
const isSleepUsable = move.sleepUsable || this.dex.moves.get(move.sourceEffect).sleepUsable;
|
|
let i: number;
|
|
for (i = 0; i < hits && target.hp && pokemon.hp; i++) {
|
|
if (pokemon.status === 'slp' && !isSleepUsable) break;
|
|
move.hit = i + 1;
|
|
if (move.hit === hits) move.lastHit = true;
|
|
moveDamage = this.moveHit(target, pokemon, move);
|
|
if (moveDamage === false) break;
|
|
if (nullDamage && (moveDamage || moveDamage === 0 || moveDamage === undefined)) nullDamage = false;
|
|
damage = (moveDamage || 0);
|
|
move.totalDamage += damage;
|
|
this.battle.eachEvent('Update');
|
|
}
|
|
if (i === 0) return 1;
|
|
if (nullDamage) damage = false;
|
|
this.battle.add('-hitcount', target, i);
|
|
} else {
|
|
damage = this.moveHit(target, pokemon, move);
|
|
move.totalDamage = damage;
|
|
}
|
|
if (move.category !== 'Status') {
|
|
target.gotAttacked(move, damage, pokemon);
|
|
}
|
|
if (move.ohko) this.battle.add('-ohko');
|
|
|
|
if (!move.negateSecondary) {
|
|
this.battle.singleEvent('AfterMoveSecondary', move, null, target, pokemon, move);
|
|
this.battle.runEvent('AfterMoveSecondary', target, pokemon, move);
|
|
}
|
|
// Implementing Recoil mechanics from Stadium 2.
|
|
// If a pokemon caused the other to faint with a recoil move and only one pokemon remains on both sides,
|
|
// recoil damage will not be taken.
|
|
if (move.recoil && move.totalDamage && (pokemon.side.pokemonLeft > 1 || target.side.pokemonLeft > 1 || target.hp)) {
|
|
this.battle.damage(this.calcRecoilDamage(move.totalDamage, move, pokemon), pokemon, target, 'recoil');
|
|
}
|
|
return damage;
|
|
},
|
|
getDamage(source, target, move, suppressMessages) {
|
|
// First of all, we get the move.
|
|
if (typeof move === 'string') {
|
|
move = this.dex.getActiveMove(move);
|
|
} else if (typeof move === 'number') {
|
|
move = {
|
|
basePower: move,
|
|
type: '???',
|
|
category: 'Physical',
|
|
willCrit: false,
|
|
flags: {},
|
|
} as unknown as ActiveMove;
|
|
}
|
|
|
|
// Let's test for immunities.
|
|
if (!move.ignoreImmunity || (move.ignoreImmunity !== true && !move.ignoreImmunity[move.type])) {
|
|
if (!target.runImmunity(move.type, true)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Is it an OHKO move?
|
|
if (move.ohko) {
|
|
return target.maxhp;
|
|
}
|
|
|
|
// We edit the damage through move's damage callback
|
|
if (move.damageCallback) {
|
|
return move.damageCallback.call(this.battle, source, target);
|
|
}
|
|
|
|
// We take damage from damage=level moves
|
|
if (move.damage === 'level') {
|
|
return source.level;
|
|
}
|
|
|
|
// If there's a fix move damage, we run it
|
|
if (move.damage) {
|
|
return move.damage;
|
|
}
|
|
|
|
// We check the category and typing to calculate later on the damage
|
|
move.category = this.battle.getCategory(move);
|
|
// '???' is typeless damage: used for Struggle and Confusion etc
|
|
if (!move.type) move.type = '???';
|
|
const type = move.type;
|
|
|
|
// We get the base power and apply basePowerCallback if necessary
|
|
let basePower: number | false | null | undefined = move.basePower;
|
|
if (move.basePowerCallback) {
|
|
basePower = move.basePowerCallback.call(this.battle, source, target, move);
|
|
}
|
|
|
|
// We check for Base Power
|
|
if (!basePower) {
|
|
if (basePower === 0) return; // Returning undefined means not dealing damage
|
|
return basePower;
|
|
}
|
|
basePower = this.battle.clampIntRange(basePower, 1);
|
|
|
|
// Checking for the move's Critical Hit ratio
|
|
let critRatio = this.battle.runEvent('ModifyCritRatio', source, target, move, move.critRatio || 0);
|
|
critRatio = this.battle.clampIntRange(critRatio, 0, 5);
|
|
const critMult = [0, 16, 8, 4, 3, 2];
|
|
let isCrit = move.willCrit || false;
|
|
if (typeof move.willCrit === 'undefined') {
|
|
if (critRatio) {
|
|
isCrit = this.battle.randomChance(1, critMult[critRatio]);
|
|
}
|
|
}
|
|
|
|
if (isCrit && this.battle.runEvent('CriticalHit', target, null, move)) {
|
|
target.getMoveHitData(move).crit = true;
|
|
}
|
|
|
|
// Happens after crit calculation
|
|
if (basePower) {
|
|
// confusion damage
|
|
if (move.isConfusionSelfHit) {
|
|
move.type = move.baseMoveType!;
|
|
basePower = this.battle.runEvent('BasePower', source, target, move, basePower, true);
|
|
move.type = '???';
|
|
} else {
|
|
basePower = this.battle.runEvent('BasePower', source, target, move, basePower, true);
|
|
}
|
|
if (basePower && move.basePowerModifier) {
|
|
basePower *= move.basePowerModifier;
|
|
}
|
|
}
|
|
if (!basePower) return 0;
|
|
basePower = this.battle.clampIntRange(basePower, 1);
|
|
|
|
// We now check for attacker and defender
|
|
let level = source.level;
|
|
|
|
// Using Beat Up
|
|
if (move.allies) {
|
|
this.battle.add('-activate', source, 'move: Beat Up', '[of] ' + move.allies[0].name);
|
|
level = move.allies[0].level;
|
|
}
|
|
|
|
const attacker = move.overrideOffensivePokemon === 'target' ? target : source;
|
|
const defender = move.overrideDefensivePokemon === 'source' ? source : target;
|
|
|
|
const isPhysical = move.category === 'Physical';
|
|
const atkType: StatIDExceptHP = move.overrideOffensiveStat || (isPhysical ? 'atk' : 'spa');
|
|
const defType: StatIDExceptHP = move.overrideDefensiveStat || (isPhysical ? 'def' : 'spd');
|
|
|
|
let unboosted = false;
|
|
let noburndrop = false;
|
|
|
|
if (isCrit) {
|
|
if (!suppressMessages) this.battle.add('-crit', target);
|
|
// Stat level modifications are ignored if they are neutral to or favour the defender.
|
|
// Reflect and Light Screen defensive boosts are only ignored if stat level modifications were also ignored as a result of that.
|
|
if (attacker.boosts[atkType] <= defender.boosts[defType]) {
|
|
unboosted = true;
|
|
noburndrop = true;
|
|
}
|
|
}
|
|
|
|
let attack = attacker.getStat(atkType, unboosted, noburndrop);
|
|
let defense = defender.getStat(defType, unboosted);
|
|
|
|
// Using Beat Up
|
|
if (move.allies) {
|
|
attack = move.allies[0].species.baseStats.atk;
|
|
move.allies.shift();
|
|
defense = defender.species.baseStats.def;
|
|
}
|
|
|
|
// Moves that ignore offense and defense respectively.
|
|
if (move.ignoreOffensive) {
|
|
this.battle.debug('Negating (sp)atk boost/penalty.');
|
|
// The attack drop from the burn is only applied when attacker's attack level is higher than defender's defense level.
|
|
attack = attacker.getStat(atkType, true, true);
|
|
}
|
|
|
|
if (move.ignoreDefensive) {
|
|
this.battle.debug('Negating (sp)def boost/penalty.');
|
|
defense = target.getStat(defType, true, true);
|
|
}
|
|
|
|
if (attack >= 256 || defense >= 256) {
|
|
attack = this.battle.clampIntRange(Math.floor(this.battle.clampIntRange(attack, 1, 999) / 4), 1);
|
|
defense = this.battle.clampIntRange(Math.floor(this.battle.clampIntRange(defense, 1, 999) / 4), 1);
|
|
}
|
|
|
|
// Self destruct moves halve defense at this point.
|
|
if (move.selfdestruct && defType === 'def') {
|
|
defense = this.battle.clampIntRange(Math.floor(defense / 2), 1);
|
|
}
|
|
|
|
// Let's go with the calculation now that we have what we need.
|
|
// We do it step by step just like the game does.
|
|
let damage = level * 2;
|
|
damage = Math.floor(damage / 5);
|
|
damage += 2;
|
|
damage *= basePower;
|
|
damage *= attack;
|
|
damage = Math.floor(damage / defense);
|
|
damage = Math.floor(damage / 50);
|
|
if (isCrit) damage *= 2;
|
|
damage = Math.floor(this.battle.runEvent('ModifyDamage', attacker, defender, move, damage));
|
|
damage = this.battle.clampIntRange(damage, 1, 997);
|
|
damage += 2;
|
|
|
|
// Weather modifiers
|
|
if (
|
|
(type === 'Water' && this.battle.field.isWeather('raindance')) ||
|
|
(type === 'Fire' && this.battle.field.isWeather('sunnyday'))
|
|
) {
|
|
damage = Math.floor(damage * 1.5);
|
|
} else if (
|
|
((type === 'Fire' || move.id === 'solarbeam') && this.battle.field.isWeather('raindance')) ||
|
|
(type === 'Water' && this.battle.field.isWeather('sunnyday'))
|
|
) {
|
|
damage = Math.floor(damage / 2);
|
|
}
|
|
|
|
// STAB damage bonus, the "???" type never gets STAB
|
|
if (type !== '???' && source.hasType(type)) {
|
|
damage += Math.floor(damage / 2);
|
|
}
|
|
|
|
// Type effectiveness
|
|
const totalTypeMod = target.runEffectiveness(move);
|
|
// Super effective attack
|
|
if (totalTypeMod > 0) {
|
|
if (!suppressMessages) this.battle.add('-supereffective', target);
|
|
damage *= 2;
|
|
if (totalTypeMod >= 2) {
|
|
damage *= 2;
|
|
}
|
|
}
|
|
// Resisted attack
|
|
if (totalTypeMod < 0) {
|
|
if (!suppressMessages) this.battle.add('-resisted', target);
|
|
damage = Math.floor(damage / 2);
|
|
if (totalTypeMod <= -2) {
|
|
damage = Math.floor(damage / 2);
|
|
}
|
|
}
|
|
|
|
// Apply random factor if damage is greater than 1, except for Flail and Reversal
|
|
if (!move.noDamageVariance && damage > 1) {
|
|
damage *= this.battle.random(217, 256);
|
|
damage = Math.floor(damage / 255);
|
|
}
|
|
|
|
// If damage is less than 1, we return 1
|
|
if (basePower && !Math.floor(damage)) {
|
|
return 1;
|
|
}
|
|
|
|
// We are done, this is the final damage
|
|
return damage;
|
|
},
|
|
},
|
|
/**
|
|
* Stadium 2 ignores stat drops due to status ailments upon boosting the dropped stat.
|
|
* For example: if a burned Snorlax uses Curse then it will ignore the attack drop from
|
|
* burn when it is recalculating its attack stat. This is why volatiles are added to status
|
|
* conditions, so that we can keep track of whether or not to apply the stat drop from
|
|
* statuses.
|
|
*/
|
|
boost(boost, 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 (typeof effect === 'string') effect = this.dex.conditions.get(effect);
|
|
if (!target?.hp) return 0;
|
|
let success = null;
|
|
boost = this.runEvent('TryBoost', target, source, effect, {...boost});
|
|
let i: BoostID;
|
|
for (i in boost) {
|
|
const currentBoost: SparseBoostsTable = {};
|
|
currentBoost[i] = boost[i];
|
|
let boostBy = target.boostBy(currentBoost);
|
|
let msg = '-boost';
|
|
if (boost[i]! < 0) {
|
|
msg = '-unboost';
|
|
boostBy = -boostBy;
|
|
}
|
|
if (boostBy) {
|
|
success = true;
|
|
// Check for boost increases deleting attack or speed drops
|
|
if (i === 'atk' && target.status === 'brn' && target.volatiles['brnattackdrop']) {
|
|
target.removeVolatile('brnattackdrop');
|
|
}
|
|
if (i === 'spe' && target.status === 'par' && target.volatiles['parspeeddrop']) {
|
|
target.removeVolatile('parspeeddrop');
|
|
}
|
|
if (!effect || effect.effectType === 'Move') {
|
|
this.add(msg, target, i, boostBy);
|
|
} else {
|
|
this.add(msg, target, i, boostBy, '[from] ' + effect.fullname);
|
|
}
|
|
this.runEvent('AfterEachBoost', target, source, effect, currentBoost);
|
|
}
|
|
}
|
|
this.runEvent('AfterBoost', target, source, effect, boost);
|
|
return success;
|
|
},
|
|
/**
|
|
* Implementing Self-KO Clause by having it check what the last move used by the players were
|
|
* in the case both Pokemon faint. Since the only way this can happen in Stadium 2 is if a player
|
|
* uses self-destruct or explosion, I can use this to determine who should win.
|
|
*/
|
|
faintMessages(lastFirst) {
|
|
if (this.ended) return;
|
|
const length = this.faintQueue.length;
|
|
if (!length) return false;
|
|
if (lastFirst) {
|
|
this.faintQueue.unshift(this.faintQueue[this.faintQueue.length - 1]);
|
|
this.faintQueue.pop();
|
|
}
|
|
let faintData;
|
|
while (this.faintQueue.length) {
|
|
faintData = this.faintQueue.shift()!;
|
|
const pokemon: Pokemon = faintData.target;
|
|
if (!pokemon.fainted &&
|
|
this.runEvent('BeforeFaint', pokemon, faintData.source, faintData.effect)) {
|
|
this.add('faint', pokemon);
|
|
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.isActive = false;
|
|
pokemon.isStarted = false;
|
|
pokemon.side.faintedThisTurn = pokemon;
|
|
}
|
|
}
|
|
|
|
if (this.gen <= 1) {
|
|
// in gen 1, fainting skips the rest of the turn
|
|
// residuals don't exist in gen 1
|
|
this.queue.clear();
|
|
// Fainting clears accumulated Bide damage
|
|
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') {
|
|
// in gen 3 or earlier, fainting in singles skips to residuals
|
|
for (const pokemon of this.getAllActive()) {
|
|
if (this.gen <= 2) {
|
|
// in gen 2, fainting skips moves only
|
|
this.queue.cancelMove(pokemon);
|
|
} else {
|
|
// in gen 3, fainting skips all moves and switches
|
|
this.queue.cancelAction(pokemon);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!this.p1.pokemonLeft && !this.p2.pokemonLeft) {
|
|
if (this.p1.lastMove !== null && this.p2.lastMove === null) {
|
|
this.win(this.p2);
|
|
return true;
|
|
} else if (this.p2.lastMove !== null && this.p1.lastMove === null) {
|
|
this.win(this.p1);
|
|
return true;
|
|
}
|
|
this.win(faintData ? faintData.target.side.foe : null);
|
|
return true;
|
|
}
|
|
if (!this.p1.pokemonLeft) {
|
|
this.win(this.p2);
|
|
return true;
|
|
}
|
|
if (!this.p2.pokemonLeft) {
|
|
this.win(this.p1);
|
|
return true;
|
|
}
|
|
if (faintData) {
|
|
this.runEvent('AfterFaint', faintData.target, faintData.source, faintData.effect, length);
|
|
}
|
|
return false;
|
|
},
|
|
};
|