@yipe/dice 0.2.10 → 0.2.12

package/dist/builder/index.d.cts

@@ -1,38 +1,47 @@
 import { P as PMF, i as DiceQuery, L as LRUCache } from '../pmf-D1p2Re-J.cjs';
 
-type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode;
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
 type DieNode = {
-    type: 'die';
+    type: "die";
     sides: number;
     reroll?: number;
     minimum?: number;
     explode?: number;
 };
 type ConstantNode = {
-    type: 'constant';
+    type: "constant";
     value: number;
 };
 type SumNode = {
-    type: 'sum';
+    type: "sum";
     count: number;
     child: ExpressionNode;
 };
 type AddNode = {
-    type: 'add';
+    type: "add";
     children: {
         node: ExpressionNode;
         sign: 1 | -1;
     }[];
 };
 type KeepNode = {
-    type: 'keep';
-    mode: 'highest' | 'lowest';
+    type: "keep";
+    mode: "highest" | "lowest";
     count: number;
     child: SumNode | KeepNode;
 };
 type D20RollNode = {
-    type: 'd20Roll';
-    rollType: 'advantage' | 'disadvantage' | 'elven accuracy';
+    type: "d20Roll";
+    rollType: "advantage" | "disadvantage" | "elven accuracy";
+    child: ExpressionNode;
+};
+type HalfNode = {
+    type: "half";
+    child: ExpressionNode;
+};
+type MaxOfNode = {
+    type: "maxOf";
+    count: number;
     child: ExpressionNode;
 };
 
@@ -151,6 +160,32 @@ declare class RollBuilder {
     get modifier(): number;
     get rollType(): RollType;
     get baseReroll(): number;
+    half(): HalfRollBuilder;
+    maxOf(count: number): MaxOfRollBuilder;
+}
+declare class HalfRollBuilder extends RollBuilder {
+    private readonly innerRoll;
+    constructor(innerRoll: RollBuilder);
+    get lastConfig(): any;
+    getSubRollConfigs(): readonly RollConfig[];
+    toExpression(): string;
+    toAST(): ExpressionNode;
+    toPMF(eps?: number): PMF;
+    copy(): HalfRollBuilder;
+}
+declare class MaxOfRollBuilder extends RollBuilder {
+    private readonly innerRoll;
+    private readonly count;
+    private readonly diceCount?;
+    private readonly diceSides?;
+    constructor(innerRoll: RollBuilder, count: number, diceCount?: number, diceSides?: number);
+    get lastConfig(): any;
+    getSubRollConfigs(): readonly RollConfig[];
+    toExpression(): string;
+    private findDieInAST;
+    toAST(): ExpressionNode;
+    toPMF(eps?: number): PMF;
+    copy(): MaxOfRollBuilder;
 }
 
 type ActionEffect = RollBuilder;
@@ -264,4 +299,4 @@ declare const flat: (n: number) => RollBuilder;
 declare const roll: RollFactory;
 declare const builderPMFCache: LRUCache<string, PMF>;
 
-export { ACBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, type KeepMode, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };

package/dist/builder/index.d.ts

@@ -1,38 +1,47 @@
 import { P as PMF, i as DiceQuery, L as LRUCache } from '../pmf-D1p2Re-J.js';
 
-type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode;
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
 type DieNode = {
-    type: 'die';
+    type: "die";
     sides: number;
     reroll?: number;
     minimum?: number;
     explode?: number;
 };
 type ConstantNode = {
-    type: 'constant';
+    type: "constant";
     value: number;
 };
 type SumNode = {
-    type: 'sum';
+    type: "sum";
     count: number;
     child: ExpressionNode;
 };
 type AddNode = {
-    type: 'add';
+    type: "add";
     children: {
         node: ExpressionNode;
         sign: 1 | -1;
     }[];
 };
 type KeepNode = {
-    type: 'keep';
-    mode: 'highest' | 'lowest';
+    type: "keep";
+    mode: "highest" | "lowest";
     count: number;
     child: SumNode | KeepNode;
 };
 type D20RollNode = {
-    type: 'd20Roll';
-    rollType: 'advantage' | 'disadvantage' | 'elven accuracy';
+    type: "d20Roll";
+    rollType: "advantage" | "disadvantage" | "elven accuracy";
+    child: ExpressionNode;
+};
+type HalfNode = {
+    type: "half";
+    child: ExpressionNode;
+};
+type MaxOfNode = {
+    type: "maxOf";
+    count: number;
     child: ExpressionNode;
 };
 
