@yipe/dice 0.2.12 → 0.2.15

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,7 @@ declare class RollBuilder {
     addRoll(count?: number): RollBuilder;
     scaleDice(scale: number): RollBuilder;
     doubleDice(): RollBuilder;
+    alwaysHits(): AlwaysHitBuilder;
     copy(): RollBuilder;
     d4: () => RollBuilder;
     d6: () => RollBuilder;
@@ -182,19 +183,42 @@ 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;
+    toExpression(): string;
+    toPMF(): PMF;
+    copy(): AlwaysHitBuilder;
+}
+declare class AlwaysCritBuilder extends RollBuilder {
+    readonly attackConfig: CritConfig;
+    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig);
+    get critThreshold(): number;
+    critOn(critThreshold: number): AlwaysHitBuilder;
+    toExpression(): string;
+    toPMF(): PMF;
+    copy(): AlwaysHitBuilder;
+}
 
 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 +233,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;
@@ -299,4 +323,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,7 @@ declare class RollBuilder {
     addRoll(count?: number): RollBuilder;
     scaleDice(scale: number): RollBuilder;
     doubleDice(): RollBuilder;
+    alwaysHits(): AlwaysHitBuilder;
     copy(): RollBuilder;
     d4: () => RollBuilder;
     d6: () => RollBuilder;
@@ -182,19 +183,42 @@ 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;
+    toExpression(): string;
+    toPMF(): PMF;
+    copy(): AlwaysHitBuilder;
+}
+declare class AlwaysCritBuilder extends RollBuilder {
+    readonly attackConfig: CritConfig;
+    constructor(baseRoll: RollBuilder, attackConfig?: CritConfig);
+    get critThreshold(): number;
+    critOn(critThreshold: number): AlwaysHitBuilder;
+    toExpression(): string;
+    toPMF(): PMF;
+    copy(): AlwaysHitBuilder;
+}
 
 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 +233,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;
@@ -299,4 +323,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,9 @@ var RollBuilder = class _RollBuilder {
   doubleDice() {
     return this.scaleDice(2);
   }
+  alwaysHits() {
+    return new AlwaysHitBuilder(this);
+  }
   copy() {
     return new this.constructor(this.getSubRollConfigs());
   }
@@ -2937,17 +2932,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 = {
@@ -2989,6 +2973,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) => {
@@ -3080,7 +3138,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",
@@ -3096,8 +3165,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",
@@ -3532,11 +3599,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);
@@ -3821,6 +3902,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