mirror of
https://github.com/smogon/pokemon-showdown.git
synced 2026-05-09 12:36:41 -05:00
d8b7aa74f1
In the event that the user and target get KOed in the same turn (Life Orb recoil, Iron Barbs, etc.), make sure the user isn't forced to switch to another Pokemon before the opponent chooses a replacement.
1099 lines
34 KiB
JavaScript
1099 lines
34 KiB
JavaScript
exports.BattleScripts = {
|
|
runMove: function(move, pokemon, target) {
|
|
move = this.getMove(move);
|
|
if (!target) target = this.resolveTarget(pokemon, move);
|
|
|
|
this.setActiveMove(move, pokemon, target);
|
|
|
|
if (pokemon.movedThisTurn || !this.runEvent('BeforeMove', pokemon, target, move)) {
|
|
this.debug(''+pokemon.id+' move interrupted; movedThisTurn: '+pokemon.movedThisTurn);
|
|
this.clearActiveMove(true);
|
|
return;
|
|
}
|
|
if (move.beforeMoveCallback) {
|
|
if (move.beforeMoveCallback.call(this, pokemon, target, move)) {
|
|
this.clearActiveMove(true);
|
|
return;
|
|
}
|
|
}
|
|
pokemon.lastDamage = 0;
|
|
pokemon.deductPP(move, 1, target);
|
|
this.useMove(move, pokemon, target);
|
|
this.runEvent('AfterMove', target, pokemon, move);
|
|
this.runEvent('AfterMoveSelf', pokemon, target, move);
|
|
},
|
|
useMove: function(move, pokemon, target, sourceEffect) {
|
|
move = this.getMove(move);
|
|
baseMove = move;
|
|
move = this.getMoveCopy(move);
|
|
if (!target) target = this.resolveTarget(pokemon, move);
|
|
if (move.target === 'self' || move.target === 'allies') {
|
|
target = pokemon;
|
|
}
|
|
|
|
this.setActiveMove(move, pokemon, target);
|
|
|
|
var canTargetFainted = {
|
|
all: 1, foeSide: 1
|
|
};
|
|
this.singleEvent('ModifyMove', move, null, pokemon, target, move, move);
|
|
if (baseMove.target !== move.target) {
|
|
//Target changed in ModifyMove, so we must adjust it here
|
|
target = this.resolveTarget(pokemon, move);
|
|
}
|
|
move = this.runEvent('ModifyMove',pokemon,target,move,move);
|
|
if (baseMove.target !== move.target) {
|
|
//check again
|
|
target = this.resolveTarget(pokemon, move);
|
|
}
|
|
if (!move) return false;
|
|
|
|
var attrs = '';
|
|
var missed = false;
|
|
if (pokemon.fainted) {
|
|
return false;
|
|
}
|
|
|
|
if (move.isTwoTurnMove && !pokemon.volatiles[move.id]) {
|
|
attrs = '|[still]'; // suppress the default move animation
|
|
}
|
|
|
|
var boostTable = [1, 4/3, 5/3, 2, 7/3, 8/3, 3];
|
|
var accuracy = move.accuracy;
|
|
if (accuracy !== true) {
|
|
if (!move.ignoreAccuracy) {
|
|
if (pokemon.boosts.accuracy > 0) {
|
|
accuracy *= boostTable[pokemon.boosts.accuracy];
|
|
} else {
|
|
accuracy /= boostTable[-pokemon.boosts.accuracy];
|
|
}
|
|
}
|
|
if (!move.ignoreEvasion) {
|
|
if (target.boosts.evasion > 0 && !move.ignorePositiveEvasion) {
|
|
accuracy /= boostTable[target.boosts.evasion];
|
|
} else if (target.boosts.evasion < 0) {
|
|
accuracy *= boostTable[-target.boosts.evasion];
|
|
}
|
|
}
|
|
}
|
|
if (move.ohko) { // bypasses accuracy modifiers
|
|
accuracy = 30;
|
|
if (pokemon.level > target.level) accuracy += (pokemon.level - target.level);
|
|
}
|
|
if (move.alwaysHit) accuracy = true; // bypasses ohko accuracy modifiers
|
|
if (target.fainted && !canTargetFainted[move.target]) {
|
|
attrs += '|[notarget]';
|
|
} else if (accuracy !== true && this.random(100) >= accuracy) {
|
|
missed = true;
|
|
attrs += '|[miss]';
|
|
}
|
|
var movename = move.name;
|
|
if (move.id === 'hiddenpower') movename = 'Hidden Power';
|
|
if (sourceEffect) attrs += '[from]'+this.getEffect(sourceEffect);
|
|
this.add('move', pokemon, movename, target+attrs);
|
|
|
|
if (!this.singleEvent('Try', move, null, pokemon, target, move)) {
|
|
this.singleEvent('MoveFail', move, null, target, pokemon, move);
|
|
return true;
|
|
}
|
|
|
|
if (target.fainted && !canTargetFainted[move.target]) {
|
|
this.add('-notarget');
|
|
this.singleEvent('MoveFail', move, null, target, pokemon, move);
|
|
if (move.selfdestruct && move.target === 'adjacent') {
|
|
this.faint(pokemon, pokemon, move);
|
|
}
|
|
return true;
|
|
}
|
|
if (typeof move.affectedByImmunities === 'undefined') {
|
|
move.affectedByImmunities = (move.category !== 'Status');
|
|
}
|
|
if ((move.affectedByImmunities && !target.runImmunity(move.type, true)) || (move.isSoundBased && !target.runImmunity('sound', true))) {
|
|
this.singleEvent('MoveFail', move, null, target, pokemon, move);
|
|
if (move.selfdestruct && move.target === 'adjacent') {
|
|
this.faint(pokemon, pokemon, move);
|
|
}
|
|
return true;
|
|
}
|
|
if (missed) {
|
|
this.add('-miss', pokemon);
|
|
this.singleEvent('MoveFail', move, null, target, pokemon, move);
|
|
if (move.selfdestruct && move.target === 'adjacent') {
|
|
this.faint(pokemon, pokemon, move);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
var damage = 0;
|
|
pokemon.lastDamage = 0;
|
|
if (!move.multihit) {
|
|
damage = this.moveHit(target, pokemon, move);
|
|
} else {
|
|
var hits = move.multihit;
|
|
if (hits.length) {
|
|
// yes, it's hardcoded... meh
|
|
if (hits[0] === 2 && hits[1] === 5) {
|
|
var roll = this.random(20);
|
|
if (roll < 7) hits = 2;
|
|
else if (roll < 14) hits = 3;
|
|
else if (roll < 17) hits = 4;
|
|
else hits = 5;
|
|
} else {
|
|
hits = this.random(hits[0],hits[1]+1);
|
|
}
|
|
}
|
|
hits = Math.floor(hits);
|
|
for (var i=0; i<hits && target.hp && pokemon.hp; i++) {
|
|
var moveDamage = this.moveHit(target, pokemon, move);
|
|
if (moveDamage === false) return true;
|
|
damage += (moveDamage || 0);
|
|
}
|
|
this.add('-hitcount', target, i);
|
|
}
|
|
|
|
target.gotAttacked(move, damage, pokemon);
|
|
|
|
if (move.recoil && pokemon.lastDamage) {
|
|
this.damage(pokemon.lastDamage * move.recoil[0] / move.recoil[1], pokemon, target, 'recoil');
|
|
}
|
|
if (move.drain && pokemon.lastDamage) {
|
|
this.heal(Math.ceil(pokemon.lastDamage * move.drain[0] / move.drain[1]), pokemon, target, 'drain');
|
|
}
|
|
if (move.selfdestruct) {
|
|
this.faint(pokemon, pokemon, move);
|
|
}
|
|
if (move.afterMoveCallback) {
|
|
move.afterMoveCallback.call(this, pokemon, target);
|
|
}
|
|
if (!move.negateSecondary && damage !== false) {
|
|
this.singleEvent('AfterMoveSecondary', move, null, target, pokemon, move);
|
|
this.singleEvent('AfterMoveSecondarySelf', move, null, pokemon, target, move);
|
|
this.runEvent('AfterMoveSecondary', target, pokemon, move);
|
|
this.runEvent('AfterMoveSecondarySelf', pokemon, target, move);
|
|
}
|
|
return true;
|
|
},
|
|
moveHit: function(target, pokemon, move, moveData, isSecondary, isSelf) {
|
|
move = this.getMoveCopy(move);
|
|
|
|
if (!isSecondary && !isSelf) this.setActiveMove(move, pokemon, target);
|
|
var hitResult = true;
|
|
if (!moveData) moveData = move;
|
|
|
|
if (typeof move.affectedByImmunities === 'undefined') {
|
|
move.affectedByImmunities = (move.category !== 'Status');
|
|
}
|
|
|
|
// TryHit events:
|
|
// STEP 1: we see if the move will succeed at all:
|
|
// - TryHit, TryHitSide, or TryHitField are run on the move,
|
|
// depending on move target
|
|
// == primary hit line ==
|
|
// Everything after this only happens on the primary hit (not on
|
|
// secondary or self-hits)
|
|
// STEP 2: we see if anything blocks the move from hitting:
|
|
// - TryFieldHit is run on the target
|
|
// STEP 3: we see if anything blocks the move from hitting the target:
|
|
// - If the move's target is a pokemon, TryHit is run on that pokemon
|
|
|
|
// Note:
|
|
// If the move target is `foeSide`:
|
|
// event target = pokemon 0 on the target side
|
|
// If the move target is `allySide` or `all`:
|
|
// event target = the move user
|
|
//
|
|
// This is because events can't accept actual sides or fields as
|
|
// targets. Choosing these event targets ensures that the correct
|
|
// side or field is hit.
|
|
//
|
|
// It is the `TryHitField` event handler's responsibility to never
|
|
// use `target`.
|
|
// It is the `TryFieldHit` event handler's responsibility to read
|
|
// move.target and react accordingly.
|
|
// An exception is `TryHitSide`, which is passed the target side.
|
|
|
|
// Note 2:
|
|
// In case you didn't notice, FieldHit and HitField mean different things.
|
|
// TryFieldHit - something in the field was hit
|
|
// TryHitField - our move has a target of 'all' i.e. the field, and hit
|
|
// This is a VERY important distinction: Every move triggers
|
|
// TryFieldHit, but only moves with a target of "all" (e.g.
|
|
// Haze) trigger TryHitField.
|
|
|
|
if (target) {
|
|
if (move.target === 'all' && !isSelf) {
|
|
hitResult = this.singleEvent('TryHitField', moveData, {}, target, pokemon, move);
|
|
} else if ((move.target === 'foeSide' || move.target === 'allySide') && !isSelf) {
|
|
hitResult = this.singleEvent('TryHitSide', moveData, {}, target.side, pokemon, move);
|
|
} else {
|
|
hitResult = this.singleEvent('TryHit', moveData, {}, target, pokemon, move);
|
|
}
|
|
if (!hitResult) {
|
|
if (hitResult === false) this.add('-fail', target);
|
|
return false;
|
|
}
|
|
// only run the hit events for the hit itself, not the secondary or self hits
|
|
if (!isSelf && !isSecondary) {
|
|
if (move.target !== 'all' && move.target !== 'foeSide' && move.target !== 'allySide') {
|
|
hitResult = this.runEvent('TryHit', target, pokemon, move);
|
|
if (!hitResult) {
|
|
if (hitResult === false) this.add('-fail', target);
|
|
if (hitResult !== 0) { // special Substitute hit flag
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (!this.runEvent('TryFieldHit', target, pokemon, move)) {
|
|
return false;
|
|
}
|
|
} else if (isSecondary && !moveData.self) {
|
|
hitResult = this.runEvent('TrySecondaryHit', target, pokemon, moveData);
|
|
}
|
|
|
|
if (hitResult === 0) {
|
|
target = null;
|
|
} else if (!hitResult) {
|
|
if (hitResult === false) this.add('-fail', target);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (target) {
|
|
var didSomething = false;
|
|
var damage = this.getDamage(pokemon, target, moveData);
|
|
if (damage === false || damage === null) {
|
|
this.singleEvent('MoveFail', move, null, target, pokemon, move);
|
|
return false;
|
|
}
|
|
if (move.noFaint && damage >= target.hp) {
|
|
damage = target.hp - 1;
|
|
}
|
|
if (damage && !target.fainted) {
|
|
damage = this.damage(damage, target, pokemon, move);
|
|
if (!damage) return false;
|
|
didSomething = true;
|
|
} else if (damage === false && typeof hitResult === 'undefined') {
|
|
this.add('-fail', target);
|
|
}
|
|
if (moveData.boosts && !target.fainted) {
|
|
this.boost(moveData.boosts, target, pokemon, move);
|
|
}
|
|
if (moveData.heal && !target.fainted) {
|
|
var d = target.heal(Math.round(target.maxhp * moveData.heal[0] / moveData.heal[1]));
|
|
if (!d) {
|
|
this.add('-fail', target);
|
|
return false;
|
|
}
|
|
this.add('-heal', target, target.hpChange(d));
|
|
didSomething = true;
|
|
}
|
|
if (moveData.status) {
|
|
if (!target.status) {
|
|
target.setStatus(moveData.status, pokemon, move);
|
|
} else if (!isSecondary) {
|
|
if (target.status === moveData.status) {
|
|
this.add('-fail', target, target.status);
|
|
} else {
|
|
this.add('-fail', target);
|
|
}
|
|
}
|
|
didSomething = true;
|
|
}
|
|
if (moveData.forceStatus) {
|
|
if (target.setStatus(moveData.forceStatus, pokemon, move)) {
|
|
didSomething = true;
|
|
}
|
|
}
|
|
if (moveData.volatileStatus) {
|
|
if (target.addVolatile(moveData.volatileStatus, pokemon, move)) {
|
|
didSomething = true;
|
|
}
|
|
}
|
|
if (moveData.sideCondition) {
|
|
if (target.side.addSideCondition(moveData.sideCondition, pokemon, move)) {
|
|
didSomething = true;
|
|
}
|
|
}
|
|
if (moveData.weather) {
|
|
if (this.setWeather(moveData.weather, pokemon, move)) {
|
|
didSomething = true;
|
|
}
|
|
}
|
|
if (moveData.pseudoWeather) {
|
|
if (this.addPseudoWeather(moveData.pseudoWeather, pokemon, move)) {
|
|
didSomething = true;
|
|
}
|
|
}
|
|
// Hit events
|
|
// These are like the TryHit events, except we don't need a FieldHit event.
|
|
// Scroll up for the TryHit event documentation, and just ignore the "Try" part. ;)
|
|
if (move.target === 'all' && !isSelf) {
|
|
hitResult = this.singleEvent('HitField', moveData, {}, target, pokemon, move);
|
|
} else if ((move.target === 'foeSide' || move.target === 'allySide') && !isSelf) {
|
|
hitResult = this.singleEvent('HitSide', moveData, {}, target.side, pokemon, move);
|
|
} else {
|
|
hitResult = this.singleEvent('Hit', moveData, {}, target, pokemon, move);
|
|
if (!isSelf && !isSecondary) {
|
|
this.runEvent('Hit', target, pokemon, move);
|
|
}
|
|
}
|
|
if (!hitResult && !didSomething) {
|
|
if (hitResult === false) this.add('-fail', target);
|
|
return false;
|
|
}
|
|
}
|
|
if (moveData.self) {
|
|
this.moveHit(pokemon, pokemon, move, moveData.self, isSecondary, true);
|
|
}
|
|
if (moveData.secondaries) {
|
|
var secondaryRoll;
|
|
for (var i = 0; i < moveData.secondaries.length; i++) {
|
|
secondaryRoll = this.random(100);
|
|
if (typeof moveData.secondaries[i].chance === 'undefined' || secondaryRoll < moveData.secondaries[i].chance) {
|
|
this.moveHit(target, pokemon, move, moveData.secondaries[i], true, isSelf);
|
|
}
|
|
}
|
|
}
|
|
if (target && target.hp > 0 && pokemon.hp > 0) {
|
|
if (moveData.forceSwitch && this.runEvent('DragOut', target, pokemon, move)) {
|
|
this.dragIn(target.side);
|
|
}
|
|
}
|
|
if (move.selfSwitch && pokemon.hp) {
|
|
pokemon.switchFlag = move.selfSwitch;
|
|
}
|
|
return damage;
|
|
},
|
|
getTeam: function(side, team) {
|
|
if (side.battle.getFormat().team === 'cc') {
|
|
return this.ChallengeCup(side);
|
|
} else if (side.battle.getFormat().team === 'random') {
|
|
return this.randomTeam(side);
|
|
} else if (team) {
|
|
return team;
|
|
} else {
|
|
return this.randomTeam(side);
|
|
}
|
|
},
|
|
ChallengeCup: function(side) {
|
|
var teamdexno = [];
|
|
var team = [];
|
|
|
|
//pick six random pokmeon--no repeats, even among formes
|
|
//also need to either normalize for formes or select formes at random
|
|
//unreleased are okay. No CAP for now, but maybe at some later date
|
|
for (var i=0; i<6; i++)
|
|
{
|
|
while (true) {
|
|
var x=Math.floor(Math.random()*649)+1;
|
|
if (teamdexno.indexOf(x) === -1) {
|
|
teamdexno.push(x)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (var i=0; i<6; i++) {
|
|
//choose forme
|
|
var formes = [];
|
|
for (var j in this.data.Pokedex) {
|
|
if (this.data.Pokedex[j].num === teamdexno[i]) {
|
|
formes.push(this.data.Pokedex[j].species);
|
|
}
|
|
}
|
|
var poke = formes.sample();
|
|
var template = this.getTemplate(poke);
|
|
|
|
//level balance--calculate directly from stats rather than using some silly lookup table
|
|
var mbstmin = 1307; //sunkern has the lowest modified base stat total, and that total is 807
|
|
|
|
var stats = template.baseStats;
|
|
|
|
//modified base stat total assumes 31 IVs, 85 EVs in every stat
|
|
var mbst = (stats["hp"]*2+31+21+100)+10;
|
|
mbst += (stats["atk"]*2+31+21+100)+5;
|
|
mbst += (stats["def"]*2+31+21+100)+5;
|
|
mbst += (stats["spa"]*2+31+21+100)+5;
|
|
mbst += (stats["spd"]*2+31+21+100)+5;
|
|
mbst += (stats["spe"]*2+31+21+100)+5;
|
|
|
|
var level = Math.floor(100*mbstmin/mbst); //initial level guess will underestimate
|
|
|
|
while (level < 100) {
|
|
mbst = Math.floor((stats["hp"]*2+31+21+100)*level/100+10);
|
|
mbst += Math.floor(((stats["atk"]*2+31+21+100)*level/100+5)*level/100); //since damage is roughly proportional to lvl
|
|
mbst += Math.floor((stats["def"]*2+31+21+100)*level/100+5);
|
|
mbst += Math.floor(((stats["spa"]*2+31+21+100)*level/100+5)*level/100);
|
|
mbst += Math.floor((stats["spd"]*2+31+21+100)*level/100+5);
|
|
mbst += Math.floor((stats["spe"]*2+31+21+100)*level/100+5);
|
|
|
|
if (mbst >= mbstmin)
|
|
break;
|
|
level++;
|
|
}
|
|
|
|
|
|
//random gender--already handled by PS?
|
|
|
|
//random ability (unreleased DW are par for the course)
|
|
var abilities = [template.abilities['0']];
|
|
if (template.abilities['1']) {
|
|
abilities.push(template.abilities['1']);
|
|
}
|
|
if (template.abilities['DW']) {
|
|
abilities.push(template.abilities['DW']);
|
|
}
|
|
var ability = abilities.sample();
|
|
|
|
//random nature
|
|
var nature = ["Adamant", "Bashful", "Bold", "Brave", "Calm", "Careful", "Docile", "Gentle", "Hardy", "Hasty", "Impish", "Jolly", "Lax", "Lonely", "Mild", "Modest", "Naive", "Naughty", "Quiet", "Quirky", "Rash", "Relaxed", "Sassy", "Serious", "Timid"].sample();
|
|
|
|
//random item--I guess if it's in items.js, it's okay
|
|
var item = Object.keys(this.data.Items).sample();
|
|
|
|
//since we're selecting forme at random, we gotta make sure forme/item combo is correct
|
|
if (template.requiredItem) {
|
|
item = template.requiredItem;
|
|
}
|
|
while ((poke === 'Arceus' && item.indexOf("plate") > -1) || (poke === 'Giratina' && item === 'griseousorb')) {
|
|
item = Object.keys(this.data.Items).sample();
|
|
}
|
|
|
|
|
|
|
|
//random IVs
|
|
var ivs = {
|
|
hp: Math.floor(Math.random()*32),
|
|
atk: Math.floor(Math.random()*32),
|
|
def: Math.floor(Math.random()*32),
|
|
spa: Math.floor(Math.random()*32),
|
|
spd: Math.floor(Math.random()*32),
|
|
spe: Math.floor(Math.random()*32)
|
|
};
|
|
|
|
//random EVs
|
|
var evs = {
|
|
hp: 0,
|
|
atk: 0,
|
|
def: 0,
|
|
spa: 0,
|
|
spd: 0,
|
|
spe: 0
|
|
};
|
|
var s = ["hp","atk","def","spa","spd","spe"];
|
|
var evpool = 510;
|
|
do
|
|
{
|
|
var x = s.sample();
|
|
var y = Math.floor(Math.random()*Math.min(256-evs[x],evpool+1));
|
|
evs[x]+=y;
|
|
evpool-=y;
|
|
} while (evpool > 0);
|
|
|
|
//random happiness--useless, since return/frustration is currently a "cheat"
|
|
var happiness = Math.floor(Math.random()*256);
|
|
|
|
//random shininess?
|
|
var shiny = (Math.random()*1024<=1);
|
|
|
|
//four random unique moves from movepool. don't worry about "attacking" or "viable"
|
|
var moves;
|
|
var pool = ['struggle'];
|
|
if (template.learnset) pool = Object.keys(template.learnset);
|
|
if (pool.length < 5) {
|
|
moves = pool;
|
|
} else {
|
|
moves=pool.sample(4);
|
|
}
|
|
|
|
team.push({
|
|
name: poke,
|
|
moves: moves,
|
|
ability: ability,
|
|
evs: evs,
|
|
ivs: ivs,
|
|
item: item,
|
|
level: level,
|
|
happiness: happiness,
|
|
shiny: shiny
|
|
});
|
|
}
|
|
|
|
//console.log(team);
|
|
return team;
|
|
},
|
|
randomTeam: function(side) {
|
|
var keys = [];
|
|
var pokemonLeft = 0;
|
|
var pokemon = [];
|
|
for (var i in this.data.FormatsData) {
|
|
if (this.data.FormatsData[i].viableMoves) {
|
|
keys.push(i);
|
|
}
|
|
}
|
|
keys = keys.randomize();
|
|
|
|
var ruleset = this.getFormat().ruleset;
|
|
|
|
for (var i=0; i<keys.length && pokemonLeft < 6; i++) {
|
|
var template = this.getTemplate(keys[i]);
|
|
|
|
if (!template || !template.name || !template.types) continue;
|
|
if ((template.tier === 'G4CAP' || template.tier === 'G5CAP') && Math.random()*5>1) continue;
|
|
if (keys[i].substr(0,6) === 'arceus' && Math.random()*17>1) continue;
|
|
|
|
if (ruleset && ruleset[0]==='PotD') {
|
|
var potd = this.getTemplate(config.potd);
|
|
if (i===1) {
|
|
template = potd;
|
|
if (!template || !template.name || !template.types) {
|
|
continue;
|
|
} else if (template.species === 'Magikarp') {
|
|
template.viableMoves = {magikarpsrevenge:1, splash:1, bounce:1};
|
|
} else if (template.species === 'Delibird') {
|
|
template.viableMoves = {present:1, bestow:1};
|
|
}
|
|
} else if (template.species === potd.species) {
|
|
continue; // No thanks, I've already got one
|
|
}
|
|
}
|
|
|
|
var moveKeys = Object.keys(template.viableMoves).randomize();
|
|
var moves = [];
|
|
var ability = '';
|
|
var item = '';
|
|
var evs = {
|
|
hp: 85,
|
|
atk: 85,
|
|
def: 85,
|
|
spa: 85,
|
|
spd: 85,
|
|
spe: 85
|
|
};
|
|
var ivs = {
|
|
hp: 31,
|
|
atk: 31,
|
|
def: 31,
|
|
spa: 31,
|
|
spd: 31,
|
|
spe: 31
|
|
};
|
|
|
|
var hasType = {};
|
|
hasType[template.types[0]] = true;
|
|
if (template.types[1]) hasType[template.types[1]] = true;
|
|
|
|
var hasMove = {};
|
|
var counter = {};
|
|
var setupType = '';
|
|
|
|
var j=0;
|
|
do {
|
|
while (moves.length<4 && j<moveKeys.length) {
|
|
var moveid = toId(moveKeys[j]);
|
|
j++;
|
|
if (moveid.substr(0,11) === 'hiddenpower') {
|
|
if (!hasMove['hiddenpower']) {
|
|
hasMove['hiddenpower'] = true;
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
moves.push(moveid);
|
|
}
|
|
|
|
hasMove = {};
|
|
counter = {
|
|
Physical: 0, Special: 0, Status: 0, damage: 0,
|
|
technician: 0, skilllink: 0, contrary: 0,
|
|
recoil: 0, inaccurate: 0,
|
|
physicalsetup: 0, specialsetup: 0, mixedsetup: 0
|
|
};
|
|
for (var k=0; k<moves.length; k++) {
|
|
var move = this.getMove(moves[k]);
|
|
var moveid = move.id;
|
|
hasMove[moveid] = true;
|
|
if (move.damage || move.damageCallback) {
|
|
counter['damage']++;
|
|
} else {
|
|
counter[move.category]++;
|
|
}
|
|
if (move.basePower && move.basePower <= 60) {
|
|
counter['technician']++;
|
|
}
|
|
if (move.multihit && move.multihit[1] === 5) {
|
|
counter['skilllink']++;
|
|
}
|
|
if (move.recoil) {
|
|
counter['recoil']++;
|
|
}
|
|
if (move.accuracy && move.accuracy !== true && move.accuracy < 90) {
|
|
counter['inaccurate']++;
|
|
}
|
|
var ContraryMove = {
|
|
leafstorm: 1, overheat: 1, closecombat: 1, superpower: 1, vcreate: 1
|
|
};
|
|
if (ContraryMove[moveid]) {
|
|
counter['contrary']++;
|
|
}
|
|
var PhysicalSetup = {
|
|
swordsdance:1, dragondance:1, coil:1, bulkup:1, curse:1, bellydrum:1
|
|
};
|
|
var SpecialSetup = {
|
|
nastyplot:1, tailglow:1, quiverdance:1, calmmind:1
|
|
};
|
|
var MixedSetup = {
|
|
growth:1, workup:1, shellsmash:1
|
|
};
|
|
if (PhysicalSetup[moveid]) {
|
|
counter['physicalsetup']++;
|
|
}
|
|
if (SpecialSetup[moveid]) {
|
|
counter['specialsetup']++;
|
|
}
|
|
if (MixedSetup[moveid]) {
|
|
counter['mixedsetup']++;
|
|
}
|
|
}
|
|
|
|
if (counter['mixedsetup']) {
|
|
setupType = 'Mixed';
|
|
} else if (counter['specialsetup']) {
|
|
setupType = 'Special';
|
|
} else if (counter['physicalsetup']) {
|
|
setupType = 'Physical';
|
|
}
|
|
|
|
for (var k=0; k<moves.length; k++) {
|
|
var moveid = moves[k];
|
|
var move = this.getMove(moveid);
|
|
var rejected = false;
|
|
var isSetup = false;
|
|
|
|
switch (moveid) {
|
|
// not very useful without their supporting moves
|
|
|
|
case 'sleeptalk':
|
|
if (!hasMove['rest']) rejected = true;
|
|
if (hasMove['trick'] || hasMove['protect'] || hasMove['substitute'] || hasMove['bellydrum']) rejected = true;
|
|
break;
|
|
case 'endure':
|
|
if (!hasMove['flail'] && !hasMove['endeavor'] && !hasMove['reversal']) rejected = true;
|
|
break;
|
|
|
|
// we only need to set up once
|
|
|
|
case 'swordsdance': case 'dragondance': case 'coil': case 'curse': case 'bulkup': case 'bellydrum':
|
|
if (!counter['Physical'] && !hasMove['batonpass']) rejected = true;
|
|
if (setupType !== 'Physical' || counter['physicalsetup'] > 1) rejected = true;
|
|
isSetup = true;
|
|
break;
|
|
case 'nastyplot': case 'tailglow': case 'quiverdance': case 'calmmind':
|
|
if (!counter['Special'] && !hasMove['batonpass']) rejected = true;
|
|
if (setupType !== 'Special' || counter['specialsetup'] > 1) rejected = true;
|
|
isSetup = true;
|
|
break;
|
|
case 'shellsmash': case 'growth': case 'workup':
|
|
if (!counter['Special'] && !counter['Physical'] && !hasMove['batonpass']) rejected = true;
|
|
if (setupType !== 'Mixed' || counter['mixedsetup'] > 1) rejected = true;
|
|
isSetup = true;
|
|
break;
|
|
|
|
// bad after setup
|
|
case 'seismictoss': case 'nightshade': case 'superfang':
|
|
if (setupType) rejected = true;
|
|
break;
|
|
case 'knockoff': case 'protect': case 'perishsong': case 'magiccoat':
|
|
if (setupType) rejected = true;
|
|
break;
|
|
|
|
// bit redundant to have both
|
|
|
|
case 'fireblast':
|
|
if (hasMove['eruption'] || hasMove['overheat'] || hasMove['flamethrower']) rejected = true;
|
|
break;
|
|
case 'flamethrower':
|
|
if (hasMove['lavaplume'] || hasMove['fireblast'] || hasMove['overheat']) rejected = true;
|
|
break;
|
|
case 'icebeam':
|
|
if (hasMove['blizzard']) rejected = true;
|
|
break;
|
|
case 'surf':
|
|
if (hasMove['scald'] || hasMove['hydropump']) rejected = true;
|
|
break;
|
|
case 'energyball':
|
|
case 'grassknot':
|
|
case 'petaldance':
|
|
if (hasMove['gigadrain']) rejected = true;
|
|
break;
|
|
case 'seedbomb':
|
|
if (hasMove['needlearm']) rejected = true;
|
|
break;
|
|
case 'flareblitz':
|
|
if (hasMove['firepunch']) rejected = true;
|
|
break;
|
|
case 'thunderbolt':
|
|
if (hasMove['discharge'] || hasMove['voltswitch'] || hasMove['thunder']) rejected = true;
|
|
break;
|
|
case 'discharge':
|
|
if (hasMove['voltswitch'] || hasMove['thunder']) rejected = true;
|
|
break;
|
|
case 'rockslide':
|
|
if (hasMove['stoneedge']) rejected = true;
|
|
break;
|
|
case 'dragonclaw':
|
|
if (hasMove['outrage'] || hasMove['dragontail']) rejected = true;
|
|
break;
|
|
case 'ancientpower':
|
|
if (hasMove['paleowave']) rejected = true;
|
|
break;
|
|
case 'dragonpulse':
|
|
if (hasMove['dracometeor']) rejected = true;
|
|
break;
|
|
case 'return':
|
|
if (hasMove['bodyslam']) rejected = true;
|
|
if (hasMove['flail']) rejected = true;
|
|
if (hasMove['facade']) rejected = true;
|
|
break;
|
|
case 'flail':
|
|
if (hasMove['facade']) rejected = true;
|
|
break;
|
|
case 'poisonjab':
|
|
if (hasMove['gunkshot']) rejected = true;
|
|
break;
|
|
case 'psychic':
|
|
if (hasMove['psyshock']) rejected = true;
|
|
break;
|
|
|
|
case 'yawn':
|
|
if (hasMove['grasswhistle']) rejected = true;
|
|
break;
|
|
case 'rest':
|
|
if (hasMove['morningsun']) rejected = true;
|
|
break;
|
|
case 'softboiled':
|
|
if (hasMove['wish']) rejected = true;
|
|
break;
|
|
case 'perishsong':
|
|
if (hasMove['roar'] || hasMove['whirlwind'] || hasMove['haze']) rejected = true;
|
|
break;
|
|
case 'roar':
|
|
// Whirlwind outclasses Roar because Soundproof
|
|
if (hasMove['whirlwind'] || hasMove['haze']) rejected = true;
|
|
break;
|
|
case 'roost':
|
|
if (hasMove['recover']) rejected = true;
|
|
break;
|
|
}
|
|
// handle HP IVs
|
|
if (move.id === 'hiddenpower') {
|
|
var HPivs = this.getType(move.name.substr(13)).HPivs;
|
|
for (var iv in HPivs) {
|
|
ivs[iv] = HPivs[iv];
|
|
}
|
|
}
|
|
if (k===3) {
|
|
if (counter['Status']>=4) {
|
|
// taunt bait, not okay
|
|
rejected = true;
|
|
}
|
|
}
|
|
var SetupException = {
|
|
overheat:1, dracometeor:1, leafstorm:1,
|
|
voltswitch:1, uturn:1,
|
|
suckerpunch:1, extremespeed:1
|
|
};
|
|
if (move.category === 'Special' && setupType === 'Physical' && !SetupException[move.id]) {
|
|
rejected = true;
|
|
}
|
|
if (move.category === 'Physical' && setupType === 'Special' && !SetupException[move.id]) {
|
|
rejected = true;
|
|
}
|
|
if (setupType === 'Physical' && move.category !== 'Physical' && counter['Physical'] < 2) {
|
|
rejected = true;
|
|
}
|
|
if (setupType === 'Special' && move.category !== 'Special' && counter['Special'] < 2) {
|
|
rejected = true;
|
|
}
|
|
|
|
if (rejected && j<moveKeys.length) {
|
|
moves.splice(k,1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
} while (moves.length<4 && j<moveKeys.length);
|
|
|
|
// any moveset modification goes here
|
|
//moves[0] = 'Safeguard';
|
|
{
|
|
var abilities = [template.abilities['0']];
|
|
if (template.abilities['1']) {
|
|
abilities.push(template.abilities['1']);
|
|
}
|
|
if (template.abilities['DW']) {
|
|
abilities.push(template.abilities['DW']);
|
|
}
|
|
abilities.sort(function(a,b){
|
|
return this.getAbility(b).rating - this.getAbility(a).rating;
|
|
}.bind(this));
|
|
var ability0 = this.getAbility(abilities[0]);
|
|
var ability1 = this.getAbility(abilities[1]);
|
|
var ability = ability0.name;
|
|
if (abilities[1]) {
|
|
|
|
if (ability0.rating <= ability1.rating) {
|
|
if (Math.random()*2<1) {
|
|
ability = ability1.name;
|
|
}
|
|
} else if (ability0.rating - 0.6 <= ability1.rating) {
|
|
if (Math.random()*3<1) {
|
|
ability = ability1.name;
|
|
}
|
|
}
|
|
|
|
var rejectAbility = false;
|
|
if (ability === 'Contrary' && !counter['contrary']) {
|
|
rejectAbility = true;
|
|
}
|
|
if (ability === 'Technician' && !counter['technician']) {
|
|
rejectAbility = true;
|
|
}
|
|
if (ability === 'Skill Link' && !counter['skilllink']) {
|
|
rejectAbility = true;
|
|
}
|
|
if ((ability === 'Rock Head' || ability === 'Reckless') && !counter['recoil']) {
|
|
rejectAbility = true;
|
|
}
|
|
if ((ability === 'No Guard' || ability === 'Compoundeyes') && !counter['inaccurate']) {
|
|
rejectAbility = true;
|
|
}
|
|
if (ability === 'Moody') {
|
|
rejectAbility = true;
|
|
}
|
|
|
|
if (rejectAbility) {
|
|
if (ability === ability1.name) { // or not
|
|
ability = ability0.name;
|
|
} else if (ability1.rating > 0) { // only switch if the alternative doesn't suck
|
|
ability = ability1.name;
|
|
}
|
|
}
|
|
if ((abilities[0] === 'Guts' || abilities[1] === 'Guts' || abilities[2] === 'Guts') && ability !== 'Quick Feet' && hasMove['facade']) {
|
|
ability = 'Guts';
|
|
}
|
|
}
|
|
|
|
if (hasMove['gyroball']) {
|
|
ivs.spe = 0;
|
|
//evs.atk += evs.spe;
|
|
evs.spe = 0;
|
|
} else if (hasMove['trickroom']) {
|
|
ivs.spe = 0;
|
|
//evs.hp += evs.spe;
|
|
evs.spe = 0;
|
|
}
|
|
|
|
item = 'Focus Sash';
|
|
if (template.requiredItem) {
|
|
item = template.requiredItem;
|
|
} else if (template.species === 'Rotom-Fan') {
|
|
// this is just to amuse myself
|
|
item = 'Air Balloon';
|
|
} else if (template.species === 'Delibird') {
|
|
// to go along with the Christmas Delibird set
|
|
item = 'Leftovers';
|
|
} else if (ability === 'Imposter') {
|
|
item = 'Choice Scarf';
|
|
} else if (hasMove["magikarpsrevenge"]) {
|
|
item = 'Choice Band';
|
|
} else if (ability === 'Wonder Guard') {
|
|
item = 'Focus Sash';
|
|
} else if (template.species === 'Unown') {
|
|
item = 'Choice Specs';
|
|
} else if (hasMove['trick'] && hasMove['gyroball'] && (ability === 'Levitate' || hasType['Flying'])) {
|
|
item = 'Macho Brace';
|
|
} else if (hasMove['trick'] && hasMove['gyroball']) {
|
|
item = 'Iron Ball';
|
|
} else if (counter.Physical >= 3 && (hasMove['trick'] || hasMove['switcheroo'])) {
|
|
item = 'Choice Band';
|
|
} else if (counter.Special >= 3 && (hasMove['trick'] || hasMove['switcheroo'])) {
|
|
item = 'Choice Specs';
|
|
} else if (counter.Status <= 1 && (hasMove['trick'] || hasMove['switcheroo'])) {
|
|
item = 'Choice Scarf';
|
|
} else if (hasMove['rest'] && !hasMove['sleeptalk']) {
|
|
item = 'Chesto Berry';
|
|
} else if (hasMove['naturalgift']) {
|
|
item = 'Liechi Berry';
|
|
} else if (template.species === 'Cubone' || template.species === 'Marowak') {
|
|
item = 'Thick Club';
|
|
} else if (template.species === 'Pikachu') {
|
|
item = 'Light Ball';
|
|
} else if (template.species === 'Clamperl') {
|
|
item = 'DeepSeaTooth';
|
|
} else if (hasMove['reflect'] && hasMove['lightscreen']) {
|
|
item = 'Light Clay';
|
|
} else if (hasMove['acrobatics']) {
|
|
item = 'Flying Gem';
|
|
} else if (hasMove['shellsmash']) {
|
|
item = 'White Herb';
|
|
} else if (ability === 'Poison Heal' || ability === 'Toxic Boost') {
|
|
item = 'Toxic Orb';
|
|
} else if (hasMove['raindance']) {
|
|
item = 'Damp Rock';
|
|
} else if (hasMove['sunnyday']) {
|
|
item = 'Heat Rock';
|
|
} else if (hasMove['sandstorm']) { // lol
|
|
item = 'Smooth Rock';
|
|
} else if (hasMove['hail']) { // lol
|
|
item = 'Icy Rock';
|
|
} else if (ability === 'Magic Guard' && hasMove['psychoshift']) {
|
|
item = 'Flame Orb';
|
|
} else if (ability === 'Sheer Force' || ability === 'Magic Guard') {
|
|
item = 'Life Orb';
|
|
} else if (ability === 'Unburden' && (counter['Physical'] || counter['Special'])) {
|
|
// Give Unburden mons a random Gem of the type of one of their damaging moves
|
|
var shuffledMoves = moves.randomize();
|
|
for (var m in shuffledMoves) {
|
|
var move = this.getMove(shuffledMoves[m]);
|
|
if (move.basePower || move.basePowerCallback) {
|
|
item = move.type + ' Gem';
|
|
break;
|
|
}
|
|
}
|
|
} else if (hasMove['trick'] || hasMove['switcheroo']) {
|
|
item = 'Choice Scarf';
|
|
} else if (ability === 'Guts') {
|
|
if (hasMove['drainpunch']) {
|
|
item = 'Flame Orb';
|
|
} else {
|
|
item = 'Toxic Orb';
|
|
}
|
|
if ((hasMove['return'] || hasMove['hyperfang']) && !hasMove['facade']) {
|
|
// lol no
|
|
for (var j=0; j<moves.length; j++) {
|
|
if (moves[j] === 'Return' || moves[j] === 'HyperFang') {
|
|
moves[j] = 'Facade';
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} else if (ability === 'Marvel Scale' && hasMove['psychoshift']) {
|
|
item = 'FlameOrb';
|
|
} else if (hasMove['reflect'] || hasMove['lightscreen']) {
|
|
// less priority than if you'd had both
|
|
item = 'Light Clay';
|
|
} else if (counter.Physical >= 4 && !hasMove['fakeout'] && !hasMove['suckerpunch']) {
|
|
if (Math.random()*3 > 1) {
|
|
item = 'Choice Band';
|
|
} else {
|
|
item = 'Expert Belt';
|
|
}
|
|
} else if (counter.Special >= 4) {
|
|
if (Math.random()*3 > 1) {
|
|
item = 'Choice Specs';
|
|
} else {
|
|
item = 'Expert Belt';
|
|
}
|
|
} else if (this.getEffectiveness('Ground', template) >= 2 && ability !== 'Levitate') {
|
|
item = 'Air Balloon';
|
|
} else if (hasMove['eruption'] || hasMove['waterspout']) {
|
|
item = 'Choice Scarf';
|
|
} else if (hasMove['substitute'] || hasMove['detect'] || hasMove['protect']) {
|
|
item = 'Leftovers';
|
|
} else if ((hasMove['flail'] || hasMove['reversal']) && !hasMove['endure']) {
|
|
item = 'Focus Sash';
|
|
} else if (ability === 'Iron Barbs') {
|
|
// only Iron Barbs for now
|
|
item = 'Rocky Helmet';
|
|
} else if ((template.baseStats.hp+75)*(template.baseStats.def+template.baseStats.spd+175) > 60000 || template.species === 'Skarmory' || template.species === 'Forretress') {
|
|
// skarmory and forretress get exceptions for their typing
|
|
item = 'Leftovers';
|
|
} else if (counter.Physical + counter.Special >= 3 && setupType) {
|
|
item = 'Life Orb';
|
|
} else if (counter.Special >= 3 && setupType) {
|
|
item = 'Life Orb';
|
|
} else if (counter.Physical + counter.Special >= 4) {
|
|
item = 'Expert Belt';
|
|
} else if (i===0) {
|
|
item = 'Focus Sash';
|
|
}
|
|
|
|
// this is the "REALLY can't think of a good item" cutoff
|
|
// why not always Leftovers? Because it's boring. :P
|
|
|
|
else if (hasType['Flying'] || ability === 'Levitate') {
|
|
item = 'Leftovers';
|
|
} else if (this.getEffectiveness('Ground', template) >= 1 && ability !== 'Levitate') {
|
|
item = 'Air Balloon';
|
|
} else if (hasType['Poison']) {
|
|
item = 'Black Sludge';
|
|
} else if (counter.Status <= 1) {
|
|
item = 'Life Orb';
|
|
}
|
|
/* else if ((template.baseStats.hp+75)*(template.baseStats.def+template.baseStats.spd+175) > 50000) {
|
|
item = 'Leftovers';
|
|
} else if (this.getEffectiveness('Ground', template) >= 0) {
|
|
item = 'Air Balloon';
|
|
} */
|
|
else {
|
|
item = 'Leftovers';
|
|
}
|
|
|
|
if (item === 'Leftovers' && hasType['Poison']) {
|
|
item = 'Black Sludge';
|
|
}
|
|
}
|
|
|
|
// 95-86-82-78-74-70
|
|
var levelScale = {
|
|
LC: 95,
|
|
NFE: 90,
|
|
'LC Uber': 86,
|
|
NU: 86,
|
|
BL3: 84,
|
|
RU: 82,
|
|
BL2: 80,
|
|
UU: 78,
|
|
BL: 76,
|
|
OU: 74,
|
|
CAP: 73,
|
|
G4CAP: 73,
|
|
G5CAP: 73,
|
|
Unreleased: 73,
|
|
Uber: 70
|
|
};
|
|
var customScale = {
|
|
Meloetta: 78,
|
|
Caterpie: 99, Metapod: 99,
|
|
Weedle: 99, Kakuna: 99,
|
|
Hoppip: 99,
|
|
Wurmple: 99, Silcoon: 99, Cascoon: 99,
|
|
Feebas: 99,
|
|
Magikarp: 99
|
|
};
|
|
var level = levelScale[template.tier] || 90;
|
|
if (customScale[template.name]) level = customScale[template.name];
|
|
|
|
if (template.name === 'Chandelure' && ability === 'Shadow Tag') level = 70;
|
|
if (template.name === 'Serperior' && ability === 'Contrary') level = 75;
|
|
if (template.name === 'Magikarp' && hasMove['magikarpsrevenge']) level = 85;
|
|
|
|
pokemon.push({
|
|
name: template.name,
|
|
moves: moves,
|
|
ability: ability,
|
|
evs: evs,
|
|
ivs: ivs,
|
|
item: item,
|
|
level: level,
|
|
shiny: (Math.random()*1024<=1)
|
|
});
|
|
pokemonLeft++;
|
|
}
|
|
return pokemon;
|
|
},
|
|
};
|
|
|
|
var BattleScripts = exports.BattleScripts;
|