@@ -151,6 +160,32 @@ declare class RollBuilder {
     get modifier(): number;
     get rollType(): RollType;
     get baseReroll(): number;
+    half(): HalfRollBuilder;
+    maxOf(count: number): MaxOfRollBuilder;
+}
+declare class HalfRollBuilder extends RollBuilder {
+    private readonly innerRoll;
+    constructor(innerRoll: RollBuilder);
+    get lastConfig(): any;
+    getSubRollConfigs(): readonly RollConfig[];
+    toExpression(): string;
+    toAST(): ExpressionNode;
+    toPMF(eps?: number): PMF;
+    copy(): HalfRollBuilder;
+}
+declare class MaxOfRollBuilder extends RollBuilder {
+    private readonly innerRoll;
+    private readonly count;
+    private readonly diceCount?;
+    private readonly diceSides?;
+    constructor(innerRoll: RollBuilder, count: number, diceCount?: number, diceSides?: number);
+    get lastConfig(): any;
+    getSubRollConfigs(): readonly RollConfig[];
+    toExpression(): string;
+    private findDieInAST;
+    toAST(): ExpressionNode;
+    toPMF(eps?: number): PMF;
+    copy(): MaxOfRollBuilder;
 }
 
 type ActionEffect = RollBuilder;
@@ -264,4 +299,4 @@ declare const flat: (n: number) => RollBuilder;
 declare const roll: RollFactory;
 declare const builderPMFCache: LRUCache<string, PMF>;
 
-export { ACBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, type KeepMode, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, type RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };

package/dist/builder/index.js

@@ -2657,6 +2657,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 };
@@ -2873,6 +2881,113 @@ var RollBuilder = class _RollBuilder {
     const rootConfig = this.getRootDieConfig();
     return rootConfig?.reroll || 0;
   }
+  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) {
+    super(0);
+    this.innerRoll = innerRoll;
+  }
+  get lastConfig() {
+    return this.innerRoll.lastConfig;
+  }
+  getSubRollConfigs() {
+    return this.innerRoll.getSubRollConfigs();
+  }
+  toExpression() {
+    const innerExpression = this.innerRoll.toExpression();
+    return `(${innerExpression}) // 2`;
+  }
+  toAST() {
+    return {
+      type: "half",
+      child: this.innerRoll.toAST()
+    };
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  copy() {
+    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
@@ -2962,13 +3077,41 @@ 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 (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 if (k === 1 && cfg.keep.mode === "highest") {
+          node = { type: "maxOf", count: trials, child: 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 };
@@ -3022,14 +3165,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
@@ -3040,14 +3183,23 @@ function resolve(node, eps = defaultEps) {
         const rerollOne = !!childDie && (childDie.reroll || 0) >= 1;
         return d20RollPMF(node.rollType, rerollOne);
       }
+      case "half": {
+        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);
   return result;
 }
 function pmfFromRollBuilder(rb, eps = defaultEps) {
-  const configs = rb.getSubRollConfigs?.() ?? [];
-  const ast = astFromRollConfigs(configs) || { type: "constant", value: 0 };
+  const ast = rb.toAST();
   return resolve(ast, eps);
 }
 function resolveSingleDie(die, eps = defaultEps) {
@@ -3110,6 +3262,8 @@ function findDie(node) {
       return void 0;
     case "sum":
     case "d20Roll":
+    case "half":
+    case "maxOf":
       return findDie(node.child);
     case "keep":
       return findDie(node.child.child);
@@ -3126,6 +3280,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);
@@ -3134,24 +3320,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;
 }
@@ -3175,6 +3443,10 @@ function getASTSignature(node) {
       return `keep{c:${node.count},m:${node.mode},ch:${getASTSignature(
         node.child
       )}}`;
+    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 = [];
@@ -3234,7 +3506,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(
@@ -3544,6 +3821,6 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
-export { ACBuilder, DCBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map