@yipe/dice 0.2.13 → 0.2.16

package/dist/builder/index.d.cts

@@ -1,4 +1,4 @@
-import { P as PMF, i as DiceQuery, L as LRUCache } from '../pmf-D1p2Re-J.cjs';
+import { P as PMF, C as CritConfig, i as DiceQuery, L as LRUCache } from '../pmf-CYaEbY7m.cjs';
 
 type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
 type DieNode = {
@@ -138,6 +138,8 @@ declare class RollBuilder {
     addRoll(count?: number): RollBuilder;
     scaleDice(scale: number): RollBuilder;
     doubleDice(): RollBuilder;
+    alwaysHits(): AlwaysHitBuilder;
+    alwaysCrits(): AlwaysCritBuilder;
     copy(): RollBuilder;
     d4: () => RollBuilder;
     d6: () => RollBuilder;
@@ -182,19 +184,54 @@ declare class MaxOfRollBuilder extends RollBuilder {
     get lastConfig(): any;
     getSubRollConfigs(): readonly RollConfig[];
     toExpression(): string;
-    private findDieInAST;
     toAST(): ExpressionNode;
     toPMF(eps?: number): PMF;
     copy(): MaxOfRollBuilder;
 }
+declare class AlwaysHitBuilder extends RollBuilder {
+    readonly attackConfig: CritConfig;
+    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig);
+    onHit(val: number): AttackBuilder;
+    onHit(val: RollBuilder): AttackBuilder;
+    onHit(count: number, die: RollBuilder): AttackBuilder;
+    onHit(count: number, sides: number): AttackBuilder;
+    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onHit(count: number, sides: number, modifier: number): AttackBuilder;
+    get critThreshold(): number;
+    critOn(critThreshold: number): AlwaysHitBuilder;
+    alwaysCrits(): AlwaysCritBuilder;
+    toExpression(): string;
+    toPMF(): PMF;
+    copy(): AlwaysHitBuilder;
+}
+declare class AlwaysCritBuilder extends RollBuilder {
+    readonly attackConfig: CritConfig & {
+        ac?: number;
+    };
+    readonly fromAlwaysHit: boolean;
+    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig & {
+        ac?: number;
+    }, fromAlwaysHit?: boolean);
+    onHit(val: number): AttackBuilder;
+    onHit(val: RollBuilder): AttackBuilder;
+    onHit(count: number, die: RollBuilder): AttackBuilder;
+    onHit(count: number, sides: number): AttackBuilder;
+    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onHit(count: number, sides: number, modifier: number): AttackBuilder;
+    get critThreshold(): number;
+    critOn(critThreshold: number): AlwaysCritBuilder;
+    toExpression(): string;
+    toPMF(): PMF;
+    copy(): AlwaysCritBuilder;
+}
 
 type ActionEffect = RollBuilder;
 declare class AttackBuilder implements CheckBuilder {
-    readonly check: ACBuilder;
+    readonly check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder;
     private readonly hitEffect?;
     private readonly critEffect?;
     private readonly missEffect?;
-    constructor(check: ACBuilder, hitEffect?: ActionEffect, critEffect?: ActionEffect | null, missEffect?: ActionEffect);
+    constructor(check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder, hitEffect?: ActionEffect, critEffect?: ActionEffect | null, missEffect?: ActionEffect);
     onCrit(val: number): AttackBuilder;
     onCrit(val: RollBuilder): AttackBuilder;
     onCrit(count: number, die: RollBuilder): AttackBuilder;
@@ -209,7 +246,7 @@ declare class AttackBuilder implements CheckBuilder {
     onMiss(count: number, sides: number, modifier: number): AttackBuilder;
     noCrit(): AttackBuilder;
     toExpression(): string;
-    resolveProbabilities(check: ACBuilder, eps?: number): {
+    resolveProbabilities(check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder, eps?: number): {
         pSuccess: number;
         pHit: number;
         pCrit: number;
@@ -236,6 +273,7 @@ declare class ACBuilder extends RollBuilder {
     onHit(count: number, sides: number, modifier: number): AttackBuilder;
     get critThreshold(): number;
     critOn(threshold: number): ACBuilder;
+    alwaysCrits(): AlwaysCritBuilder;
     toExpression(): string;
     toPMF(eps?: number): PMF;
     copy(): ACBuilder;
@@ -299,4 +337,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, 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 };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, 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,4 +1,4 @@
-import { P as PMF, i as DiceQuery, L as LRUCache } from '../pmf-D1p2Re-J.js';
+import { P as PMF, C as CritConfig, i as DiceQuery, L as LRUCache } from '../pmf-CYaEbY7m.js';
 
 type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
 type DieNode = {
@@ -138,6 +138,8 @@ declare class RollBuilder {
     addRoll(count?: number): RollBuilder;
     scaleDice(scale: number): RollBuilder;
     doubleDice(): RollBuilder;
+    alwaysHits(): AlwaysHitBuilder;
+    alwaysCrits(): AlwaysCritBuilder;
     copy(): RollBuilder;
     d4: () => RollBuilder;
     d6: () => RollBuilder;
@@ -182,19 +184,54 @@ declare class MaxOfRollBuilder extends RollBuilder {
     get lastConfig(): any;
     getSubRollConfigs(): readonly RollConfig[];
     toExpression(): string;
-    private findDieInAST;
     toAST(): ExpressionNode;
     toPMF(eps?: number): PMF;
     copy(): MaxOfRollBuilder;
 }
+declare class AlwaysHitBuilder extends RollBuilder {
+    readonly attackConfig: CritConfig;
+    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig);
+    onHit(val: number): AttackBuilder;
+    onHit(val: RollBuilder): AttackBuilder;
+    onHit(count: number, die: RollBuilder): AttackBuilder;
+    onHit(count: number, sides: number): AttackBuilder;
+    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onHit(count: number, sides: number, modifier: number): AttackBuilder;
+    get critThreshold(): number;
+    critOn(critThreshold: number): AlwaysHitBuilder;
+    alwaysCrits(): AlwaysCritBuilder;
+    toExpression(): string;
+    toPMF(): PMF;
+    copy(): AlwaysHitBuilder;
+}
+declare class AlwaysCritBuilder extends RollBuilder {
+    readonly attackConfig: CritConfig & {
+        ac?: number;
+    };
+    readonly fromAlwaysHit: boolean;
+    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig & {
+        ac?: number;
+    }, fromAlwaysHit?: boolean);
+    onHit(val: number): AttackBuilder;
+    onHit(val: RollBuilder): AttackBuilder;
+    onHit(count: number, die: RollBuilder): AttackBuilder;
+    onHit(count: number, sides: number): AttackBuilder;
+    onHit(count: number, die: RollBuilder, modifier: number): AttackBuilder;
+    onHit(count: number, sides: number, modifier: number): AttackBuilder;
+    get critThreshold(): number;
+    critOn(critThreshold: number): AlwaysCritBuilder;
+    toExpression(): string;
+    toPMF(): PMF;
+    copy(): AlwaysCritBuilder;
+}
 
 type ActionEffect = RollBuilder;
 declare class AttackBuilder implements CheckBuilder {
-    readonly check: ACBuilder;
+    readonly check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder;
     private readonly hitEffect?;
     private readonly critEffect?;
     private readonly missEffect?;
-    constructor(check: ACBuilder, hitEffect?: ActionEffect, critEffect?: ActionEffect | null, missEffect?: ActionEffect);
+    constructor(check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder, hitEffect?: ActionEffect, critEffect?: ActionEffect | null, missEffect?: ActionEffect);
     onCrit(val: number): AttackBuilder;
     onCrit(val: RollBuilder): AttackBuilder;
     onCrit(count: number, die: RollBuilder): AttackBuilder;
@@ -209,7 +246,7 @@ declare class AttackBuilder implements CheckBuilder {
     onMiss(count: number, sides: number, modifier: number): AttackBuilder;
     noCrit(): AttackBuilder;
     toExpression(): string;
-    resolveProbabilities(check: ACBuilder, eps?: number): {
+    resolveProbabilities(check: ACBuilder | AlwaysHitBuilder | AlwaysCritBuilder, eps?: number): {
         pSuccess: number;
         pHit: number;
         pCrit: number;
@@ -236,6 +273,7 @@ declare class ACBuilder extends RollBuilder {
     onHit(count: number, sides: number, modifier: number): AttackBuilder;
     get critThreshold(): number;
     critOn(threshold: number): ACBuilder;
+    alwaysCrits(): AlwaysCritBuilder;
     toExpression(): string;
     toPMF(eps?: number): PMF;
     copy(): ACBuilder;
@@ -299,4 +337,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, 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 };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, 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,14 +2657,6 @@ 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 };
@@ -2674,6 +2666,12 @@ var RollBuilder = class _RollBuilder {
   doubleDice() {
     return this.scaleDice(2);
   }
+  alwaysHits() {
+    return new AlwaysHitBuilder(this);
+  }
+  alwaysCrits() {
+    return new AlwaysCritBuilder(this);
+  }
   copy() {
     return new this.constructor(this.getSubRollConfigs());
   }
@@ -2937,17 +2935,6 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
     }
     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 = {
@@ -2976,7 +2963,7 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
           child: sumChild
         };
       }
-    } catch (e) {
+    } catch {
     }
     throw new Error(
       `MaxOfRollBuilder.toAST(): Unsupported innerRoll configuration`
@@ -2989,6 +2976,88 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
     return new _MaxOfRollBuilder(this.innerRoll.copy(), this.count);
   }
 };
+var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
+  constructor(baseRoll, attackConfig) {
+    super(baseRoll.getSubRollConfigs());
+    __publicField(this, "attackConfig");
+    if (attackConfig) {
+      this.attackConfig = { ...attackConfig };
+    } else {
+      this.attackConfig = { critThreshold: 20 };
+    }
+  }
+  onHit(...args) {
+    const damageRoll = RollBuilder.fromArgs(...args);
+    return new AttackBuilder(this, damageRoll);
+  }
+  get critThreshold() {
+    return this.attackConfig.critThreshold;
+  }
+  // TODO - move this to AC Builder… or if we create a DC builder that has critOn, throw an error?
+  critOn(critThreshold) {
+    const newConfig = { critThreshold };
+    return new _AlwaysHitBuilder(this, newConfig);
+  }
+  alwaysCrits() {
+    return new AlwaysCritBuilder(this, void 0, true);
+  }
+  // Legacy expressions
+  toExpression() {
+    const configs = this.getSubRollConfigs();
+    return new RollBuilder(configs).toExpression();
+  }
+  toPMF() {
+    const rollType = this.rollType;
+    const rerollOne = this.baseReroll > 0;
+    return d20RollPMF(rollType, rerollOne);
+  }
+  copy() {
+    const baseCopy = new RollBuilder(this.getSubRollConfigs());
+    const critThreshold = this.critThreshold;
+    const newConfig = { critThreshold };
+    return new _AlwaysHitBuilder(baseCopy, newConfig);
+  }
+};
+var AlwaysCritBuilder = class _AlwaysCritBuilder extends RollBuilder {
+  constructor(baseRoll, attackConfig, fromAlwaysHit = false) {
+    super(baseRoll.getSubRollConfigs());
+    __publicField(this, "attackConfig");
+    __publicField(this, "fromAlwaysHit");
+    if (attackConfig) {
+      this.attackConfig = { ...attackConfig };
+    } else {
+      this.attackConfig = { critThreshold: 20 };
+    }
+    this.fromAlwaysHit = fromAlwaysHit || baseRoll instanceof AlwaysHitBuilder;
+  }
+  onHit(...args) {
+    const damageRoll = RollBuilder.fromArgs(...args);
+    return new AttackBuilder(this, damageRoll);
+  }
+  get critThreshold() {
+    return this.attackConfig.critThreshold;
+  }
+  critOn(critThreshold) {
+    const newConfig = { critThreshold, ac: this.attackConfig.ac };
+    return new _AlwaysCritBuilder(this, newConfig, this.fromAlwaysHit);
+  }
+  // Legacy expressions
+  toExpression() {
+    const configs = this.getSubRollConfigs();
+    return new RollBuilder(configs).toExpression();
+  }
+  toPMF() {
+    const rollType = this.rollType;
+    const rerollOne = this.baseReroll > 0;
+    return d20RollPMF(rollType, rerollOne);
+  }
+  copy() {
+    const baseCopy = new RollBuilder(this.getSubRollConfigs());
+    const critThreshold = this.critThreshold;
+    const newConfig = { critThreshold, ac: this.attackConfig.ac };
+    return new _AlwaysCritBuilder(baseCopy, newConfig, this.fromAlwaysHit);
+  }
+};
 
 // src/builder/factory.ts
 var rollFn = (count, sidesOrDie, modifier) => {
@@ -3522,9 +3591,9 @@ var AttackBuilder = class _AttackBuilder {
           crit = this.hitEffect?.copy().doubleDice() ?? RollBuilder.fromArgs(0);
         }
         const critThreshold = this.check.critThreshold;
-        if (critThreshold < 15 || critThreshold > 20) {
+        if (critThreshold < 1 || critThreshold > 20) {
           throw new Error(
-            `Invalid crit threshold: ${critThreshold}. Must be between 15 and 20.`
+            `Invalid crit threshold: ${critThreshold}. Must be between 1 and 20.`
           );
         }
         if (critThreshold === 20) {
@@ -3541,11 +3610,46 @@ var AttackBuilder = class _AttackBuilder {
     return `${checkPart} * ${effectPart}`;
   }
   resolveProbabilities(check, eps = 0) {
-    const ac = check.attackConfig.ac;
     const rollType = check.rollType;
     const rerollOne = check.baseReroll > 0;
     const critThreshold = check.critThreshold;
     const d202 = d20RollPMF(rollType, rerollOne);
+    if (check instanceof AlwaysCritBuilder) {
+      if (check.fromAlwaysHit) {
+        return { pSuccess: 1, pHit: 0, pCrit: 1, pMiss: 0 };
+      }
+      const ac2 = check.attackConfig.ac ?? 0;
+      const staticMod2 = this.check.modifier;
+      const bonusDicePMFs2 = this.check.getBonusDicePMFs(this.check, eps);
+      const bonusPMF2 = bonusDicePMFs2.length ? PMF.convolveMany(bonusDicePMFs2, eps) : PMF.delta(0, eps);
+      let pcrit2 = 0;
+      let pmiss2 = 0;
+      for (const [r, rec] of d202) {
+        const pr = typeof rec === "number" ? rec : rec.p;
+        if (pr <= 0) continue;
+        if (r === 1) {
+          pmiss2 += pr;
+          continue;
+        }
+        const need = ac2 - staticMod2 - r;
+        const pBonusHit = bonusPMF2.tailProbGE(need);
+        pcrit2 += pr * pBonusHit;
+        pmiss2 += pr * (1 - pBonusHit);
+      }
+      return { pSuccess: pcrit2, pHit: 0, pCrit: pcrit2, pMiss: pmiss2 };
+    }
+    if (check instanceof AlwaysHitBuilder) {
+      let pCrit = 0;
+      for (const [r, rec] of d202) {
+        const pr = typeof rec === "number" ? rec : rec.p;
+        if (pr <= 0) continue;
+        if (r >= critThreshold) pCrit += pr;
+      }
+      const pHit = 1 - pCrit;
+      const pMiss = 0;
+      return { pSuccess: 1, pHit, pCrit, pMiss };
+    }
+    const ac = check.attackConfig.ac;
     const staticMod = this.check.modifier;
     const bonusDicePMFs = this.check.getBonusDicePMFs(this.check, eps);
     const bonusPMF = bonusDicePMFs.length ? PMF.convolveMany(bonusDicePMFs, eps) : PMF.delta(0, eps);
@@ -3555,14 +3659,14 @@ var AttackBuilder = class _AttackBuilder {
     for (const [r, rec] of d202) {
       const pr = typeof rec === "number" ? rec : rec.p;
       if (pr <= 0) continue;
-      if (r >= critThreshold) {
-        pcrit += pr;
-        continue;
-      }
       if (r === 1) {
         pmiss += pr;
         continue;
       }
+      if (r >= critThreshold) {
+        pcrit += pr;
+        continue;
+      }
       const need = ac - staticMod - r;
       const pBonusHit = bonusPMF.tailProbGE(need);
       phit += pr * pBonusHit;
@@ -3643,6 +3747,16 @@ var ACBuilder = class _ACBuilder extends RollBuilder {
     };
     return new _ACBuilder(this, this.attackConfig.ac, newConfig);
   }
+  alwaysCrits() {
+    return new AlwaysCritBuilder(
+      this,
+      {
+        critThreshold: this.attackConfig.critThreshold,
+        ac: this.attackConfig.ac
+      },
+      false
+    );
+  }
   // Legacy expressions
   toExpression() {
     const configs = this.getSubRollConfigs();
@@ -3830,6 +3944,6 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
-export { ACBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, 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