@yipe/dice 0.2.11 → 0.2.13

package/dist/builder/index.cjs

@@ -2659,6 +2659,14 @@ var RollBuilder = class _RollBuilder {
     const scaleInt = Math.floor(scale);
     if (scaleInt !== scale) throw new Error("Scale must be an integer");
     if (scaleInt <= 0) throw new Error("Scale must be > 0");
+    if (scaleInt > 1) {
+      const configs = this.getSubRollConfigs();
+      if (configs.length === 1 && configs[0].keep && configs[0].count === 1) {
+        const config = configs[0];
+        const newConfig = { ...config, count: scaleInt };
+        return new _RollBuilder([newConfig]);
+      }
+    }
     const newConfigs = this.getSubRollConfigs().map((config) => {
       if (!config.sides || config.sides <= 0) return config;
       return { ...config, count: config.count * scaleInt };
@@ -2878,6 +2886,10 @@ var RollBuilder = class _RollBuilder {
   half() {
     return new HalfRollBuilder(this);
   }
+  // Create a "max of N rolls" version of this roll for crit damage with keep operations
+  maxOf(count) {
+    return new MaxOfRollBuilder(this, count);
+  }
 };
 var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
   constructor(innerRoll) {
@@ -2907,6 +2919,78 @@ var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
     return new _HalfRollBuilder(this.innerRoll.copy());
   }
 };
+var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
+  constructor(innerRoll, count, diceCount, diceSides) {
+    super(0);
+    this.innerRoll = innerRoll;
+    this.count = count;
+    this.diceCount = diceCount;
+    this.diceSides = diceSides;
+  }
+  get lastConfig() {
+    return this.innerRoll.lastConfig;
+  }
+  getSubRollConfigs() {
+    return this.innerRoll.getSubRollConfigs();
+  }
+  toExpression() {
+    if (this.diceCount && this.diceSides) {
+      return `max${this.count}(${this.diceCount}d${this.diceSides})`;
+    }
+    return `max${this.count}(?d?)`;
+  }
+  findDieInAST(node) {
+    if (node.type === "die") return node;
+    if (node.child) return this.findDieInAST(node.child);
+    if (node.children) {
+      for (const child of node.children) {
+        const result = this.findDieInAST(child.node || child);
+        if (result) return result;
+      }
+    }
+    return null;
+  }
+  toAST() {
+    if (this.diceCount && this.diceSides) {
+      const sumChild = {
+        type: "sum",
+        count: this.diceCount,
+        child: { type: "die", sides: this.diceSides }
+      };
+      return {
+        type: "maxOf",
+        count: this.count,
+        child: sumChild
+      };
+    }
+    try {
+      const configs = this.innerRoll.getSubRollConfigs();
+      if (configs.length === 1 && configs[0].sides) {
+        const config = configs[0];
+        const sumChild = {
+          type: "sum",
+          count: config.count,
+          child: { type: "die", sides: config.sides }
+        };
+        return {
+          type: "maxOf",
+          count: this.count,
+          child: sumChild
+        };
+      }
+    } catch (e) {
+    }
+    throw new Error(
+      `MaxOfRollBuilder.toAST(): Unsupported innerRoll configuration`
+    );
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  copy() {
+    return new _MaxOfRollBuilder(this.innerRoll.copy(), this.count);
+  }
+};
 
 // src/builder/factory.ts
 var rollFn = (count, sidesOrDie, modifier) => {
@@ -2995,13 +3079,50 @@ function astFromRollConfigs(configs) {
       appliedRollType = true;
     }
     if (cfg.rollType === "flat" && cfg.keep && cfg.keep.total > 0) {
-      const base = { type: "sum", count: cfg.keep.total, child: node };
-      node = {
-        type: "keep",
-        mode: cfg.keep.mode,
-        count: cfg.keep.count,
-        child: base
-      };
+      const baseCount = Math.max(1, Math.floor(Math.abs(count || 1)));
+      const trials = Math.max(1, Math.floor(cfg.keep.total));
+      const k = Math.max(0, Math.floor(cfg.keep.count));
+      if (k === 1 && cfg.keep.mode === "highest") {
+        const perTrial = {
+          type: "sum",
+          count: baseCount,
+          child: node
+        };
+        if (trials === 1) {
+          node = perTrial;
+        } else {
+          node = { type: "maxOf", count: trials, child: perTrial };
+        }
+      } else if (trials === baseCount) {
+        const base = { type: "sum", count: trials, child: node };
+        node = {
+          type: "keep",
+          mode: cfg.keep.mode,
+          count: k,
+          child: base
+        };
+      } else {
+        const perTrial = {
+          type: "sum",
+          count: baseCount,
+          child: node
+        };
+        if (trials === 1) {
+          node = perTrial;
+        } else {
+          const trialPool = {
+            type: "sum",
+            count: trials,
+            child: perTrial
+          };
+          node = {
+            type: "keep",
+            mode: cfg.keep.mode,
+            count: k,
+            child: trialPool
+          };
+        }
+      }
     } else {
       const c = appliedRollType ? 1 : Math.max(1, count || 1);
       node = { type: "sum", count: c, child: node };
@@ -3055,14 +3176,14 @@ function resolve(node, eps = defaultEps) {
         return res;
       }
       case "keep": {
-        const total = getTotalCount(node);
-        const die = findDie(node.child.child);
-        const perDie = die ? resolveSingleDie(die, eps) : PMF.delta(0, eps);
-        const keepCount = Math.max(0, Math.min(node.count, total));
-        if (keepCount === 0 || total === 0) return PMF.delta(0, eps);
+        const totalTrials = getTotalCount(node);
+        const keepCount = Math.max(0, Math.min(node.count, totalTrials));
+        if (keepCount === 0 || totalTrials === 0) return PMF.delta(0, eps);
+        const perTrialNode = node.child.child;
+        const perTrialPMF = resolve(perTrialNode, eps);
         return keepSumPMF(
-          perDie,
-          total,
+          perTrialPMF,
+          totalTrials,
           keepCount,
           node.mode === "highest",
           eps
@@ -3077,6 +3198,12 @@ function resolve(node, eps = defaultEps) {
         const childPMF = resolve(node.child, eps);
         return childPMF.scaleDamage(0.5, "floor");
       }
+      case "maxOf": {
+        const childPMF = resolve(node.child, eps);
+        const count = Math.max(1, Math.floor(node.count));
+        if (count === 1) return childPMF;
+        return computeMaxOfPMF(childPMF, count, eps);
+      }
     }
   })();
   builderPMFCache.set(cacheKey, result);
@@ -3147,6 +3274,7 @@ function findDie(node) {
     case "sum":
     case "d20Roll":
     case "half":
+    case "maxOf":
       return findDie(node.child);
     case "keep":
       return findDie(node.child.child);
@@ -3163,6 +3291,38 @@ function getTotalCount(node) {
   while (cur.type === "keep") cur = cur.child;
   return cur.type === "sum" ? Math.max(0, Math.floor(cur.count)) : 0;
 }
+function computeMaxOfPMF(pmf, count, eps = defaultEps) {
+  if (count <= 1) return pmf;
+  const support = pmf.support();
+  const out = /* @__PURE__ */ new Map();
+  if (count <= 6 && support.length <= 20) {
+    let dfs = function(rollsLeft, currentMax, probability) {
+      if (rollsLeft === 0) {
+        out.set(currentMax, (out.get(currentMax) || 0) + probability);
+        return;
+      }
+      for (const value of support) {
+        const p = pmf.pAt(value);
+        if (p > 0) {
+          const newMax = Math.max(currentMax, value);
+          dfs(rollsLeft - 1, newMax, probability * p);
+        }
+      }
+    };
+    dfs(count, -Infinity, 1);
+  } else {
+    const sortedSupport = [...support].sort((a, b) => a - b);
+    for (const value of sortedSupport) {
+      const cdfAtValue = pmf.cdfAt(value);
+      const cdfAtValueMinus1 = value > sortedSupport[0] ? pmf.cdfAt(value - 1) : 0;
+      const probMax = Math.pow(cdfAtValue, count) - Math.pow(cdfAtValueMinus1, count);
+      if (probMax > eps) {
+        out.set(value, probMax);
+      }
+    }
+  }
+  return PMF.fromMap(out, eps);
+}
 function keepSumPMF(single, total, keep, highest, eps = defaultEps) {
   if (keep >= total) return single.power(total, eps);
   if (keep <= 0) return PMF.delta(0, eps);
@@ -3171,24 +3331,106 @@ function keepSumPMF(single, total, keep, highest, eps = defaultEps) {
   const cacheKey = `keep|${pmfSig}|t:${total}|k:${keep}|h:${highest ? 1 : 0}|e:${eps}`;
   const cached = builderPMFCache.get(cacheKey);
   if (cached) return cached;
-  const support = single.support();
-  const probs = support.map((v) => ({ v, p: single.pAt(v) }));
-  const out = /* @__PURE__ */ new Map();
-  function dfs(i, accValues, weight) {
-    if (i === total) {
-      const sorted = [...accValues].sort((a, b) => highest ? b - a : a - b);
-      let sum = 0;
-      for (let j = 0; j < keep; j++) sum += sorted[j];
-      out.set(sum, (out.get(sum) || 0) + weight);
-      return;
+  if (keep === 1) {
+    if (highest) {
+      return computeMaxOfPMF(single, total, eps);
+    } else {
+      const neg = single.mapDamage((v) => -v);
+      const minPMF = computeMaxOfPMF(neg, total, eps).mapDamage((v) => -v);
+      builderPMFCache.set(cacheKey, minPMF);
+      return minPMF;
+    }
+  }
+  let state = /* @__PURE__ */ new Map();
+  const keyOf = (used, r) => `${used}|${r}`;
+  state.set(keyOf(0, total), /* @__PURE__ */ new Map([[0, 1]]));
+  const valuesDesc = highest ? [...sortedSupport].sort((a, b) => b - a) : [...sortedSupport].sort((a, b) => a - b);
+  const binomPMF = (r, p) => {
+    if (r <= 0) return [1];
+    if (p <= eps) {
+      const arr2 = new Array(r + 1).fill(0);
+      arr2[0] = 1;
+      return arr2;
+    }
+    if (1 - p <= eps) {
+      const arr2 = new Array(r + 1).fill(0);
+      arr2[r] = 1;
+      return arr2;
     }
-    for (const { v, p } of probs) {
-      if (p <= 0) continue;
-      dfs(i + 1, [...accValues, v], weight * p);
+    const q = 1 - p;
+    const arr = new Array(r + 1).fill(0);
+    arr[0] = Math.pow(q, r);
+    const ratio = p / q;
+    for (let x = 1; x <= r; x++)
+      arr[x] = arr[x - 1] * (r - x + 1) / x * ratio;
+    let s = 0;
+    for (let x = 0; x <= r; x++) s += arr[x];
+    if (Math.abs(1 - s) > 1e-12) for (let x = 0; x <= r; x++) arr[x] /= s;
+    return arr;
+  };
+  const pruneMap = (m, threshold) => {
+    if (threshold <= 0) return m;
+    const out = /* @__PURE__ */ new Map();
+    for (const [sum, pr] of m) if (pr >= threshold) out.set(sum, pr);
+    return out.size === m.size ? m : out;
+  };
+  const pruneState = (st, threshold) => {
+    if (threshold <= 0) return st;
+    const out = /* @__PURE__ */ new Map();
+    for (const [k, m] of st) {
+      const mm = pruneMap(m, threshold);
+      if (mm.size > 0) out.set(k, mm);
     }
+    return out;
+  };
+  let processedMass = 0;
+  for (const v of valuesDesc) {
+    const p = single.pAt(v);
+    if (p <= 0) continue;
+    const q = Math.max(eps, 1 - processedMass);
+    const pCond = Math.min(1, p / q);
+    const next = /* @__PURE__ */ new Map();
+    for (const [k, m] of state) {
+      const [usedStr, rStr] = k.split("|");
+      const used = parseInt(usedStr, 10);
+      const r = parseInt(rStr, 10);
+      if (r === 0) {
+        const destKey = keyOf(used, 0);
+        const dest = next.get(destKey) ?? /* @__PURE__ */ new Map();
+        for (const [sum, pr] of m) dest.set(sum, (dest.get(sum) || 0) + pr);
+        next.set(destKey, dest);
+        continue;
+      }
+      const bin = binomPMF(r, pCond);
+      const remainingCapacity = keep - used;
+      for (let x = 0; x <= r; x++) {
+        const px = bin[x];
+        if (px <= eps) continue;
+        const t = Math.min(x, remainingCapacity);
+        const used2 = used + t;
+        const r2 = r - x;
+        const add = t * v;
+        const destKey = keyOf(used2, r2);
+        const dest = next.get(destKey) ?? /* @__PURE__ */ new Map();
+        for (const [sum, pr] of m) {
+          const s2 = sum + add;
+          const prob = pr * px;
+          const cur = dest.get(s2) || 0;
+          const nv = cur + prob;
+          if (nv >= eps) dest.set(s2, nv);
+        }
+        if (dest.size > 0) next.set(destKey, dest);
+      }
+    }
+    state = pruneState(next, eps * 1e-6);
+    processedMass += p;
+  }
+  const finalKey = keyOf(keep, 0);
+  const dist = state.get(finalKey) ?? /* @__PURE__ */ new Map();
+  if (dist.size === 0) {
+    return PMF.emptyMass();
   }
-  dfs(0, [], 1);
-  const result = PMF.fromMap(out, eps);
+  const result = PMF.fromMap(dist, eps);
   builderPMFCache.set(cacheKey, result);
   return result;
 }
@@ -3214,6 +3456,8 @@ function getASTSignature(node) {
       )}}`;
     case "half":
       return `half{ch:${getASTSignature(node.child)}}`;
+    case "maxOf":
+      return `maxOf{c:${node.count},ch:${getASTSignature(node.child)}}`;
     case "add": {
       let constantValue = 0;
       const otherChildrenSigs = [];
@@ -3273,7 +3517,12 @@ var AttackBuilder = class _AttackBuilder {
     if (this.hitEffect) {
       effectPart = `(${this.hitEffect.toExpression()})`;
       if (this.critEffect !== null) {
-        const crit = this.critEffect ?? this.hitEffect.copy().doubleDice();
+        let crit;
+        if (this.critEffect) {
+          crit = this.critEffect;
+        } else {
+          crit = this.hitEffect?.copy().doubleDice() ?? RollBuilder.fromArgs(0);
+        }
         const critThreshold = this.check.critThreshold;
         if (critThreshold < 15 || critThreshold > 20) {
           throw new Error(
@@ -3586,6 +3835,7 @@ RollBuilder.prototype.dc = function(saveDC) {
 exports.ACBuilder = ACBuilder;
 exports.DCBuilder = DCBuilder;
 exports.HalfRollBuilder = HalfRollBuilder;
+exports.MaxOfRollBuilder = MaxOfRollBuilder;
 exports.RollBuilder = RollBuilder;
 exports.SaveBuilder = SaveBuilder;
 exports.builderPMFCache = builderPMFCache;