dist/server/chat-plugins/randombattles/index.js

"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 randombattles_exports = {};
__export(randombattles_exports, {
  STAT_NAMES: () => STAT_NAMES,
  commands: () => commands,
  formatNature: () => formatNature
});
module.exports = __toCommonJS(randombattles_exports);
var import_lib = require("../../../lib");
function getHTMLCriteriaDescription(criteria) {
  const format = (list) => list.map((m) => import_lib.Utils.html`<strong>${m.name}</strong>`);
  const parts = [];
  const { moves, ability, item, nature, teraType } = criteria;
  if (moves.mustHave.length) {
    parts.push(`had the move${Chat.plural(moves.mustHave)} ${Chat.toListString(format(moves.mustHave))}`);
  }
  if (moves.mustNotHave.length) {
    parts.push(`did not have the move${Chat.plural(moves.mustNotHave)} ${Chat.toListString(format(moves.mustNotHave), "or")}`);
  }
  if (ability.mustHave) {
    parts.push(import_lib.Utils.html`had the ability <strong>${ability.mustHave.name}</strong>`);
  }
  if (ability.mustNotHave.length) {
    parts.push(`did not have the ${Chat.plural(ability.mustNotHave, "abilities", "ability")} ${Chat.toListString(format(ability.mustNotHave), "or")}`);
  }
  if (item.mustHave) {
    parts.push(import_lib.Utils.html`had the item <strong>${item.mustHave.name}</strong>`);
  }
  if (item.mustNotHave.length) {
    parts.push(`did not have the item${Chat.plural(item.mustNotHave)} ${Chat.toListString(format(item.mustNotHave), "or")}`);
  }
  if (nature.mustHave) {
    parts.push(import_lib.Utils.html`had the nature <strong>${nature.mustHave.name}</strong>`);
  }
  if (nature.mustNotHave.length) {
    parts.push(`did not have the nature${Chat.plural(nature.mustNotHave)} ${Chat.toListString(format(nature.mustNotHave), "or")}`);
  }
  if (teraType.mustHave) {
    parts.push(import_lib.Utils.html`had the Tera Type <strong>${teraType.mustHave.name}</strong>`);
  }
  if (teraType.mustNotHave.length) {
    parts.push(`did not have the Tera Type${Chat.plural(teraType.mustNotHave)} ${Chat.toListString(format(teraType.mustNotHave), "or")}`);
  }
  return Chat.toListString(parts, "and");
}
function setProbability(species, format, criteria, rounds = 700) {
  const results = { rounds, matches: 0 };
  const generator = Teams.getGenerator(format);
  for (let i = 0; i < rounds; i++) {
    const set = generator.randomSet(
      species,
      {},
      false,
      format.gameType !== "singles",
      format.ruleTable?.has("dynamaxclause")
    );
    if (criteria.item.mustHave && set.item !== criteria.item.mustHave.name)
      continue;
    if (criteria.item.mustNotHave.some((item) => item.name === set.item))
      continue;
    if (criteria.ability.mustHave && set.ability !== criteria.ability.mustHave.name)
      continue;
    if (criteria.ability.mustNotHave.some((ability) => ability.name === set.ability))
      continue;
    if (criteria.nature.mustHave && set.nature !== criteria.nature.mustHave.name)
      continue;
    if (criteria.nature.mustNotHave.some((nature) => nature.name === set.nature))
      continue;
    if (criteria.teraType.mustHave && set.teraType !== criteria.teraType.mustHave.name)
      continue;
    if (criteria.teraType.mustNotHave.some((type) => type.name === set.teraType))
      continue;
    const setHasMove = (move) => {
      const id = move.id === "hiddenpower" ? `${move.id}${toID(move.type)}` : move.id;
      return set.moves.includes(id);
    };
    if (!criteria.moves.mustHave.every(setHasMove))
      continue;
    if (criteria.moves.mustNotHave.some(setHasMove))
      continue;
    results.matches++;
  }
  return results;
}
const GEN_NAMES = {
  gen1: "[Gen 1]",
  gen2: "[Gen 2]",
  gen3: "[Gen 3]",
  gen4: "[Gen 4]",
  gen5: "[Gen 5]",
  gen6: "[Gen 6]",
  gen7: "[Gen 7]",
  gen8: "[Gen 8]",
  gen9: "[Gen 9]"
};
const STAT_NAMES = {
  hp: "HP",
  atk: "Atk",
  def: "Def",
  spa: "SpA",
  spd: "SpD",
  spe: "Spe"
};
const TIERS = {
  uber: "Uber",
  ubers: "Uber",
  ou: "OU",
  uu: "UU",
  ru: "RU",
  nu: "NU",
  pu: "PU",
  mono: "Mono",
  monotype: "Mono",
  lc: "LC",
  littlecup: "LC"
};
function formatAbility(ability) {
  ability = Dex.abilities.get(ability);
  return `<a href="https://${Config.routes.dex}/abilities/${ability.id}" target="_blank" class="subtle" style="white-space:nowrap">${ability.name}</a>`;
}
function formatNature(n) {
  const nature = Dex.natures.get(n);
  return nature.name;
}
function formatMove(move) {
  move = Dex.moves.get(move);
  return `<a href="https://${Config.routes.dex}/moves/${move.id}" target="_blank" class="subtle" style="white-space:nowrap">${move.name}</a>`;
}
function formatItem(item) {
  if (typeof item === "string" && item === "No Item") {
    return `No Item`;
  } else {
    item = Dex.items.get(item);
    return `<a href="https://${Config.routes.dex}/items/${item.id}" target="_blank" class="subtle" style="white-space:nowrap">${item.name}</a>`;
  }
}
function formatType(type) {
  type = Dex.types.get(type);
  return type.name;
}
function getSets(species, format = "gen9randombattle") {
  const dex = Dex.forFormat(format);
  format = Dex.formats.get(format);
  species = dex.species.get(species);
  const isDoubles = format.gameType === "doubles";
  let folderName = format.mod;
  if (format.team === "randomBaby")
    folderName += "baby";
  if (species.isNonstandard === "CAP")
    folderName += "cap";
  const setsFile = JSON.parse(
    (0, import_lib.FS)(`data/random-battles/${folderName}/${isDoubles ? "doubles-" : ""}sets.json`).readIfExistsSync() || "{}"
  );
  const data = setsFile[species.id];
  if (!data?.sets?.length)
    return null;
  return data;
}
function getData(species, format) {
  const dex = Dex.forFormat(format);
  format = Dex.formats.get(format);
  species = dex.species.get(species);
  const dataFile = JSON.parse(
    (0, import_lib.FS)(`data/random-battles/${format.mod}/data.json`).readIfExistsSync() || "{}"
  );
  const data = dataFile[species.id];
  if (!data)
    return null;
  return data;
}
function getLevel(species, format) {
  const dex = Dex.forFormat(format);
  format = Dex.formats.get(format);
  species = dex.species.get(species);
  switch (format.id) {
    case "gen2randombattle":
      const levelScale = {
        ZU: 81,
        ZUBL: 79,
        PU: 77,
        PUBL: 75,
        NU: 73,
        NUBL: 71,
        UU: 69,
        UUBL: 67,
        OU: 65,
        Uber: 61
      };
      return levelScale[species.tier] || 80;
  }
  return 0;
}
function getRBYMoves(species) {
  species = Dex.mod(`gen1`).species.get(species);
  const data = getData(species, "gen1randombattle");
  if (!data)
    return false;
  let buf = `<br/><b>Level</b>: ${data.level}`;
  if (data.comboMoves) {
    buf += `<br/><b>Combo moves</b>: `;
    buf += data.comboMoves.map(formatMove).sort().join(", ");
  }
  if (data.exclusiveMoves) {
    buf += `<br/><b>Exclusive moves</b>: `;
    buf += data.exclusiveMoves.map(formatMove).sort().join(", ");
  }
  if (data.essentialMoves) {
    buf += `<br/><b>Essential move${Chat.plural(data.essentialMoves)}</b>: `;
    buf += data.essentialMoves.map(formatMove).sort().join(", ");
  }
  if (data.moves) {
    buf += `<br/><b>Randomized moves</b>: `;
    buf += data.moves.map(formatMove).sort().join(", ");
  }
  if (!data.moves && !data.comboMoves && !data.exclusiveMoves && !data.essentialMove) {
    return false;
  }
  return buf;
}
function getLetsGoMoves(species) {
  species = Dex.species.get(species);
  const data = getData(species, "gen7letsgorandombattle");
  if (!data)
    return false;
  const isLetsGoLegal = (species.num <= 151 || ["Meltan", "Melmetal"].includes(species.name)) && (!species.forme || ["Alola", "Mega", "Mega-X", "Mega-Y", "Starter"].includes(species.forme));
  if (!isLetsGoLegal)
    return false;
  if (!data.moves?.length)
    return false;
  return data.moves.map(formatMove).sort().join(`, `);
}
function battleFactorySets(species, tier, gen = "gen9", isBSS = false) {
  species = Dex.species.get(species);
  if (typeof species.battleOnly === "string") {
    species = Dex.species.get(species.battleOnly);
  }
  gen = toID(gen);
  const genNum = parseInt(gen[3]);
  if (isNaN(genNum) || genNum < 6 || isBSS && genNum < 7)
    return null;
  const statsFile = JSON.parse(
    (0, import_lib.FS)(`data/random-battles/gen${genNum}/${isBSS ? `bss-` : ``}factory-sets.json`).readIfExistsSync() || "{}"
  );
  if (!Object.keys(statsFile).length)
    return null;
  let buf = ``;
  if (!isBSS) {
    if (!tier)
      throw new Chat.ErrorMessage(`Please provide a valid tier.`);
    if (!(toID(tier) in TIERS))
      throw new Chat.ErrorMessage(`That tier isn't supported.`);
    if (!(TIERS[toID(tier)] in statsFile)) {
      throw new Chat.ErrorMessage(`${TIERS[toID(tier)]} is not included in [Gen ${genNum}] Battle Factory.`);
    }
    const t = statsFile[TIERS[toID(tier)]];
    if (!(species.id in t)) {
      const formatName = Dex.formats.get(`${gen}battlefactory`).name;
      throw new Chat.ErrorMessage(`${species.name} doesn't have any sets in ${TIERS[toID(tier)]} for ${formatName}.`);
    }
    const setObj = t[species.id];
    if (genNum >= 9) {
      buf += `Species rarity: ${setObj.weight} (higher is more common, max 10)<br />`;
    }
    buf += `<span style="color:#999999;">Sets for ${species.name} in${genNum === 8 ? `` : ` ${GEN_NAMES[gen]}`} ${TIERS[toID(tier)]}:</span><br />`;
    for (const [i, set] of setObj.sets.entries()) {
      if (genNum >= 9) {
        buf += `<details><summary>Set ${i + 1} (${set.weight}%)</summary>`;
      } else {
        buf += `<details><summary>Set ${i + 1}</summary>`;
      }
      buf += `<ul style="list-style-type:none;">`;
      buf += `<li>${set.species}${set.gender ? ` (${set.gender})` : ``} @ ${Array.isArray(set.item) ? set.item.map(formatItem).join(" / ") : formatItem(set.item)}</li>`;
      buf += `<li>Ability: ${Array.isArray(set.ability) ? set.ability.map(formatAbility).join(" / ") : formatAbility(set.ability)}</li>`;
      if (TIERS[toID(tier)] === "LC" && !set.level)
        buf += `<li>Level: 5</li>`;
      if (set.level && set.level < 100)
        buf += `<li>Level: ${set.level}</li>`;
      if (set.shiny)
        buf += `<li>Shiny: Yes</li>`;
      if (set.happiness)
        buf += `<li>Happiness: ${set.happiness}</li>`;
      if (genNum === 9 && set.teraType) {
        buf += `<li>Tera Type: ${set.teraType.map(formatType).join(" / ")}</li>`;
      }
      if (set.evs) {
        buf += `<li>EVs: `;
        const evs = [];
        let ev;
        for (ev in set.evs) {
          if (set.evs[ev] === 0)
            continue;
          evs.push(`${set.evs[ev]} ${STAT_NAMES[ev]}`);
        }
        buf += `${evs.join(" / ")}</li>`;
      }
      buf += `<li>${Array.isArray(set.nature) ? set.nature.map(formatNature).join(" / ") : formatNature(set.nature)} Nature</li>`;
      if (set.ivs) {
        buf += `<li>IVs: `;
        const ivs = [];
        let iv;
        for (iv in set.ivs) {
          if (set.ivs[iv] === 31)
            continue;
          ivs.push(`${set.ivs[iv]} ${STAT_NAMES[iv]}`);
        }
        buf += `${ivs.join(" / ")}</li>`;
      }
      for (const moveid of set.moves) {
        buf += `<li>- ${Array.isArray(moveid) ? moveid.map(formatMove).join(" / ") : formatMove(moveid)}</li>`;
      }
      buf += `</ul></details>`;
    }
  } else {
    const format = Dex.formats.get(`${gen}bssfactory`);
    if (!(species.id in statsFile))
      throw new Chat.ErrorMessage(`${species.name} doesn't have any sets in ${format.name}.`);
    const setObj = statsFile[species.id];
    if (genNum >= 9) {
      buf += `Species rarity: ${setObj.weight} (higher is more common, max 10)<br />`;
      buf += `Sets for ${species.name} in ${format.name}:<br />`;
      for (const [i, set] of setObj.sets.entries()) {
        buf += `<details><summary>Set ${i + 1} (${set.weight}%)</summary>`;
        buf += `<ul style="list-style-type:none;padding-left:0;">`;
        buf += `<li>${Dex.forFormat(format).species.get(set.species).name} @ ${set.item.map(formatItem).join(" / ")}</li>`;
        buf += `<li>Ability: ${set.ability.map(formatAbility).join(" / ")}</li>`;
        buf += `<li>Level: 50</li>`;
        buf += `<li>Tera Type: ${set.teraType.map(formatType).join(" / ")}</li>`;
        if (set.evs) {
          buf += `<li>EVs: `;
          const evs = [];
          let ev;
          for (ev in set.evs) {
            if (!set.evs[ev])
              continue;
            evs.push(`${set.evs[ev]} ${STAT_NAMES[ev]}`);
          }
          buf += `${evs.join(" / ")}</li>`;
        }
        buf += `<li>${formatNature(set.nature)} Nature</li>`;
        if (set.ivs) {
          buf += `<li>IVs: `;
          const ivs = [];
          let iv;
          for (iv in set.ivs) {
            if (set.ivs[iv] === 31)
              continue;
            ivs.push(`${set.ivs[iv]} ${STAT_NAMES[iv]}`);
          }
          buf += `${ivs.join(" / ")}</li>`;
        }
        for (const moveSlot of set.moves) {
          buf += `<li>- ${moveSlot.map(formatMove).join(" / ")}</li>`;
        }
        buf += `</ul></details>`;
      }
    } else {
      buf += `<span style="color:#999999;">Sets for ${species.name} in ${format.name}:</span><br />`;
      for (const [i, set] of setObj.sets.entries()) {
        buf += `<details><summary>Set ${i + 1}</summary>`;
        buf += `<ul style="list-style-type:none;padding-left:0;">`;
        buf += `<li>${set.species}${set.gender ? ` (${set.gender})` : ``} @ ${Array.isArray(set.item) ? set.item.map(formatItem).join(" / ") : formatItem(set.item)}</li>`;
        buf += `<li>Ability: ${Array.isArray(set.ability) ? set.ability.map(formatAbility).join(" / ") : formatAbility(set.ability)}</li>`;
        if (!set.level)
          buf += `<li>Level: 50</li>`;
        if (set.level && set.level < 50)
          buf += `<li>Level: ${set.level}</li>`;
        if (set.shiny)
          buf += `<li>Shiny: Yes</li>`;
        if (set.happiness)
          buf += `<li>Happiness: ${set.happiness}</li>`;
        if (set.evs) {
          buf += `<li>EVs: `;
          const evs = [];
          let ev;
          for (ev in set.evs) {
            if (set.evs[ev] === 0)
              continue;
            evs.push(`${set.evs[ev]} ${STAT_NAMES[ev]}`);
          }
          buf += `${evs.join(" / ")}</li>`;
        }
        buf += `<li>${Array.isArray(set.nature) ? set.nature.map(formatNature).join(" / ") : formatNature(set.nature)} Nature</li>`;
        if (set.ivs) {
          buf += `<li>IVs: `;
          const ivs = [];
          let iv;
          for (iv in set.ivs) {
            if (set.ivs[iv] === 31)
              continue;
            ivs.push(`${set.ivs[iv]} ${STAT_NAMES[iv]}`);
          }
          buf += `${ivs.join(" / ")}</li>`;
        }
        for (const moveid of set.moves) {
          buf += `<li>- ${Array.isArray(moveid) ? moveid.map(formatMove).join(" / ") : formatMove(moveid)}</li>`;
        }
        buf += `</ul></details>`;
      }
    }
  }
  return buf;
}
function CAP1v1Sets(species) {
  species = Dex.species.get(species);
  const statsFile = JSON.parse(
    (0, import_lib.FS)(`data/random-battles/gen8/cap-1v1-sets.json`).readIfExistsSync() || "{}"
  );
  if (!Object.keys(statsFile).length)
    return null;
  if (species.isNonstandard !== "CAP") {
    return {
      e: `[Gen 8] CAP 1v1 only allows Pok\xE9mon created by the Create-A-Pok\xE9mon Project.`,
      parse: `/cap`
    };
  }
  if (species.isNonstandard === "CAP" && !(species.name in statsFile)) {
    return { e: `${species.name} doesn't have any sets in [Gen 8] CAP 1v1.` };
  }
  let buf = `<span style="color:#999999;">Sets for ${species.name} in [Gen 8] CAP 1v1:</span><br />`;
  for (const [i, set] of statsFile[species.name].entries()) {
    buf += `<details><summary>Set ${i + 1}</summary>`;
    buf += `<ul style="list-style-type:none;">`;
    buf += `<li>${set.species || species.name}${set.gender ? ` (${set.gender})` : ``} @ ${Array.isArray(set.item) ? set.item.map(formatItem).join(" / ") : formatItem(set.item)}</li>`;
    buf += `<li>Ability: ${Array.isArray(set.ability) ? set.ability.map(formatAbility).join(" / ") : formatAbility(set.ability)}</li>`;
    if (set.level && set.level < 100)
      buf += `<li>Level: ${set.level}</li>`;
    if (set.shiny)
      buf += `<li>Shiny: Yes</li>`;
    if (set.happiness)
      buf += `<li>Happiness: ${set.happiness}</li>`;
    if (set.evs) {
      buf += `<li>EVs: `;
      const evs = [];
      let ev;
      for (ev in set.evs) {
        if (set.evs[ev] === 0)
          continue;
        evs.push(`${set.evs[ev]} ${STAT_NAMES[ev]}`);
      }
      buf += `${evs.join(" / ")}</li>`;
    }
    buf += `<li>${Array.isArray(set.nature) ? set.nature.map(formatNature).join(" / ") : formatNature(set.nature)} Nature</li>`;
    if (set.ivs) {
      buf += `<li>IVs: `;
      const ivs = [];
      let iv;
      for (iv in set.ivs) {
        if (set.ivs[iv] === 31)
          continue;
        ivs.push(`${set.ivs[iv]} ${STAT_NAMES[iv]}`);
      }
      buf += `${ivs.join(" / ")}</li>`;
    }
    for (const moveid of set.moves) {
      buf += `<li>- ${Array.isArray(moveid) ? moveid.map(formatMove).join(" / ") : formatMove(moveid)}</li>`;
    }
    buf += `</ul></details>`;
  }
  return buf;
}
const commands = {
  randbats: "randombattles",
  randomdoublesbattle: "randombattles",
  randdubs: "randombattles",
  babyrandombattle: "randombattles",
  babyrands: "randombattles",
  // randombattlenodmax: 'randombattles',
  // randsnodmax: 'randombattles',
  randombattles(target, room, user, connection, cmd) {
    if (!this.runBroadcast())
      return;
    const battle = room?.battle;
    let isDoubles = cmd === "randomdoublesbattle" || cmd === "randdubs";
    let isBaby = cmd === "babyrandombattle" || cmd === "babyrands";
    let isNoDMax = cmd.includes("nodmax");
    if (battle) {
      if (battle.format.includes("nodmax"))
        isNoDMax = true;
      if (battle.format.includes("doubles") || battle.gameType === "freeforall")
        isDoubles = true;
      if (battle.format.includes("baby"))
        isBaby = true;
    }
    const args = target.split(",");
    if (!args[0])
      return this.parse(`/help randombattles`);
    const { dex } = this.splitFormat(target, true);
    const isLetsGo = dex.currentMod === "gen7letsgo";
    const searchResults = dex.dataSearch(args[0], ["Pokedex"]);
    if (!searchResults?.length) {
      this.errorReply(`No Pok\xE9mon named '${args[0]}' was found${Dex.gen > dex.gen ? ` in Gen ${dex.gen}` : ""}. (Check your spelling?)`);
      return;
    }
    let inexactMsg = "";
    if (searchResults[0].isInexact) {
      inexactMsg = `No Pok\xE9mon named '${args[0]}' was found${Dex.gen > dex.gen ? ` in Gen ${dex.gen}` : ""}. Searching for '${searchResults[0].name}' instead.`;
    }
    const species = dex.species.get(searchResults[0].name);
    const extraFormatModifier = isLetsGo ? "letsgo" : dex.currentMod === "gen8bdsp" ? "bdsp" : "";
    const babyModifier = isBaby ? "baby" : "";
    const doublesModifier = isDoubles ? "doubles" : "";
    const noDMaxModifier = isNoDMax ? "nodmax" : "";
    const formatName = `gen${dex.gen}${extraFormatModifier}${babyModifier}random${doublesModifier}battle${noDMaxModifier}`;
    const format = dex.formats.get(formatName);
    const movesets = [];
    let setCount = 0;
    if (dex.gen === 1) {
      const rbyMoves = getRBYMoves(species);
      if (!rbyMoves) {
        this.sendReply(inexactMsg);
        return this.errorReply(`Error: ${species.name} has no Random Battle data in ${GEN_NAMES[toID(args[1])]}`);
      }
      movesets.push(`<span style="color:#999999;">Moves for ${species.name} in ${format.name}:</span>${rbyMoves}`);
      setCount = 1;
    } else if (isLetsGo) {
      const lgpeMoves = getLetsGoMoves(species);
      if (!lgpeMoves) {
        this.sendReply(inexactMsg);
        return this.errorReply(`Error: ${species.name} has no Random Battle data in [Gen 7 Let's Go]`);
      }
      movesets.push(`<span style="color:#999999;">Moves for ${species.name} in ${format.name}:</span><br />${lgpeMoves}`);
      setCount = 1;
    } else {
      const setsToCheck = [species];
      if (dex.gen >= 8 && !isNoDMax)
        setsToCheck.push(dex.species.get(`${args[0]}gmax`));
      if (species.otherFormes)
        setsToCheck.push(...species.otherFormes.map((pkmn) => dex.species.get(pkmn)));
      if ([2, 3, 4, 5, 6, 7, 9].includes(dex.gen)) {
        for (const pokemon of setsToCheck) {
          const data = getSets(pokemon, format.id);
          if (!data)
            continue;
          const sets = data.sets;
          const level = data.level || getLevel(pokemon, format);
          let buf2 = `<span style="color:#999999;">Moves for ${pokemon.name} in ${format.name}:</span><br/>`;
          buf2 += `<b>Level</b>: ${level}`;
          for (const set of sets) {
            buf2 += `<details><summary>${set.role}</summary>`;
            if (dex.gen === 9) {
              buf2 += `<b>Tera Type${Chat.plural(set.teraTypes)}</b>: ${set.teraTypes.join(", ")}<br/>`;
            } else if ([2, 3, 4, 5, 6, 7].includes(dex.gen) && set.preferredTypes) {
              buf2 += `<b>Preferred Type${Chat.plural(set.preferredTypes)}</b>: ${set.preferredTypes.join(", ")}<br/>`;
            }
            buf2 += `<b>Moves</b>: ${set.movepool.sort().map(formatMove).join(", ")}<br/>`;
            if (set.abilities) {
              buf2 += `<b>Abilit${Chat.plural(set.abilities, "ies", "y")}</b>: ${set.abilities.sort().join(", ")}`;
            }
            buf2 += "</details>";
            setCount++;
          }
          movesets.push(buf2);
        }
      } else {
        for (let pokemon of setsToCheck) {
          let data = getData(pokemon, format.name);
          if (!data && isNoDMax) {
            pokemon = dex.species.get(pokemon.id + "gmax");
            data = getData(pokemon, format.name);
          }
          if (!data)
            continue;
          if (!data.moves || pokemon.isNonstandard === "Future")
            continue;
          let randomMoves = data.moves;
          const level = data.level || getLevel(pokemon, format);
          if (isDoubles && data.doublesMoves)
            randomMoves = data.doublesMoves;
          if (isNoDMax && data.noDynamaxMoves)
            randomMoves = data.noDynamaxMoves;
          const m = randomMoves.slice().sort().map(formatMove);
          movesets.push(
            `<details><summary><span style="color:#999999;">Moves for ${pokemon.name} in ${format.name}:<span style="color:#999999;"></summary>` + (level ? `<b>Level</b>: ${level}<br>` : "") + `${m.join(`, `)}</details>`
          );
          setCount++;
        }
      }
    }
    if (!movesets.length) {
      this.sendReply(inexactMsg);
      return this.errorReply(`Error: ${species.name} has no Random Battle data in ${format.name}`);
    }
    let buf = movesets.join("<hr/>");
    if (setCount <= 2) {
      buf = buf.replace(/<details>/g, "<details open>");
    }
    this.sendReply(inexactMsg);
    this.sendReplyBox(buf);
  },
  randombattleshelp: [
    `/randombattles OR /randbats [pokemon], [gen] - Displays a Pok\xE9mon's Random Battle Moves. Defaults to Gen 9. If used in a battle, defaults to the gen of that battle.`,
    `/randomdoublesbattle OR /randdubs [pokemon], [gen] - Same as above, but instead displays Random Doubles Battle moves.`
  ],
  bssfactory: "battlefactory",
  battlefactory(target, room, user, connection, cmd) {
    if (!this.runBroadcast())
      return;
    const isBSS = cmd === "bssfactory";
    if (isBSS) {
      const args = target.split(",");
      if (!args[0])
        return this.parse(`/help battlefactory`);
      const species = Dex.species.get(args[0]);
      if (!species.exists) {
        return this.errorReply(`Error: Pok\xE9mon '${args[0].trim()}' not found.`);
      }
      let mod = "gen9";
      if (args[1] && toID(args[1]) in Dex.dexes && Dex.dexes[toID(args[1])].gen >= 7)
        mod = toID(args[1]);
      const bssSets = battleFactorySets(species, null, mod, true);
      if (!bssSets)
        return this.parse(`/help battlefactory`);
      return this.sendReplyBox(bssSets);
    } else {
      const args = target.split(",");
      if (!args[0])
        return this.parse(`/help battlefactory`);
      const species = Dex.species.get(args[0]);
      if (!species.exists) {
        return this.errorReply(`Error: Pok\xE9mon '${args[0].trim()}' not found.`);
      }
      let tier = "";
      if (args[1] && toID(args[1]) in TIERS) {
        tier = TIERS[toID(args[1])];
      } else {
        tier = "ou";
      }
      const mod = args[2] || "gen9";
      let bfSets;
      if (species.name === "Necrozma-Ultra") {
        bfSets = battleFactorySets(Dex.species.get("necrozma-dawnwings"), tier, mod);
        if (bfSets) {
          bfSets += battleFactorySets(Dex.species.get("necrozma-duskmane"), tier, mod);
        }
      } else if (species.name === "Zygarde-Complete") {
        bfSets = battleFactorySets(Dex.species.get("zygarde"), tier, mod);
        if (bfSets) {
          bfSets += battleFactorySets(Dex.species.get("zygarde-10"), tier, mod);
        }
      } else {
        bfSets = battleFactorySets(species, tier, mod);
      }
      if (!bfSets)
        return this.parse(`/help battlefactory`);
      return this.sendReplyBox(bfSets);
    }
  },
  battlefactoryhelp: [
    `/battlefactory [pokemon], [tier], [gen] - Displays a Pok\xE9mon's Battle Factory sets. Supports Gens 6-8. Defaults to Gen 8. If no tier is provided, defaults to OU.`,
    `- Supported tiers: OU, Ubers, UU, RU, NU, PU, Monotype (Gen 7 only), LC (Gen 7 only)`,
    `/bssfactory [pokemon], [gen] - Displays a Pok\xE9mon's BSS Factory sets. Supports Gen 7-9. Defaults to Gen 9.`
  ],
  cap1v1(target, room, user) {
    if (!this.runBroadcast())
      return;
    if (!target)
      return this.parse(`/help cap1v1`);
    const species = Dex.species.get(target);
    if (!species.exists)
      return this.errorReply(`Error: Pok\xE9mon '${target.trim()}' not found.`);
    const cap1v1Set = CAP1v1Sets(species);
    if (!cap1v1Set)
      return this.parse(`/help cap1v1`);
    if (typeof cap1v1Set !== "string") {
      this.errorReply(`Error: ${cap1v1Set.e}`);
      if (cap1v1Set.parse)
        this.parse(cap1v1Set.parse);
      return;
    }
    return this.sendReplyBox(cap1v1Set);
  },
  cap1v1help: [
    `/cap1v1 [pokemon] - Displays a Pok\xE9mon's CAP 1v1 sets.`
  ],
  setodds: "randombattlesetprobabilities",
  randbatsodds: "randombattlesetprobabilities",
  randbatsprobabilities: "randombattlesetprobabilities",
  randombattlesetprobabilities(target, room, user) {
    const randbatsRoom = Rooms.get("randombattles");
    if (!randbatsRoom?.auth.has(user.id)) {
      this.checkCan("lock");
    }
    if (!target)
      return this.parse(`/help randombattlesetprobabilities`);
    this.runBroadcast();
    const args = target.split(",");
    if (args.length < 2)
      return this.parse(`/help randombattlesetprobabilities`);
    let format = Dex.formats.get("gen9randombattle");
    let formatOrSpecies = args.shift();
    const possibleFormat = Dex.formats.get(formatOrSpecies);
    if (possibleFormat.exists) {
      if (!possibleFormat.team) {
        throw new Chat.ErrorMessage(`${possibleFormat.name} does not have randomly-generated teams.`);
      }
      format = possibleFormat;
      formatOrSpecies = args.shift();
    }
    const dex = Dex.forFormat(format);
    const species = dex.species.get(formatOrSpecies);
    if (!species.exists) {
      throw new Chat.ErrorMessage(`Species ${species.name} does not exist in the specified format.`);
    }
    let setExists;
    if ([2, 3, 4, 5, 6, 7, 9].includes(dex.gen)) {
      setExists = !!getSets(species, format);
    } else {
      const data = getData(species, format);
      if (!data) {
        setExists = false;
      } else if (format.gameType === "doubles" || format.gameType === "freeforall") {
        setExists = !!data.doublesMoves;
      } else {
        setExists = !!data.moves;
      }
    }
    if (!setExists) {
      throw new Chat.ErrorMessage(`${species.name} does not have random battle moves in ${format.name}.`);
    }
    const criteria = {
      moves: { mustHave: [], mustNotHave: [] },
      item: { mustNotHave: [] },
      ability: { mustNotHave: [] },
      nature: { mustNotHave: [] },
      teraType: { mustNotHave: [] }
    };
    if (args.length < 1) {
      this.errorReply(`You must specify at least one condition.`);
      return this.parse(`/help randombattlesetprobabilities`);
    }
    for (const arg of args) {
      let [key, value] = arg.split("=");
      key = toID(key);
      if (!value || !key) {
        this.errorReply(`Invalid condition format: ${arg}`);
        return this.parse(`/help randombattlesetprobabilities`);
      }
      switch (key) {
        case "moves":
          for (const rawMove of value.split("&")) {
            const move = dex.moves.get(rawMove);
            if (!move.exists) {
              throw new Chat.ErrorMessage(`"${rawMove}" is not a move in the specified format.`);
            }
            const isNegation = rawMove.trim().startsWith("!");
            if (isNegation) {
              criteria.moves.mustNotHave.push(move);
            } else {
              criteria.moves.mustHave.push(move);
            }
          }
          break;
        case "item":
          const item = dex.items.get(value);
          if (!item.exists) {
            throw new Chat.ErrorMessage(`"${value}" is not an item in the specified format.`);
          }
          const itemNegation = value.trim().startsWith("!");
          if (itemNegation) {
            criteria.item.mustNotHave.push(item);
          } else {
            if (criteria.item.mustHave) {
              throw new Chat.ErrorMessage(`Impossible situation: two items (${criteria.item.mustHave.name} and ${item.name}) are required.`);
            }
            criteria.item.mustHave = item;
          }
          break;
        case "ability":
          const ability = dex.abilities.get(value);
          if (!ability.exists) {
            throw new Chat.ErrorMessage(`"${value}" is not an ability in the specified format.`);
          }
          const abilityNegation = value.trim().startsWith("!");
          if (abilityNegation) {
            criteria.ability.mustNotHave.push(ability);
          } else {
            if (criteria.ability.mustHave) {
              throw new Chat.ErrorMessage(`Impossible situation: two abilities (${criteria.ability.mustHave.name} and ${ability.name}) are required.`);
            }
            criteria.ability.mustHave = ability;
          }
          break;
        case "nature":
          const nature = dex.natures.get(value);
          if (!nature.exists) {
            throw new Chat.ErrorMessage(`"${value}" is not a nature in the specified format.`);
          }
          const natureNegation = value.trim().startsWith("!");
          if (natureNegation) {
            criteria.nature.mustNotHave.push(nature);
          } else {
            if (criteria.nature.mustHave) {
              throw new Chat.ErrorMessage(`Impossible situation: two natures (${criteria.nature.mustHave.name} and ${nature.name}) are required.`);
            }
            criteria.nature.mustHave = nature;
          }
          break;
        case "tera":
        case "teratype":
          if (dex.gen < 9)
            throw new Chat.ErrorMessage("Tera Types do not exist in the specified format.");
          const type = dex.types.get(value);
          if (!type.exists) {
            throw new Chat.ErrorMessage(`"${value}" is not a type in the specified format.`);
          }
          const typeNegation = value.trim().startsWith("!");
          if (typeNegation) {
            criteria.teraType.mustNotHave.push(type);
          } else {
            if (criteria.teraType.mustHave) {
              throw new Chat.ErrorMessage(`Impossible situation: two Tera Types (${criteria.teraType.mustHave.name} and ${type.name}) are required.`);
            }
            criteria.teraType.mustHave = type;
          }
          break;
        default:
          throw new Chat.ErrorMessage(`Invalid criterion: ${key}`);
      }
    }
    const results = setProbability(species, format, criteria);
    const percentage = Math.round(results.matches / results.rounds * 100);
    return this.sendReplyBox(
      import_lib.Utils.html`Generated ${results.rounds} sets for <strong>${species.name}</strong> in ${format.name}:<br />` + `Approximately <strong>${percentage}%</strong> (${results.matches} sets) ${getHTMLCriteriaDescription(criteria)}.`
    );
  },
  randombattlesetprobabilitieshelp() {
    return this.sendReplyBox(
      `<code>/randombattlesetprobabilities [optional format], [species], [conditions]</code>: Gives the probability of a set matching the conditions appearing for the given species.<br /><code>[conditions]</code> is a comma-separated list of conditions of the form <code>[component]=[matching value]</code>, where <code>[component]</code> can be any of the following: <ul><li><code>moves</code>: matches all generated sets that contain every move specified. <code>[matching value]</code> should be a list of moves separated with <code>&amp;</code>.<li><code>item</code>: matches all generated sets that have the specified item. <code>[matching value]</code> should be an item name.<li><code>ability</code>: matches all generated sets with the specified ability. <code>[matching value]</code> should be an ability name.<li><code>nature</code>: matches all generated sets with the specified nature. <code>[matching value]</code> should be a nature name.<li><code>tera</code>: matches all generated sets with the specified Tera Type. <code>[matching value]</code> should be a type. Gen 9 only.</ul>The given probability is for a set that matches EVERY provided condition. Conditions can be negated by prefixing the <code>[matching value]</code> with <code>!</code>.<br />Requires: % @ # ~ (globally or in the Random Battles room)`
    );
  },
  genteam: "generateteam",
  generateteam(target, room, user) {
    if (!Rooms.get("randombattles")?.auth.has(user.id))
      this.checkCan("lock");
    this.runBroadcast(true);
    if (!target)
      return this.parse("/help generateteam");
    const format = Dex.formats.get(target);
    if (format.effectType !== "Format")
      throw new Chat.ErrorMessage(`"${target}" is not a recognized format.`);
    if (!format.team)
      throw new Chat.ErrorMessage(`"${format.name}" requires you to bring your own team.`);
    const team = Teams.getGenerator(format).getTeam();
    const dex = Dex.forFormat(format);
    const teamHTML = team.map((set) => {
      set.moves = set.moves.map((m) => dex.moves.get(m).name);
      set.item = dex.items.get(set.item).name;
      return `<details><summary>${set.name}</summary>${import_lib.Utils.escapeHTML(Teams.exportSet(set))}<br /></details>`;
    }).join("");
    return this.sendReplyBox(`<strong>Team for ${format.name}</strong>:` + teamHTML);
  },
  generateteamhelp: [`/genteam [format] - Generates a team for the given format. Requires: % @ ~ or Random Battles room auth`]
};
//# sourceMappingURL=index.js.map