@yipe/dice 0.2.12 → 0.2.15

package/dist/builder/index.cjs

@@ -2659,14 +2659,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 };
@@ -2676,6 +2668,9 @@ var RollBuilder = class _RollBuilder {
   doubleDice() {
     return this.scaleDice(2);
   }
+  alwaysHits() {
+    return new AlwaysHitBuilder(this);
+  }
   copy() {
     return new this.constructor(this.getSubRollConfigs());
   }
@@ -2939,17 +2934,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 = {
@@ -2991,6 +2975,80 @@ 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);
+  }
+  // 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 extends RollBuilder {
+  constructor(baseRoll, attackConfig) {
+    super(baseRoll.getSubRollConfigs());
+    __publicField(this, "attackConfig");
+    if (attackConfig) {
+      this.attackConfig = { ...attackConfig };
+    } else {
+      this.attackConfig = { critThreshold: 20 };
+    }
+  }
+  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);
+  }
+  // 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);
+  }
+};
 
 // src/builder/factory.ts
 var rollFn = (count, sidesOrDie, modifier) => {
@@ -3082,7 +3140,18 @@ function astFromRollConfigs(configs) {
       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) {
+      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",
@@ -3098,8 +3167,6 @@ function astFromRollConfigs(configs) {
         };
         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",
@@ -3534,11 +3601,25 @@ var AttackBuilder = class _AttackBuilder {
     return `${checkPart} * ${effectPart}`;
   }
   resolveProbabilities(check, eps = 0) {
-    const ac = check.attackConfig.ac;
+    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 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);
@@ -3824,6 +3905,8 @@ RollBuilder.prototype.dc = function(saveDC) {
 };
 
 exports.ACBuilder = ACBuilder;
+exports.AlwaysCritBuilder = AlwaysCritBuilder;
+exports.AlwaysHitBuilder = AlwaysHitBuilder;
 exports.DCBuilder = DCBuilder;
 exports.HalfRollBuilder = HalfRollBuilder;
 exports.MaxOfRollBuilder = MaxOfRollBuilder;