327 lines
14 KiB
JavaScript
327 lines
14 KiB
JavaScript
"use strict";
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
mod
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var dex_species_exports = {};
|
|
__export(dex_species_exports, {
|
|
DexSpecies: () => DexSpecies,
|
|
Learnset: () => Learnset,
|
|
Species: () => Species
|
|
});
|
|
module.exports = __toCommonJS(dex_species_exports);
|
|
var import_dex_data = require("./dex-data");
|
|
var CobblemonCache = __toESM(require("./cobblemon-cache"));
|
|
class Species extends import_dex_data.BasicEffect {
|
|
constructor(data) {
|
|
super(data);
|
|
data = this;
|
|
this.fullname = `pokemon: ${data.name}`;
|
|
this.effectType = "Pokemon";
|
|
this.baseSpecies = data.baseSpecies || this.name;
|
|
this.forme = data.forme || "";
|
|
this.baseForme = data.baseForme || "";
|
|
this.cosmeticFormes = data.cosmeticFormes || void 0;
|
|
this.otherFormes = data.otherFormes || void 0;
|
|
this.formeOrder = data.formeOrder || void 0;
|
|
this.spriteid = data.spriteid || (0, import_dex_data.toID)(this.baseSpecies) + (this.baseSpecies !== this.name ? `-${(0, import_dex_data.toID)(this.forme)}` : "");
|
|
this.abilities = data.abilities || { 0: "" };
|
|
this.types = data.types || ["???"];
|
|
this.addedType = data.addedType || void 0;
|
|
this.prevo = data.prevo || "";
|
|
this.tier = data.tier || "";
|
|
this.doublesTier = data.doublesTier || "";
|
|
this.natDexTier = data.natDexTier || "";
|
|
this.evos = data.evos || [];
|
|
this.evoType = data.evoType || void 0;
|
|
this.evoMove = data.evoMove || void 0;
|
|
this.evoLevel = data.evoLevel || void 0;
|
|
this.nfe = data.nfe || false;
|
|
this.eggGroups = data.eggGroups || [];
|
|
this.canHatch = data.canHatch || false;
|
|
this.gender = data.gender || "";
|
|
this.genderRatio = data.genderRatio || (this.gender === "M" ? { M: 1, F: 0 } : this.gender === "F" ? { M: 0, F: 1 } : this.gender === "N" ? { M: 0, F: 0 } : { M: 0.5, F: 0.5 });
|
|
this.requiredItem = data.requiredItem || void 0;
|
|
this.requiredItems = this.requiredItems || (this.requiredItem ? [this.requiredItem] : void 0);
|
|
this.baseStats = data.baseStats || { hp: 0, atk: 0, def: 0, spa: 0, spd: 0, spe: 0 };
|
|
this.bst = this.baseStats.hp + this.baseStats.atk + this.baseStats.def + this.baseStats.spa + this.baseStats.spd + this.baseStats.spe;
|
|
this.weightkg = data.weightkg || 0;
|
|
this.weighthg = this.weightkg * 10;
|
|
this.heightm = data.heightm || 0;
|
|
this.color = data.color || "";
|
|
this.tags = data.tags || [];
|
|
this.unreleasedHidden = data.unreleasedHidden || false;
|
|
this.maleOnlyHidden = !!data.maleOnlyHidden;
|
|
this.maxHP = data.maxHP || void 0;
|
|
this.isMega = !!(this.forme && ["Mega", "Mega-X", "Mega-Y"].includes(this.forme)) || void 0;
|
|
this.canGigantamax = data.canGigantamax || void 0;
|
|
this.gmaxUnreleased = !!data.gmaxUnreleased;
|
|
this.cannotDynamax = !!data.cannotDynamax;
|
|
this.battleOnly = data.battleOnly || (this.isMega ? this.baseSpecies : void 0);
|
|
this.changesFrom = data.changesFrom || (this.battleOnly !== this.baseSpecies ? this.battleOnly : this.baseSpecies);
|
|
if (Array.isArray(data.changesFrom))
|
|
this.changesFrom = data.changesFrom[0];
|
|
if (!this.gen && this.num >= 1) {
|
|
if (this.num >= 906 || this.forme.includes("Paldea")) {
|
|
this.gen = 9;
|
|
} else if (this.num >= 810 || ["Gmax", "Galar", "Galar-Zen", "Hisui"].includes(this.forme)) {
|
|
this.gen = 8;
|
|
} else if (this.num >= 722 || this.forme.startsWith("Alola") || this.forme === "Starter") {
|
|
this.gen = 7;
|
|
} else if (this.forme === "Primal") {
|
|
this.gen = 6;
|
|
this.isPrimal = true;
|
|
this.battleOnly = this.baseSpecies;
|
|
} else if (this.num >= 650 || this.isMega) {
|
|
this.gen = 6;
|
|
} else if (this.num >= 494) {
|
|
this.gen = 5;
|
|
} else if (this.num >= 387) {
|
|
this.gen = 4;
|
|
} else if (this.num >= 252) {
|
|
this.gen = 3;
|
|
} else if (this.num >= 152) {
|
|
this.gen = 2;
|
|
} else {
|
|
this.gen = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
class Learnset {
|
|
constructor(data) {
|
|
this.exists = true;
|
|
this.effectType = "Learnset";
|
|
this.learnset = data.learnset || void 0;
|
|
this.eventOnly = !!data.eventOnly;
|
|
this.eventData = data.eventData || void 0;
|
|
this.encounters = data.encounters || void 0;
|
|
}
|
|
}
|
|
class DexSpecies {
|
|
constructor(dex) {
|
|
this.speciesCache = /* @__PURE__ */ new Map();
|
|
this.learnsetCache = /* @__PURE__ */ new Map();
|
|
this.allCache = null;
|
|
this.dex = dex;
|
|
}
|
|
get(name) {
|
|
if (name && typeof name !== "string")
|
|
return name;
|
|
name = (name || "").trim();
|
|
let id = (0, import_dex_data.toID)(name);
|
|
if (id === "nidoran" && name.endsWith("\u2640")) {
|
|
id = "nidoranf";
|
|
} else if (id === "nidoran" && name.endsWith("\u2642")) {
|
|
id = "nidoranm";
|
|
}
|
|
return this.getByID(id);
|
|
}
|
|
getByID(id) {
|
|
let species = this.dex.currentMod === CobblemonCache.MOD_ID ? CobblemonCache.speciesByID(id) : this.speciesCache.get(id);
|
|
if (species)
|
|
return species;
|
|
if (this.dex.data.Aliases.hasOwnProperty(id)) {
|
|
if (this.dex.data.FormatsData.hasOwnProperty(id)) {
|
|
const baseId = (0, import_dex_data.toID)(this.dex.data.Aliases[id]);
|
|
species = new Species({
|
|
...this.dex.data.Pokedex[baseId],
|
|
...this.dex.data.FormatsData[id],
|
|
name: id
|
|
});
|
|
species.abilities = { 0: species.abilities["S"] };
|
|
} else {
|
|
species = this.get(this.dex.data.Aliases[id]);
|
|
if (species.cosmeticFormes) {
|
|
for (const forme of species.cosmeticFormes) {
|
|
if ((0, import_dex_data.toID)(forme) === id) {
|
|
species = new Species({
|
|
...species,
|
|
name: forme,
|
|
forme: forme.slice(species.name.length + 1),
|
|
baseForme: "",
|
|
baseSpecies: species.name,
|
|
otherFormes: null,
|
|
cosmeticFormes: null
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.speciesCache.set(id, species);
|
|
return species;
|
|
}
|
|
if (!this.dex.data.Pokedex.hasOwnProperty(id)) {
|
|
let aliasTo = "";
|
|
const formeNames = {
|
|
alola: ["a", "alola", "alolan"],
|
|
galar: ["g", "galar", "galarian"],
|
|
hisui: ["h", "hisui", "hisuian"],
|
|
paldea: ["p", "paldea", "paldean"],
|
|
mega: ["m", "mega"],
|
|
primal: ["p", "primal"]
|
|
};
|
|
for (const forme in formeNames) {
|
|
let pokeName = "";
|
|
for (const i of formeNames[forme]) {
|
|
if (id.startsWith(i)) {
|
|
pokeName = id.slice(i.length);
|
|
} else if (id.endsWith(i)) {
|
|
pokeName = id.slice(0, -i.length);
|
|
}
|
|
}
|
|
if (this.dex.data.Aliases.hasOwnProperty(pokeName))
|
|
pokeName = (0, import_dex_data.toID)(this.dex.data.Aliases[pokeName]);
|
|
if (this.dex.data.Pokedex[pokeName + forme]) {
|
|
aliasTo = pokeName + forme;
|
|
break;
|
|
}
|
|
}
|
|
if (aliasTo) {
|
|
species = this.get(aliasTo);
|
|
if (species.exists) {
|
|
this.speciesCache.set(id, species);
|
|
return species;
|
|
}
|
|
}
|
|
}
|
|
if (id && this.dex.data.Pokedex.hasOwnProperty(id)) {
|
|
const pokedexData = this.dex.data.Pokedex[id];
|
|
const baseSpeciesTags = pokedexData.baseSpecies && this.dex.data.Pokedex[(0, import_dex_data.toID)(pokedexData.baseSpecies)].tags;
|
|
species = new Species({
|
|
tags: baseSpeciesTags,
|
|
...pokedexData,
|
|
...this.dex.data.FormatsData[id]
|
|
});
|
|
const baseSpeciesStatuses = this.dex.data.Conditions[(0, import_dex_data.toID)(species.baseSpecies)];
|
|
if (baseSpeciesStatuses !== void 0) {
|
|
let key;
|
|
for (key in baseSpeciesStatuses) {
|
|
if (!(key in species))
|
|
species[key] = baseSpeciesStatuses[key];
|
|
}
|
|
}
|
|
if (!species.tier && !species.doublesTier && !species.natDexTier && species.baseSpecies !== species.name) {
|
|
if (species.baseSpecies === "Mimikyu") {
|
|
species.tier = this.dex.data.FormatsData[(0, import_dex_data.toID)(species.baseSpecies)].tier || "Illegal";
|
|
species.doublesTier = this.dex.data.FormatsData[(0, import_dex_data.toID)(species.baseSpecies)].doublesTier || "Illegal";
|
|
species.natDexTier = this.dex.data.FormatsData[(0, import_dex_data.toID)(species.baseSpecies)].natDexTier || "Illegal";
|
|
} else if (species.id.endsWith("totem")) {
|
|
species.tier = this.dex.data.FormatsData[species.id.slice(0, -5)].tier || "Illegal";
|
|
species.doublesTier = this.dex.data.FormatsData[species.id.slice(0, -5)].doublesTier || "Illegal";
|
|
species.natDexTier = this.dex.data.FormatsData[species.id.slice(0, -5)].natDexTier || "Illegal";
|
|
} else if (species.battleOnly) {
|
|
species.tier = this.dex.data.FormatsData[(0, import_dex_data.toID)(species.battleOnly)].tier || "Illegal";
|
|
species.doublesTier = this.dex.data.FormatsData[(0, import_dex_data.toID)(species.battleOnly)].doublesTier || "Illegal";
|
|
species.natDexTier = this.dex.data.FormatsData[(0, import_dex_data.toID)(species.battleOnly)].natDexTier || "Illegal";
|
|
} else {
|
|
const baseFormatsData = this.dex.data.FormatsData[(0, import_dex_data.toID)(species.baseSpecies)];
|
|
if (!baseFormatsData) {
|
|
throw new Error(`${species.baseSpecies} has no formats-data entry`);
|
|
}
|
|
species.tier = baseFormatsData.tier || "Illegal";
|
|
species.doublesTier = baseFormatsData.doublesTier || "Illegal";
|
|
species.natDexTier = baseFormatsData.natDexTier || "Illegal";
|
|
}
|
|
}
|
|
if (!species.tier)
|
|
species.tier = "Illegal";
|
|
if (!species.doublesTier)
|
|
species.doublesTier = species.tier;
|
|
if (!species.natDexTier)
|
|
species.natDexTier = species.tier;
|
|
if (species.gen > this.dex.gen) {
|
|
species.tier = "Illegal";
|
|
species.doublesTier = "Illegal";
|
|
species.natDexTier = "Illegal";
|
|
species.isNonstandard = "Future";
|
|
}
|
|
if (this.dex.currentMod === "gen7letsgo" && !species.isNonstandard) {
|
|
const isLetsGo = (species.num <= 151 || ["Meltan", "Melmetal"].includes(species.name)) && (!species.forme || ["Alola", "Mega", "Mega-X", "Mega-Y", "Starter"].includes(species.forme) && species.name !== "Pikachu-Alola");
|
|
if (!isLetsGo)
|
|
species.isNonstandard = "Past";
|
|
}
|
|
if (this.dex.currentMod === "gen8bdsp" && (!species.isNonstandard || ["Gigantamax", "CAP"].includes(species.isNonstandard))) {
|
|
if (species.gen > 4 || species.num < 1 && species.isNonstandard !== "CAP" || species.id === "pichuspikyeared") {
|
|
species.isNonstandard = "Future";
|
|
species.tier = species.doublesTier = species.natDexTier = "Illegal";
|
|
}
|
|
}
|
|
species.nfe = species.evos.some((evo) => {
|
|
const evoSpecies = this.get(evo);
|
|
return !evoSpecies.isNonstandard || evoSpecies.isNonstandard === species?.isNonstandard || // Pokemon with Hisui evolutions
|
|
evoSpecies.isNonstandard === "Unobtainable";
|
|
});
|
|
species.canHatch = species.canHatch || !["Ditto", "Undiscovered"].includes(species.eggGroups[0]) && !species.prevo && species.name !== "Manaphy";
|
|
if (this.dex.gen === 1)
|
|
species.bst -= species.baseStats.spd;
|
|
if (this.dex.gen < 5)
|
|
delete species.abilities["H"];
|
|
if (this.dex.gen === 3 && this.dex.abilities.get(species.abilities["1"]).gen === 4)
|
|
delete species.abilities["1"];
|
|
} else {
|
|
species = new Species({
|
|
id,
|
|
name: id,
|
|
exists: false,
|
|
tier: "Illegal",
|
|
doublesTier: "Illegal",
|
|
natDexTier: "Illegal",
|
|
isNonstandard: "Custom"
|
|
});
|
|
}
|
|
if (species.exists)
|
|
this.speciesCache.set(id, species);
|
|
return species;
|
|
}
|
|
getLearnset(id) {
|
|
return this.getLearnsetData(id).learnset;
|
|
}
|
|
getLearnsetData(id) {
|
|
let learnsetData = this.learnsetCache.get(id);
|
|
if (learnsetData)
|
|
return learnsetData;
|
|
if (!this.dex.data.Learnsets.hasOwnProperty(id)) {
|
|
return new Learnset({ exists: false });
|
|
}
|
|
learnsetData = new Learnset(this.dex.data.Learnsets[id]);
|
|
this.learnsetCache.set(id, learnsetData);
|
|
return learnsetData;
|
|
}
|
|
all() {
|
|
if (this.allCache)
|
|
return this.allCache;
|
|
const species = [];
|
|
for (const id in this.dex.data.Pokedex) {
|
|
species.push(this.getByID(id));
|
|
}
|
|
this.allCache = species;
|
|
return this.allCache;
|
|
}
|
|
}
|
|
//# sourceMappingURL=dex-species.js.map
|