@yipe/dice 0.2.15 → 0.2.16

package/dist/builder/index.cjs

@@ -2671,6 +2671,9 @@ var RollBuilder = class _RollBuilder {
   alwaysHits() {
     return new AlwaysHitBuilder(this);
   }
+  alwaysCrits() {
+    return new AlwaysCritBuilder(this);
+  }
   copy() {
     return new this.constructor(this.getSubRollConfigs());
   }
@@ -2962,7 +2965,7 @@ var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
           child: sumChild
         };
       }
-    } catch (e) {
+    } catch {
     }
     throw new Error(
       `MaxOfRollBuilder.toAST(): Unsupported innerRoll configuration`
@@ -2997,6 +3000,9 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
     const newConfig = { critThreshold };
     return new _AlwaysHitBuilder(this, newConfig);
   }
+  alwaysCrits() {
+    return new AlwaysCritBuilder(this, void 0, true);
+  }
   // Legacy expressions
   toExpression() {
     const configs = this.getSubRollConfigs();
@@ -3014,23 +3020,28 @@ var AlwaysHitBuilder = class _AlwaysHitBuilder extends RollBuilder {
     return new _AlwaysHitBuilder(baseCopy, newConfig);
   }
 };
-var AlwaysCritBuilder = class extends RollBuilder {
-  constructor(baseRoll, attackConfig) {
+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;
   }
-  // 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);
+    const newConfig = { critThreshold, ac: this.attackConfig.ac };
+    return new _AlwaysCritBuilder(this, newConfig, this.fromAlwaysHit);
   }
   // Legacy expressions
   toExpression() {
@@ -3045,8 +3056,8 @@ var AlwaysCritBuilder = class extends RollBuilder {
   copy() {
     const baseCopy = new RollBuilder(this.getSubRollConfigs());
     const critThreshold = this.critThreshold;
-    const newConfig = { critThreshold };
-    return new AlwaysHitBuilder(baseCopy, newConfig);
+    const newConfig = { critThreshold, ac: this.attackConfig.ac };
+    return new _AlwaysCritBuilder(baseCopy, newConfig, this.fromAlwaysHit);
   }
 };
 
@@ -3582,9 +3593,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) {
@@ -3601,13 +3612,34 @@ var AttackBuilder = class _AttackBuilder {
     return `${checkPart} * ${effectPart}`;
   }
   resolveProbabilities(check, eps = 0) {
-    if (check instanceof AlwaysCritBuilder) {
-      return { pSuccess: 1, pHit: 0, pCrit: 1, pMiss: 0 };
-    }
     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) {
@@ -3629,14 +3661,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;
@@ -3717,6 +3749,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();