@yipe/dice 0.10.0 → 0.11.0

package/dist/index.js

@@ -1,4 +1,25 @@
 // src/common/bounce.ts
+function faceWeights(faces, minimum = 0, reroll = 0) {
+  const f = Math.max(0, Math.floor(faces));
+  if (f <= 0) return [];
+  let weights = new Array(f).fill(1 / f);
+  const r = Math.max(0, Math.min(Math.floor(reroll), f));
+  if (r > 0) {
+    const rerollMass = r / f;
+    const uniformReroll = rerollMass / f;
+    weights = weights.map((_, i) => (i < r ? 0 : 1 / f) + uniformReroll);
+  }
+  const minV = Math.max(0, Math.floor(minimum));
+  if (minV > 1) {
+    const collapsed = new Array(f).fill(0);
+    for (let v = 1; v <= f; v++) {
+      const target = Math.min(f, Math.max(v, minV));
+      collapsed[target - 1] += weights[v - 1];
+    }
+    weights = collapsed;
+  }
+  return weights;
+}
 function binom(n, k) {
   if (k < 0 || k > n) return 0;
   let result = 1;
@@ -47,6 +68,128 @@ function calculateBounceOdds(diceCount, dieFaces, options) {
   );
   return Math.min(1, pMatchFirst + pNoMatchFirst * pMatchAfterReroll);
 }
+function diceSumDistribution(dice, weights) {
+  let dist = /* @__PURE__ */ new Map([[0, 1]]);
+  for (let die = 0; die < dice; die++) {
+    const next = /* @__PURE__ */ new Map();
+    for (const [sum, mass] of dist) {
+      for (let face = 1; face <= weights.length; face++) {
+        const w = weights[face - 1] ?? 0;
+        if (w <= 0) continue;
+        const s = sum + face;
+        next.set(s, (next.get(s) ?? 0) + mass * w);
+      }
+    }
+    dist = next;
+  }
+  return dist;
+}
+function sumAllDistinctDistribution(dice, weights) {
+  const faceCount = weights.length;
+  let dp = /* @__PURE__ */ new Map([[0, /* @__PURE__ */ new Map([[0, 1]])]]);
+  for (let face = 1; face <= faceCount; face++) {
+    const w = weights[face - 1] ?? 0;
+    const next = /* @__PURE__ */ new Map();
+    for (const [count, sumMap] of dp) next.set(count, new Map(sumMap));
+    if (w > 0) {
+      for (const [count, sumMap] of dp) {
+        const nextCount = count + 1;
+        if (nextCount > dice) continue;
+        const target = next.get(nextCount) ?? /* @__PURE__ */ new Map();
+        for (const [sum, mass] of sumMap) {
+          const s = sum + face;
+          target.set(s, (target.get(s) ?? 0) + mass * w);
+        }
+        next.set(nextCount, target);
+      }
+    }
+    dp = next;
+  }
+  let factorial = 1;
+  for (let i = 2; i <= dice; i++) factorial *= i;
+  const chosen = dp.get(dice) ?? /* @__PURE__ */ new Map();
+  const result = /* @__PURE__ */ new Map();
+  for (const [sum, mass] of chosen) result.set(sum, mass * factorial);
+  return result;
+}
+function jointSumAndMatch(dice, weights) {
+  if (dice <= 1) return /* @__PURE__ */ new Map();
+  const total = diceSumDistribution(dice, weights);
+  const distinct = sumAllDistinctDistribution(dice, weights);
+  const result = /* @__PURE__ */ new Map();
+  for (const [sum, mass] of total) {
+    const matchMass = Math.max(0, mass - (distinct.get(sum) ?? 0));
+    if (matchMass > 0) result.set(sum, matchMass);
+  }
+  return result;
+}
+function explodingPoolMkDistribution(pMax, count, budget) {
+  const binomial = (n, p) => {
+    const result = new Array(n + 1).fill(0);
+    result[0] = 1;
+    for (let trial = 0; trial < n; trial++) {
+      const next = new Array(n + 1).fill(0);
+      for (let successes = 0; successes <= trial; successes++) {
+        const mass = result[successes];
+        if (mass <= 0) continue;
+        next[successes] += mass * (1 - p);
+        next[successes + 1] += mass * p;
+      }
+      for (let i = 0; i <= n; i++) result[i] = next[i];
+    }
+    return result;
+  };
+  const memo = /* @__PURE__ */ new Map();
+  const f = (pending, remainingBudget) => {
+    if (pending === 0) return /* @__PURE__ */ new Map([["0,0", 1]]);
+    if (remainingBudget === 0) {
+      const binom2 = binomial(pending, pMax);
+      const result2 = /* @__PURE__ */ new Map();
+      for (let m = 0; m <= pending; m++) {
+        const mass = binom2[m];
+        if (mass > 0) result2.set(`${m},${pending - m}`, mass);
+      }
+      return result2;
+    }
+    const key = `${pending},${remainingBudget}`;
+    const cached = memo.get(key);
+    if (cached) return cached;
+    const result = /* @__PURE__ */ new Map();
+    const accumulate = (mk, mass) => {
+      result.set(mk, (result.get(mk) ?? 0) + mass);
+    };
+    for (const [mk, mass] of f(pending, remainingBudget - 1)) {
+      const [m, k] = mk.split(",").map(Number);
+      accumulate(`${m + 1},${k}`, mass * pMax);
+    }
+    for (const [mk, mass] of f(pending - 1, remainingBudget)) {
+      const [m, k] = mk.split(",").map(Number);
+      accumulate(`${m},${k + 1}`, mass * (1 - pMax));
+    }
+    memo.set(key, result);
+    return result;
+  };
+  return f(count, budget);
+}
+function explodingPoolMatchProbability(pMax, faces, count, budget) {
+  if (count <= 1) return 0;
+  const mkDistribution = explodingPoolMkDistribution(pMax, count, budget);
+  const nonMaxFaces = Math.max(1, faces - 1);
+  let pMatchTotal = 0;
+  for (const [mk, weight] of mkDistribution) {
+    const [m, k] = mk.split(",").map(Number);
+    if (m >= 2) {
+      pMatchTotal += weight;
+      continue;
+    }
+    let pAllDistinctAmongNonMax = 1;
+    for (let i = 0; i < k; i++) {
+      pAllDistinctAmongNonMax *= (nonMaxFaces - i) / nonMaxFaces;
+    }
+    pMatchTotal += weight * (1 - Math.max(0, pAllDistinctAmongNonMax));
+  }
+  return Math.min(1, Math.max(0, pMatchTotal));
+}
 
 // src/common/errors.ts
 var DiceParseError = class _DiceParseError extends Error {
@@ -1878,6 +2021,30 @@ var _PMF = class _PMF {
       `freq(${this.identifier},${freq})`
     );
   }
