mirror of
https://github.com/smogon/pokemon-showdown.git
synced 2026-05-09 12:36:41 -05:00
ba4148cfc7
Two-turn moves are now controlled by a volatile, twoturnmove, which determines whether a Pokemon executes the charge turn or the move turn of a two-turn move. This handles mechanics like Truant Pokemon being unable to use two-turn moves, as the execution turn is their truancy turn. It also handles various edge cases involving moves that call other moves (e.g. Metronome) and Encore. These changes add a new event, onChargeMove, in which one can return false to "skip" the charging turn and execute the move in full immediately. For example, Solarbeam returns false in onChargeMove if the weather is sunny, and Power Herb returns false if the Pokemon uses its item successfully. (Actually, those are the only two examples at present.) This implementation is complete except for one issue, an inversion of a previous problem: whereas before, moves like Assist calling two-turn moves would execute them immediately, now, only the charge turn will be executed, and the Pokemon will not be locked into the move. This is due to be fixed soon.
1088 lines
34 KiB
JavaScript
1088 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 || pokemon.runBeforeMove(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) {
|
|
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);
|
|
move = this.runEvent('ModifyMove',pokemon,target,move,move);
|
|
if (baseMove.target !== move.target) {
|
|
//Target changed in ModifyMove, so we must adjust it here
|
|
target = this.resolveTarget(pokemon, move);
|
|
}
|
|
if (!move) return false;
|
|
|
|
var attrs = '';
|
|
var missed = false;
|
|
if (pokemon.fainted) {
|
|
return false;
|
|
}
|
|
|
|
if (move.isTwoTurnMove && !pokemon.volatiles.twoturnmove) {
|
|
var result = pokemon.addVolatile('twoturnmove', pokemon, move);
|
|
if (result) return; // false means "keep going", e.g. Power Herb activates
|
|
attrs = ' | [silent]'; // suppress the "X used Y!" message if we're executing the attack in the same turn
|
|
}
|
|
|
|
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';
|
|
this.add('move', pokemon, movename, target+attrs);
|
|
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.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();
|
|
|
|
//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 = this.getTemplate(poke).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 = [this.getTemplate(poke).abilities['0']];
|
|
if (this.getTemplate(poke).abilities['1']) {
|
|
abilities.push(this.getTemplate(poke).abilities['1']);
|
|
}
|
|
if (this.getTemplate(poke).abilities['DW']) {
|
|
abilities.push(this.getTemplate(poke).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 (this.getTemplate(poke).requiredItem) {
|
|
item = this.getTemplate(poke).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 = Object.keys(this.getTemplate(poke).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') {
|
|
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;
|