@yipe/dice 0.9.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 {
@@ -1566,7 +1709,7 @@ var _PMF = class _PMF {
     const id = this.identifier;
     let key = `${id}`;
     for (let i = 1; i < n; i++) key += `+${id}`;
-    return `${key}@${eps}`;
+    return `${key}@${eps}|${this.fingerprint()}`;
   }
   /**
    * Efficiently computes this PMF convolved with itself `n` times.
@@ -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();
@@ -1917,16 +2084,27 @@ var _PMF = class _PMF {
     return `v4:${raw ? "RAW" : "N"}:${id1}+${id2}@${eps}|${p1.fingerprint()}|${p2.fingerprint()}`;
   }
   /**
-   * A small content fingerprint (mass + bin count + face sum) so convolution
-   * cache keys change if the underlying numbers do. Memoized because a PMF is
-   * immutable once constructed — this avoids re-summing every key on each
-   * convolve() call (including cache hits).
+   * A content fingerprint of every bin (probability, per-label `count`, per-label `attr`) plus
+   * the `normalized` flag, so convolution/power cache keys change whenever the underlying
+   * numbers do. Mass/bin-count/face-sum alone are not content-unique: `mapDamage` variants can
+   * keep the same identifier, support, mass, and face sum while differing in per-bin
+   * probabilities or in the `count`/`attr` channels `convolve()`/`power()` actually propagate --
+   * that previously let `power()` return one PMF's cached result for a different PMF. Memoized
+   * because a PMF is immutable once constructed -- this avoids re-deriving the key on every
+   * convolve()/power() call (including cache hits). Bin order is sorted by damage value (and
+   * label keys sorted within each bin) so two equal-content PMFs built via different code paths
+   * fingerprint identically regardless of Map insertion order.
    */
   fingerprint() {
     if (this._fingerprint === void 0) {
-      let faceSum = 0;
-      for (const k of this.map.keys()) faceSum += k;
-      this._fingerprint = `${this.mass().toFixed(12)}|${this.map.size}|${faceSum}`;
+      const bins = [...this.map.entries()].sort((a, b) => a[0] - b[0]);
+      const parts = [];
+      for (const [damageValue, bin] of bins) {
+        const countStr = Object.keys(bin.count).sort().map((k) => `${k}:${bin.count[k]}`).join(",");
+        const attrStr = bin.attr ? Object.keys(bin.attr).sort().map((k) => `${k}:${bin.attr[k]}`).join(",") : "";
+        parts.push(`${damageValue}:${bin.p}[${countStr}]{${attrStr}}`);
+      }
+      this._fingerprint = `${this.normalized ? 1 : 0}|${parts.join(";")}`;
     }
     return this._fingerprint;
   }
@@ -2158,11 +2336,13 @@ var _PMF = class _PMF {
   /** Quantile / inverse CDF for p in [0,1]. Returns smallest x with CDF ≥ p. */
   quantile(p) {
     if (this.map.size === 0) return 0;
+    const totalMass = this.mass();
+    if (totalMass <= 0) return 0;
     const s = this.support().sort((a, b) => a - b);
     let acc = 0;
     for (const x of s) {
       acc += this.pAt(x);
-      if (acc >= p) return x;
+      if (acc / totalMass >= p) return x;
     }
     return s[s.length - 1];
   }
@@ -3023,6 +3203,12 @@ function combineDiceWithNormalization(dice, normValue, outcomeType, currentNorm,
   finalResult = finalResult.combine(dice);
   return { newNorm: currentNorm * normValue, updatedResult: finalResult };
 }
+function subtractCounts(a, b) {
+  const result = new Dice();
+  for (const [key, value] of a.getFaceEntries()) result.increment(key, value);
+  for (const [key, value] of b.getFaceEntries()) result.increment(key, -value);
+  return result;
+}
 function parseExpression(arr, n) {
   const result = (() => {
     const res = parseArgument(arr, n);
@@ -3030,8 +3216,29 @@ function parseExpression(arr, n) {
   })();
   let op = parseOperation(arr);
   let finalResult = result;
+  let baseDieMeta = result.privateData?.checkDie && !result.privateData.checkDie.rerollOne ? result.privateData.checkDie : void 0;
+  let bonusOnly = Dice.scalar(0);
   while (op != null) {
     const arg = !op.unary ? parseArgument(arr, n) : finalResult;
+    let acAlreadyApplied = false;
+    if (baseDieMeta) {
+      if (op === Dice.prototype.addNonZero) {
+        bonusOnly = bonusOnly.add(arg);
+      } else if (op === Dice.prototype.subtract) {
+        bonusOnly = bonusOnly.subtract(arg);
+      } else if (op === Dice.prototype.ac && typeof arg === "number") {
+        const natMaxSlice = bonusOnly.add(baseDieMeta.sides);
+        const restSlice = subtractCounts(finalResult, natMaxSlice);
+        const gatedNatMaxSlice = natMaxSlice.ac(arg);
+        finalResult = restSlice.ac(arg).combine(gatedNatMaxSlice);
+        finalResult.privateData.checkDie = baseDieMeta;
+        finalResult.privateData.natMaxCritSlice = gatedNatMaxSlice;
+        acAlreadyApplied = true;
+        baseDieMeta = void 0;
+      } else {
+        baseDieMeta = void 0;
+      }
+    }
     let crit;
     let critNorm = 1;
     if (arr[0] === "x" || arr[0] === "c") {
@@ -3042,11 +3249,17 @@ function parseExpression(arr, n) {
       assertToken(arr, "i");
       assertToken(arr, "t");
       const count = isXcrit ? parseNumber(arr, n) : 1;
-      crit = new Dice();
-      for (let i = 0; i < count; i++) {
-        const max = finalResult.maxFace();
-        crit.setFace(max, finalResult.get(max));
-        finalResult = finalResult.deleteFace(max);
+      const trackedCritSlice = finalResult.privateData?.natMaxCritSlice;
+      if (count === 1 && trackedCritSlice) {
+        crit = trackedCritSlice;
+        finalResult = subtractCounts(finalResult, trackedCritSlice);
+      } else {
+        crit = new Dice();
+        for (let i = 0; i < count; i++) {
+          const max = finalResult.maxFace();
+          crit.setFace(max, finalResult.get(max));
+          finalResult = finalResult.deleteFace(max);
+        }
       }
       critNorm = crit.total();
       crit = op.call(crit, parseBinaryArgument(arg, arr, n));
@@ -3097,7 +3310,9 @@ function parseExpression(arr, n) {
       missNorm = miss && missNorm ? miss.total() / missNorm : 1;
     }
     let norm = finalResult.total();
-    finalResult = op.call(finalResult, arg);
+    if (!acAlreadyApplied) {
+      finalResult = op.call(finalResult, arg);
+    }
     norm = norm ? finalResult.total() / norm : 1;
     if (crit) {
       const result2 = combineDiceWithNormalization(
@@ -3288,6 +3503,7 @@ function parseDice(s, n) {
   if (rerollOne) {
     result = result.reroll(1);
   }
+  result.privateData.checkDie = { sides, rerollOne };
   return result;
 }
 function peek(arr, expected) {
@@ -3575,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