+  /**
+   * Splits this PMF into two complementary PMFs by an arbitrary per-damage-value factor in
+   * `[0, 1]` — bin `d`'s mass, `count`, and `attr` split `factor(d)` / `1 - factor(d)` between the
+   * two results (via the same proportional scaling {@link applyHitFrequency} uses, `scaleBin`), so
+   * `a.add(b)` recovers this PMF exactly and both halves stay chart-attributable. Unlike
+   * {@link applyHitFrequency}, mass is NOT redistributed to a miss bin at 0 — each bin stays at its
+   * own damage value in whichever half it lands in. `factor` outside `[0, 1]` is clamped.
+   *
+   * Built for `dice-match` trigger slicing: splitting a hit/crit sub-PMF into "matched" and
+   * "did not match" halves by the exact per-damage-value match probability.
+   */
+  splitByFactor(factor) {
+    const a = /* @__PURE__ */ new Map();
+    const b = /* @__PURE__ */ new Map();
+    for (const [damage, bin] of this.map) {
+      const f = Math.min(1, Math.max(0, factor(damage)));
+      if (f > 0) a.set(damage, _PMF.scaleBin(bin, f));
+      if (f < 1) b.set(damage, _PMF.scaleBin(bin, 1 - f));
+    }
+    return [
+      new _PMF(a, this.epsilon, false, `split+(${this.identifier})`),
+      new _PMF(b, this.epsilon, false, `split-(${this.identifier})`)
+    ];
+  }
   scaleMass(factor) {
     if (factor === 1) return this;
     const scaledMap = /* @__PURE__ */ new Map();
@@ -3624,6 +3791,6 @@ var Mixture = class _Mixture {
   }
 };
 
-export { ALL_OUTCOME_TYPES, DiceParseError, DiceQuery, EPS, LRUCache, MISS_NONE_OUTCOME, Mixture, OUTCOME_DISPLAY_ORDER, PMF, calculateBounceOdds, clearParserCache, critProbability, getCachingEnabled, onAnyHit, onCritOnly, onHitOnly, onMissDamageOnly, onMissOnly, onPotentCantripOnly, onSaveFailOnly, onSaveHalfOnly, parse, pmfCache, setCachingEnabled, sortOutcomes, tryParse, withRollType };
+export { ALL_OUTCOME_TYPES, DiceParseError, DiceQuery, EPS, LRUCache, MISS_NONE_OUTCOME, Mixture, OUTCOME_DISPLAY_ORDER, PMF, calculateBounceOdds, clearParserCache, critProbability, diceSumDistribution, explodingPoolMatchProbability, faceWeights, getCachingEnabled, jointSumAndMatch, onAnyHit, onCritOnly, onHitOnly, onMissDamageOnly, onMissOnly, onPotentCantripOnly, onSaveFailOnly, onSaveHalfOnly, parse, pmfCache, setCachingEnabled, sortOutcomes, tryParse, withRollType };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map