236 lines
10 KiB
JavaScript
236 lines
10 KiB
JavaScript
"use strict";
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var random_teams_exports = {};
|
|
__export(random_teams_exports, {
|
|
RandomLetsGoTeams: () => RandomLetsGoTeams,
|
|
default: () => random_teams_default
|
|
});
|
|
module.exports = __toCommonJS(random_teams_exports);
|
|
var import_random_teams = require("../gen8/random-teams");
|
|
class RandomLetsGoTeams extends import_random_teams.RandomGen8Teams {
|
|
constructor(format, prng) {
|
|
super(format, prng);
|
|
this.randomData = require("./random-data.json");
|
|
this.moveEnforcementCheckers = {
|
|
Dark: (movePool, moves, abilities, types, counter) => !counter.get("Dark"),
|
|
Dragon: (movePool, moves, abilities, types, counter) => !counter.get("Dragon"),
|
|
Electric: (movePool, moves, abilities, types, counter) => !counter.get("Electric"),
|
|
Fighting: (movePool, moves, abilities, types, counter) => !counter.get("Fighting") && (!!counter.setupType || !counter.get("Status")),
|
|
Fire: (movePool, moves, abilities, types, counter) => !counter.get("Fire"),
|
|
Ghost: (movePool, moves, abilities, types, counter) => !types.has("Dark") && !counter.get("Ghost"),
|
|
Ground: (movePool, moves, abilities, types, counter) => !counter.get("Ground"),
|
|
Ice: (movePool, moves, abilities, types, counter) => !counter.get("Ice"),
|
|
Water: (movePool, moves, abilities, types, counter) => !counter.get("Water") || !counter.get("stab")
|
|
};
|
|
}
|
|
shouldCullMove(move, types, moves, abilities, counter, movePool, teamDetails) {
|
|
switch (move.id) {
|
|
case "bulkup":
|
|
case "swordsdance":
|
|
return {
|
|
cull: counter.setupType !== "Physical" || counter.get("physicalsetup") > 1 || counter.get("Physical") + counter.get("physicalpool") < 2,
|
|
isSetup: true
|
|
};
|
|
case "calmmind":
|
|
case "nastyplot":
|
|
case "quiverdance":
|
|
return {
|
|
cull: counter.setupType !== "Special" || counter.get("specialsetup") > 1 || counter.get("Special") + counter.get("specialpool") < 2,
|
|
isSetup: true
|
|
};
|
|
case "growth":
|
|
case "shellsmash":
|
|
return {
|
|
cull: counter.setupType !== "Mixed" || counter.damagingMoves.size + counter.get("physicalpool") + counter.get("specialpool") < 2,
|
|
isSetup: true
|
|
};
|
|
case "agility":
|
|
return {
|
|
cull: counter.damagingMoves.size < 2 && !counter.setupType,
|
|
isSetup: !counter.setupType
|
|
};
|
|
case "dragontail":
|
|
return { cull: !!counter.setupType || !!counter.get("speedsetup") || ["encore", "roar", "whirlwind"].some((m) => moves.has(m)) };
|
|
case "fakeout":
|
|
case "uturn":
|
|
case "teleport":
|
|
return { cull: !!counter.setupType || !!counter.get("speedsetup") || moves.has("substitute") };
|
|
case "haze":
|
|
case "leechseed":
|
|
case "roar":
|
|
case "whirlwind":
|
|
return { cull: !!counter.setupType || !!counter.get("speedsetup") || moves.has("dragontail") };
|
|
case "protect":
|
|
return { cull: !!counter.setupType || ["rest", "lightscreen", "reflect"].some((m) => moves.has(m)) };
|
|
case "seismictoss":
|
|
return { cull: counter.damagingMoves.size > 1 || !!counter.setupType };
|
|
case "stealthrock":
|
|
return { cull: !!counter.setupType || !!counter.get("speedsetup") || !!teamDetails.stealthRock };
|
|
case "leechlife":
|
|
case "substitute":
|
|
return { cull: moves.has("uturn") };
|
|
case "dragonpulse":
|
|
return { cull: moves.has("dragontail") || moves.has("outrage") };
|
|
case "thunderbolt":
|
|
return { cull: moves.has("thunder") };
|
|
case "flareblitz":
|
|
case "flamethrower":
|
|
return { cull: moves.has("fireblast") || moves.has("firepunch") };
|
|
case "megadrain":
|
|
return { cull: moves.has("petaldance") || moves.has("powerwhip") };
|
|
case "bonemerang":
|
|
return { cull: moves.has("earthquake") };
|
|
case "icebeam":
|
|
return { cull: moves.has("blizzard") };
|
|
case "rockslide":
|
|
return { cull: moves.has("stoneedge") };
|
|
case "hydropump":
|
|
case "willowisp":
|
|
return { cull: moves.has("scald") };
|
|
case "surf":
|
|
return { cull: moves.has("hydropump") || moves.has("scald") };
|
|
}
|
|
if (move.priority !== 0 && !!counter.get("speedsetup"))
|
|
return { cull: true };
|
|
if (move.category === "Physical" && counter.setupType === "Special" || move.category === "Special" && counter.setupType === "Physical") {
|
|
if (!types.has(move.type) || counter.get("stab") > 1 || counter.get(move.category) < 2)
|
|
return { cull: true };
|
|
}
|
|
return { cull: false };
|
|
}
|
|
randomSet(species, teamDetails = {}) {
|
|
species = this.dex.species.get(species);
|
|
let forme = species.name;
|
|
if (typeof species.battleOnly === "string") {
|
|
forme = species.battleOnly;
|
|
}
|
|
const data = this.randomData[species.id];
|
|
const movePool = (data.moves || Object.keys(this.dex.species.getLearnset(species.id))).slice();
|
|
const types = new Set(species.types);
|
|
const moves = /* @__PURE__ */ new Set();
|
|
let counter;
|
|
do {
|
|
while (moves.size < this.maxMoveCount && movePool.length) {
|
|
const moveid = this.sampleNoReplace(movePool);
|
|
moves.add(moveid);
|
|
}
|
|
counter = this.queryMoves(moves, species.types, /* @__PURE__ */ new Set(), movePool);
|
|
for (const moveid of moves) {
|
|
const move = this.dex.moves.get(moveid);
|
|
let { cull, isSetup } = this.shouldCullMove(move, types, moves, /* @__PURE__ */ new Set(), counter, movePool, teamDetails);
|
|
if (!isSetup && counter.setupType && counter.setupType !== "Mixed" && move.category !== counter.setupType && counter.get(counter.setupType) < 2 && // Mono-attacking with setup and RestTalk is allowed
|
|
// Reject Status moves only if there is nothing else to reject
|
|
(move.category !== "Status" || counter.get(counter.setupType) + counter.get("Status") > 3 && counter.get("physicalsetup") + counter.get("specialsetup") < 2)) {
|
|
cull = true;
|
|
}
|
|
const moveIsRejectable = !move.damage && (move.category !== "Status" || !move.flags.heal) && (move.category === "Status" || !types.has(move.type) || move.selfSwitch || move.basePower && move.basePower < 40 && !move.multihit);
|
|
if (moveIsRejectable && !cull && !isSetup && counter.get("physicalsetup") + counter.get("specialsetup") < 2 && (!counter.setupType || counter.setupType === "Mixed" || move.category !== counter.setupType && move.category !== "Status" || counter.get(counter.setupType) + counter.get("Status") > 3)) {
|
|
if ((counter.damagingMoves.size === 0 || !counter.get("stab")) && (counter.get("physicalpool") || counter.get("specialpool"))) {
|
|
cull = true;
|
|
} else {
|
|
for (const type of types) {
|
|
if (this.moveEnforcementCheckers[type]?.(movePool, moves, /* @__PURE__ */ new Set(), types, counter, species, teamDetails))
|
|
cull = true;
|
|
}
|
|
}
|
|
}
|
|
if (cull && movePool.length) {
|
|
moves.delete(moveid);
|
|
break;
|
|
}
|
|
}
|
|
} while (moves.size < this.maxMoveCount && movePool.length);
|
|
const ivs = { hp: 31, atk: 31, def: 31, spa: 31, spd: 31, spe: 31 };
|
|
if (!counter.get("Physical") && !moves.has("transform"))
|
|
ivs.atk = 0;
|
|
const requiredItem = species.requiredItem || (species.requiredItems ? this.sample(species.requiredItems) : null);
|
|
return {
|
|
name: species.baseSpecies,
|
|
species: forme,
|
|
level: this.adjustLevel || 100,
|
|
gender: species.gender,
|
|
happiness: 70,
|
|
shiny: this.randomChance(1, 1024),
|
|
item: requiredItem || "",
|
|
ability: "No Ability",
|
|
evs: { hp: 20, atk: 20, def: 20, spa: 20, spd: 20, spe: 20 },
|
|
moves: Array.from(moves),
|
|
ivs
|
|
};
|
|
}
|
|
randomTeam() {
|
|
this.enforceNoDirectCustomBanlistChanges();
|
|
const pokemon = [];
|
|
const pokemonPool = [];
|
|
for (const id in this.dex.data.FormatsData) {
|
|
const species = this.dex.species.get(id);
|
|
if (species.num < 1 || species.num > 151 && ![808, 809].includes(species.num) || species.gen > 7 || species.nfe || !this.randomData[species.id]?.moves || this.forceMonotype && !species.types.includes(this.forceMonotype)) {
|
|
continue;
|
|
}
|
|
pokemonPool.push(id);
|
|
}
|
|
const typeCount = {};
|
|
const typeComboCount = {};
|
|
const baseFormes = {};
|
|
const teamDetails = {};
|
|
while (pokemonPool.length && pokemon.length < this.maxTeamSize) {
|
|
const species = this.dex.species.get(this.sampleNoReplace(pokemonPool));
|
|
if (!species.exists)
|
|
continue;
|
|
if (baseFormes[species.baseSpecies])
|
|
continue;
|
|
const types = species.types;
|
|
let skip = false;
|
|
for (const type of species.types) {
|
|
if (typeCount[type] > 1 && this.randomChance(4, 5)) {
|
|
skip = true;
|
|
break;
|
|
}
|
|
}
|
|
if (skip)
|
|
continue;
|
|
const typeCombo = types.slice().sort().join();
|
|
if (!this.forceMonotype && typeComboCount[typeCombo] >= 1)
|
|
continue;
|
|
const set = this.randomSet(species, teamDetails);
|
|
pokemon.push(set);
|
|
baseFormes[species.baseSpecies] = 1;
|
|
for (const type of types) {
|
|
if (type in typeCount) {
|
|
typeCount[type]++;
|
|
} else {
|
|
typeCount[type] = 1;
|
|
}
|
|
}
|
|
if (typeCombo in typeComboCount) {
|
|
typeComboCount[typeCombo]++;
|
|
} else {
|
|
typeComboCount[typeCombo] = 1;
|
|
}
|
|
if (set.moves.includes("stealthrock"))
|
|
teamDetails.stealthRock = 1;
|
|
if (set.moves.includes("rapidspin"))
|
|
teamDetails.rapidSpin = 1;
|
|
}
|
|
return pokemon;
|
|
}
|
|
}
|
|
var random_teams_default = RandomLetsGoTeams;
|
|
//# sourceMappingURL=random-teams.js.map
|