@umang-boss/claudemon 2.1.3 → 2.2.0

package/dist/award-xp.mjs

@@ -75,6 +75,26 @@ import { constants as fsConst } from "node:fs";
 
 // src/engine/types.ts
 var MOOD_TYPES = ["happy", "worried", "sleepy", "energetic", "proud", "neutral"];
+var POKEMON_TYPES = [
+  "Normal",
+  "Fire",
+  "Water",
+  "Electric",
+  "Grass",
+  "Ice",
+  "Fighting",
+  "Poison",
+  "Ground",
+  "Flying",
+  "Psychic",
+  "Bug",
+  "Rock",
+  "Ghost",
+  "Dragon",
+  "Steel",
+  "Dark",
+  "Fairy"
+];
 var CODING_STATS = ["stamina", "debugging", "stability", "velocity", "wisdom"];
 var BADGE_TYPES = [
   "blaze",
@@ -16435,6 +16455,40 @@ function isBaseStage(pokemonId) {
   return !EVOLVED_IDS.has(pokemonId);
 }
 var WILD_RARITIES = /* @__PURE__ */ new Set(["common", "uncommon", "rare"]);
+var GEN_RANGES = [
+  { gen: 1, start: 1, end: 151 },
+  { gen: 2, start: 152, end: 251 },
+  { gen: 3, start: 252, end: 386 },
+  { gen: 4, start: 387, end: 493 },
+  { gen: 5, start: 494, end: 649 },
+  { gen: 6, start: 650, end: 721 },
+  { gen: 7, start: 722, end: 809 },
+  { gen: 8, start: 810, end: 905 }
+];
+function getGeneration(pokemonId) {
+  for (const { gen, start, end } of GEN_RANGES) {
+    if (pokemonId >= start && pokemonId <= end) return gen;
+  }
+  return 1;
+}
+function buildAllPool() {
+  const common = [];
+  const uncommon = [];
+  const rare = [];
+  for (const pokemon2 of POKEDEX) {
+    if (!isBaseStage(pokemon2.id)) continue;
+    if (!WILD_RARITIES.has(pokemon2.rarity)) continue;
+    const rarity = pokemon2.rarity;
+    if (rarity === "common") common.push(pokemon2.id);
+    else if (rarity === "uncommon") uncommon.push(pokemon2.id);
+    else rare.push(pokemon2.id);
+  }
+  return {
+    common: Object.freeze(common),
+    uncommon: Object.freeze(uncommon),
+    rare: Object.freeze(rare)
+  };
+}
 function buildTypePools() {
   const pools = /* @__PURE__ */ new Map();
   for (const pokemon2 of POKEDEX) {
@@ -16462,32 +16516,14 @@ function buildTypePools() {
   return frozen;
 }
 var TYPE_POOLS = buildTypePools();
+var ALL_WILD_POOL = buildAllPool();
 
 // src/engine/encounters.ts
-var ENCOUNTER_TYPE_MAP = {
-  commit: ["Normal", "Flying"],
-  test_pass: ["Fighting", "Normal"],
-  test_written: ["Fighting", "Normal"],
-  build_success: ["Fire", "Rock"],
-  bug_fix: ["Bug", "Poison"],
-  lint_fix: ["Bug", "Poison"],
-  file_create: ["Normal", "Ground"],
-  file_edit: ["Normal", "Ground"],
-  search: ["Flying", "Ground"],
-  large_refactor: ["Psychic", "Dragon"],
-  session_start: ["Grass", "Fairy"],
-  daily_streak: ["Water", "Electric"],
-  pet: ["Normal", "Fairy"]
-};
-function getEncounterTypes(eventType2) {
-  return ENCOUNTER_TYPE_MAP[eventType2];
-}
 function shouldTriggerEncounter(ctx) {
   const threshold = ENCOUNTER_THRESHOLDS[ctx.encounterSpeed];
   const streakMultiplier = ctx.currentStreak >= 7 ? 0.5 : 1;
   const effectiveThreshold = Math.floor(threshold * streakMultiplier);
-  if (ctx.xpSinceLastEncounter < effectiveThreshold) return false;
-  return true;
+  return ctx.xpSinceLastEncounter >= effectiveThreshold;
 }
 function shouldBonusEncounter() {
   return Math.random() < 0.1;
@@ -16496,13 +16532,6 @@ function shouldDiversityBonus(recentToolTypes2) {
   const uniqueTypes = new Set(recentToolTypes2);
   return uniqueTypes.size >= 3;
 }
-function getTimeOfDayBias(hour) {
-  if (hour >= 22 || hour < 5) return ["Ghost", "Dark"];
-  if (hour >= 5 && hour < 9) return ["Grass", "Fairy"];
-  if (hour >= 12 && hour < 14) return ["Fire", "Steel"];
-  if (hour >= 17 && hour < 20) return ["Water", "Flying"];
-  return [];
-}
 var RARITY_WEIGHTS = {
   common: 70,
   uncommon: 25,
@@ -16557,30 +16586,81 @@ function getCatchCondition(pokemonId) {
   const requiredStat = TYPE_TO_STAT[primaryType];
   return { requiredStat, minStatValue, requiredLevel };
 }
-function buildCandidatePool(types, state2) {
+function getTypeCounts(state2) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const t of POKEMON_TYPES) counts.set(t, 0);
+  for (const [idStr, entry] of Object.entries(state2.pokedex.entries)) {
+    if (!entry.caught) continue;
+    const pokemon2 = POKEMON_BY_ID.get(Number(idStr));
+    if (!pokemon2) continue;
+    for (const t of pokemon2.types) {
+      if (t !== void 0) counts.set(t, (counts.get(t) ?? 0) + 1);
+    }
+  }
+  return counts;
+}
+function getGenCounts(state2) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const { gen } of GEN_RANGES) counts.set(gen, 0);
+  for (const [idStr, entry] of Object.entries(state2.pokedex.entries)) {
+    if (!entry.caught) continue;
+    const gen = getGeneration(Number(idStr));
+    counts.set(gen, (counts.get(gen) ?? 0) + 1);
+  }
+  return counts;
+}
+function buildSmartPool(state2) {
   const candidates = [];
-  const seen = /* @__PURE__ */ new Set();
   const starterPokemon = [...state2.party, ...state2.pcBox].find((p) => p.isStarter);
   const starterPokemonId = starterPokemon?.pokemonId ?? -1;
   const caughtIds = /* @__PURE__ */ new Set();
+  const seenIds = /* @__PURE__ */ new Set();
   for (const [idStr, entry] of Object.entries(state2.pokedex.entries)) {
-    if (entry.caught) {
-      caughtIds.add(Number(idStr));
-    }
+    const id = Number(idStr);
+    if (entry.caught) caughtIds.add(id);
+    if (entry.seen) seenIds.add(id);
   }
-  for (const pokemonType of types) {
-    const pool = TYPE_POOLS.get(pokemonType);
-    if (!pool) continue;
-    for (const rarity of ["common", "uncommon", "rare"]) {
-      const ids = pool[rarity];
-      const weight = RARITY_WEIGHTS[rarity];
-      for (const id of ids) {
-        if (seen.has(id)) continue;
-        seen.add(id);
-        if (id === starterPokemonId) continue;
-        if (rarity !== "common" && caughtIds.has(id)) continue;
-        candidates.push({ id, weight });
+  const totalCaught = state2.pokedex.totalCaught ?? 0;
+  const isEarlyGame = totalCaught < 50;
+  const seed = Math.floor(Date.now() / 1e3);
+  const sameAgainRoll = seededRandom(seed + 99);
+  const applyDiversity = sameAgainRoll >= 0.1;
+  let typeCounts = null;
+  let genCounts = null;
+  if (applyDiversity) {
+    typeCounts = getTypeCounts(state2);
+    genCounts = getGenCounts(state2);
+  }
+  for (const rarity of ["common", "uncommon", "rare"]) {
+    const ids = ALL_WILD_POOL[rarity];
+    const baseWeight = RARITY_WEIGHTS[rarity];
+    for (const id of ids) {
+      if (id === starterPokemonId) continue;
+      if (rarity !== "common" && caughtIds.has(id)) continue;
+      let weight = baseWeight;
+      if (applyDiversity) {
+        const pokemon2 = POKEMON_BY_ID.get(id);
+        if (pokemon2) {
+          if (!seenIds.has(id)) {
+            weight *= isEarlyGame ? 4 : 2;
+          }
+          const primaryType = pokemon2.types[0];
+          const typeCount = typeCounts.get(primaryType) ?? 0;
+          if (typeCount === 0) {
+            weight *= 3;
+          } else if (typeCount < 3) {
+            weight *= 1.5;
+          }
+          const gen = getGeneration(id);
+          const genCount = genCounts.get(gen) ?? 0;
+          if (genCount === 0) {
+            weight *= 2;
+          } else if (genCount < 3) {
+            weight *= 1.3;
+          }
+        }
       }
+      candidates.push({ id, weight: Math.round(weight) });
     }
   }
   return candidates;
@@ -16612,16 +16692,8 @@ function determineEncounterLevel(state2, seed) {
   const level = minLevel + Math.floor(seededRandom(seed + 7) * range);
   return Math.min(level, 100);
 }
-function generateEncounter(eventType2, state2, timeOfDayTypes2) {
-  let types = getEncounterTypes(eventType2);
-  if (timeOfDayTypes2 && timeOfDayTypes2.length > 0) {
-    const seed2 = Math.floor(Date.now() / 1e3);
-    const biasRoll = seededRandom(seed2 + 42);
-    if (biasRoll < 0.4) {
-      types = timeOfDayTypes2;
-    }
-  }
-  const candidates = buildCandidatePool(types, state2);
+function generateEncounter(_eventType, state2, _timeOfDayTypes) {
+  const candidates = buildSmartPool(state2);
   if (candidates.length === 0) return null;
   const seed = Math.floor(Date.now() / 1e3);
   const pokemonId = weightedSelect(candidates, seed);
@@ -16759,7 +16831,6 @@ for (const badge of newBadges) {
 var evolutionReady = checkEvolution(pokemon, state) !== null;
 var encounterSpeed = state.config.encounterSpeed ?? "normal";
 var currentHour = (/* @__PURE__ */ new Date()).getHours();
-var timeOfDayTypes = getTimeOfDayBias(currentHour);
 var encounterCtx = {
   xpSinceLastEncounter: (state.xpSinceLastEncounter ?? 0) + xpEvent.xp,
   encounterSpeed,
@@ -16770,14 +16841,14 @@ var encounterCtx = {
 state.xpSinceLastEncounter = encounterCtx.xpSinceLastEncounter;
 var encounterTriggered = false;
 if (shouldTriggerEncounter(encounterCtx) && !state.pendingEncounter) {
-  const encounter = generateEncounter(eventType, state, timeOfDayTypes);
+  const encounter = generateEncounter(eventType, state);
   if (encounter) {
     state.pendingEncounter = encounter;
     state.xpSinceLastEncounter = 0;
     state.lastEncounterTime = Date.now();
     encounterTriggered = true;
     if (shouldBonusEncounter()) {
-      const bonusEncounter = generateEncounter(eventType, state, timeOfDayTypes);
+      const bonusEncounter = generateEncounter(eventType, state);
       if (bonusEncounter) {
         state.pendingEncounter = bonusEncounter;
       }
@@ -16785,7 +16856,7 @@ if (shouldTriggerEncounter(encounterCtx) && !state.pendingEncounter) {
   }
 }
 if (!encounterTriggered && !state.pendingEncounter && shouldDiversityBonus(state.recentToolTypes)) {
-  const diversityEncounter = generateEncounter(eventType, state, timeOfDayTypes);
+  const diversityEncounter = generateEncounter(eventType, state);
   if (diversityEncounter) {
     state.pendingEncounter = diversityEncounter;
     state.xpSinceLastEncounter = 0;