@pkmn/randoms 0.9.5 → 0.9.7

package/build/index.mjs

@@ -43,14 +43,16 @@ function sortBy(array, callback) {
   return array.sort((a, b) => compare(callback(a), callback(b)));
 }
 var Multiset = class extends Map {
-  add(key) {
+  get(key) {
     var _a;
-    this.set(key, ((_a = this.get(key)) != null ? _a : 0) + 1);
+    return (_a = super.get(key)) != null ? _a : 0;
+  }
+  add(key) {
+    this.set(key, this.get(key) + 1);
     return this;
   }
   remove(key) {
-    var _a;
-    const newValue = ((_a = this.get(key)) != null ? _a : 0) - 1;
+    const newValue = this.get(key) - 1;
     if (newValue <= 0)
       return this.delete(key);
     this.set(key, newValue);
@@ -72,9 +74,6 @@ var MoveCounter = class extends Utils.Multiset {
     this.damagingMoves = /* @__PURE__ */ new Set();
     this.setupType = "";
   }
-  get(key) {
-    return super.get(key) || 0;
-  }
 };
 var RECOVERY_MOVES = [
   "healorder",
@@ -10452,9 +10451,6 @@ var MoveCounter2 = class extends Utils.Multiset {
     this.damagingMoves = /* @__PURE__ */ new Set();
     this.ironFist = 0;
   }
-  get(key) {
-    return super.get(key) || 0;
-  }
 };
 var RECOVERY_MOVES8 = [
   "healorder",
@@ -10671,6 +10667,7 @@ var RandomTeams = class {
   constructor(dex, format, prng) {
     this.randomSets = randomSetsJSON7;
     this.randomDoublesSets = randomDoublesSetsJSON;
+    this.randomBSSFactorySets = {};
     this.dex = dex;
     this.gen = this.dex.gen;
     this.noStab = NO_STAB8;
@@ -13017,6 +13014,239 @@ var RandomTeams = class {
     }
     return team;
   }
+  randomBSSFactorySet(species, teamData) {
+    var _a;
+    const id = toID5(species.name);
+    const setList = this.randomBSSFactorySets[id].sets;
+    const movesMax = {
+      batonpass: 1,
+      stealthrock: 1,
+      toxicspikes: 1,
+      trickroom: 1,
+      auroraveil: 1
+    };
+    const weatherAbilities = ["drizzle", "drought", "snowwarning", "sandstream"];
+    const terrainAbilities = {
+      electricsurge: "electric",
+      psychicsurge: "psychic",
+      grassysurge: "grassy",
+      seedsower: "grassy",
+      mistysurge: "misty"
+    };
+    const terrainItemsRequire = {
+      electricseed: "electric",
+      psychicseed: "psychic",
+      grassyseed: "grassy",
+      mistyseed: "misty"
+    };
+    const maxWantsTera = 2;
+    const effectivePool = [];
+    for (const curSet of setList) {
+      let reject = false;
+      if (curSet.wantsTera && teamData.wantsTeraCount && teamData.wantsTeraCount >= maxWantsTera) {
+        continue;
+      }
+      if (teamData.weather && weatherAbilities.includes(curSet.ability)) {
+        continue;
+      }
+      if (terrainAbilities[curSet.ability]) {
+        if (!teamData.terrain)
+          teamData.terrain = [];
+        teamData.terrain.push(terrainAbilities[curSet.ability]);
+      }
+      for (const item of curSet.item) {
+        if (terrainItemsRequire[item] && !((_a = teamData.terrain) == null ? void 0 : _a.includes(terrainItemsRequire[item]))) {
+          reject = true;
+          break;
+        }
+      }
+      const curSetMoveVariants = [];
+      for (const move of curSet.moves) {
+        const variantIndex = this.random(move.length);
+        const moveId = toID5(move[variantIndex]);
+        if (movesMax[moveId] && teamData.has[moveId] >= movesMax[moveId]) {
+          reject = true;
+          break;
+        }
+        curSetMoveVariants.push(variantIndex);
+      }
+      if (reject)
+        continue;
+      const set = { set: curSet, moveVariants: curSetMoveVariants };
+      effectivePool.push(set);
+    }
+    if (!effectivePool.length) {
+      if (!teamData.forceResult)
+        return null;
+      for (const curSet of setList) {
+        effectivePool.push({ set: curSet });
+      }
+    }
+    let setData = this.sample(effectivePool);
+    const total = effectivePool.reduce((a, b) => a + b.set.weight, 0);
+    const setRand = this.random(total);
+    let cur = 0;
+    for (const set of effectivePool) {
+      cur += set.set.weight;
+      if (cur > setRand) {
+        setData = set;
+        break;
+      }
+    }
+    const moves = [];
+    for (const [i, moveSlot] of setData.set.moves.entries()) {
+      moves.push(setData.moveVariants ? moveSlot[setData.moveVariants[i]] : this.sample(moveSlot));
+    }
+    return {
+      name: setData.set.species || species.baseSpecies,
+      species: setData.set.species,
+      teraType: this.sampleIfArray(setData.set.teraType),
+      gender: setData.set.gender || species.gender || (this.randomChance(1, 2) ? "M" : "F"),
+      item: this.sampleIfArray(setData.set.item) || "",
+      ability: this.sampleIfArray(setData.set.ability),
+      shiny: this.randomChance(1, 1024),
+      level: 50,
+      happiness: 255,
+      evs: { hp: 0, atk: 0, def: 0, spa: 0, spd: 0, spe: 0, ...setData.set.evs },
+      ivs: { hp: 31, atk: 31, def: 31, spa: 31, spd: 31, spe: 31, ...setData.set.ivs },
+      nature: setData.set.nature || "Serious",
+      moves,
+      wantsTera: setData.set.wantsTera
+    };
+  }
+  randomBSSFactoryTeam(side, depth = 0) {
+    var _a;
+    this.enforceNoDirectCustomBanlistChanges();
+    const forceResult = depth >= 4;
+    const pokemon = [];
+    const pokemonPool = Object.keys(this.randomBSSFactorySets);
+    const teamData = {
+      typeCount: {},
+      typeComboCount: {},
+      baseFormes: {},
+      has: {},
+      wantsTeraCount: 0,
+      forceResult,
+      weaknesses: {},
+      resistances: {}
+    };
+    const weatherAbilitiesSet = {
+      drizzle: "raindance",
+      drought: "sunnyday",
+      snowwarning: "hail",
+      sandstream: "sandstorm"
+    };
+    const resistanceAbilities = {
+      waterabsorb: ["Water"],
+      flashfire: ["Fire"],
+      lightningrod: ["Electric"],
+      voltabsorb: ["Electric"],
+      thickfat: ["Ice", "Fire"],
+      levitate: ["Ground"]
+    };
+    const limitFactor = Math.ceil(this.maxTeamSize / 6);
+    const shuffledSpecies = [];
+    for (const speciesName of pokemonPool) {
+      const sortObject = {
+        speciesName,
+        score: Math.pow(this.prng.next(), 1 / this.randomBSSFactorySets[speciesName].weight)
+      };
+      shuffledSpecies.push(sortObject);
+    }
+    shuffledSpecies.sort((a, b) => a.score - b.score);
+    while (shuffledSpecies.length && pokemon.length < this.maxTeamSize) {
+      const species = this.dex.species.get(shuffledSpecies.pop().speciesName);
+      if (!species.exists)
+        continue;
+      if (this.forceMonotype && !species.types.includes(this.forceMonotype))
+        continue;
+      if (teamData.baseFormes[species.baseSpecies])
+        continue;
+      const types = species.types;
+      let skip = false;
+      if (!this.forceMonotype) {
+        for (const type of types) {
+          if (teamData.typeCount[type] >= 2 * limitFactor && this.randomChance(4, 5)) {
+            skip = true;
+            break;
+          }
+        }
+      }
+      if (skip)
+        continue;
+      const set = this.randomBSSFactorySet(species, teamData);
+      if (!set)
+        continue;
+      let typeCombo = types.slice().sort().join();
+      if (set.ability === "Drought" || set.ability === "Drizzle") {
+        typeCombo = set.ability;
+      }
+      if (!this.forceMonotype && teamData.typeComboCount[typeCombo] >= limitFactor)
+        continue;
+      const itemData = this.dex.items.get(set.item);
+      if (teamData.has[itemData.id])
+        continue;
+      pokemon.push(set);
+      for (const type of types) {
+        if (type in teamData.typeCount) {
+          teamData.typeCount[type]++;
+        } else {
+          teamData.typeCount[type] = 1;
+        }
+      }
+      if (typeCombo in teamData.typeComboCount) {
+        teamData.typeComboCount[typeCombo]++;
+      } else {
+        teamData.typeComboCount[typeCombo] = 1;
+      }
+      teamData.baseFormes[species.baseSpecies] = 1;
+      teamData.has[itemData.id] = 1;
+      if (set.wantsTera) {
+        if (!teamData.wantsTeraCount)
+          teamData.wantsTeraCount = 0;
+        teamData.wantsTeraCount++;
+      }
+      const abilityState = this.dex.abilities.get(set.ability);
+      if (abilityState.id in weatherAbilitiesSet) {
+        teamData.weather = weatherAbilitiesSet[abilityState.id];
+      }
+      for (const move of set.moves) {
+        const moveId = toID5(move);
+        if (moveId in teamData.has) {
+          teamData.has[moveId]++;
+        } else {
+          teamData.has[moveId] = 1;
+        }
+      }
+      for (const typeName of this.dex.types.names()) {
+        if (teamData.resistances[typeName] >= 1)
+          continue;
+        if (((_a = resistanceAbilities[abilityState.id]) == null ? void 0 : _a.includes(typeName)) || !this.dex.getImmunity(typeName, types)) {
+          teamData.resistances[typeName] = (teamData.resistances[typeName] || 0) + 1;
+          if (teamData.resistances[typeName] >= 1)
+            teamData.weaknesses[typeName] = 0;
+          continue;
+        }
+        const typeMod = this.dex.getEffectiveness(typeName, types);
+        if (typeMod < 0) {
+          teamData.resistances[typeName] = (teamData.resistances[typeName] || 0) + 1;
+          if (teamData.resistances[typeName] >= 1)
+            teamData.weaknesses[typeName] = 0;
+        } else if (typeMod > 0) {
+          teamData.weaknesses[typeName] = (teamData.weaknesses[typeName] || 0) + 1;
+        }
+      }
+    }
+    if (!teamData.forceResult && pokemon.length < this.maxTeamSize)
+      return this.randomBSSFactoryTeam(side, ++depth);
+    if (!teamData.forceResult && !this.forceMonotype) {
+      for (const type in teamData.weaknesses) {
+        if (teamData.weaknesses[type] >= 3 * limitFactor)
+          return this.randomBSSFactoryTeam(side, ++depth);
+      }
+    }
+    return pokemon;
+  }
 };
 
 // src/index.ts