@yipe/dice 0.2.9 → 0.2.11

package/dist/builder/index.d.cts

@@ -1,38 +1,42 @@
 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;
 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;
 };
 
@@ -151,6 +155,17 @@ declare class RollBuilder {
     get modifier(): number;
     get rollType(): RollType;
     get baseReroll(): number;
+    half(): HalfRollBuilder;
+}
+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;
 }
 
 type ActionEffect = RollBuilder;
@@ -264,4 +279,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, 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,42 @@
 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;
 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;
 };
 
@@ -151,6 +155,17 @@ declare class RollBuilder {
     get modifier(): number;
     get rollType(): RollType;
     get baseReroll(): number;
+    half(): HalfRollBuilder;
+}
+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;
 }
 
 type ActionEffect = RollBuilder;
@@ -264,4 +279,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, 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

@@ -2696,7 +2696,7 @@ var RollBuilder = class _RollBuilder {
     let rootD20Group;
     if (rootConfig && rootConfig.sides === 20) {
       const rootIndex = groupedConfigs.findIndex(
-        ({ config }) => config.sides === rootConfig.sides && config.rollType === rootConfig.rollType && config.reroll === rootConfig.reroll && config.explode === rootConfig.explode && config.minimum === rootConfig.minimum && config.bestOf === rootConfig.bestOf && JSON.stringify(config.keep) === JSON.stringify(rootConfig.keep)
+        ({ config }) => rollConfigsEqual(config, rootConfig) && JSON.stringify(config.keep) === JSON.stringify(rootConfig.keep)
       );
       if (rootIndex !== -1) {
         rootD20Group = groupedConfigs.splice(rootIndex, 1)[0];
@@ -2735,13 +2735,19 @@ var RollBuilder = class _RollBuilder {
       const expression = diceExpressions[i];
       if (i === 0) {
         result = (config.isSubtraction ? "-" : "") + expression;
+        if (config.sides === 20 && totalModifier !== 0) {
+          if (totalModifier > 0) result += ` + ${totalModifier}`;
+          else result += ` - ${Math.abs(totalModifier)}`;
+        }
       } else {
         const operator = config.isSubtraction ? " - " : " + ";
         result += operator + expression;
       }
     }
-    if (totalModifier > 0) result += ` + ${totalModifier}`;
-    else if (totalModifier < 0) result += ` - ${Math.abs(totalModifier)}`;
+    if (diceConfigs.length === 0 || diceConfigs[0].sides !== 20) {
+      if (totalModifier > 0) result += ` + ${totalModifier}`;
+      else if (totalModifier < 0) result += ` - ${Math.abs(totalModifier)}`;
+    }
     return result.replace(/\+ -/g, "-");
   }
   toPMF(eps = 0) {
@@ -2867,6 +2873,37 @@ var RollBuilder = class _RollBuilder {
     const rootConfig = this.getRootDieConfig();
     return rootConfig?.reroll || 0;
   }
+  half() {
+    return new HalfRollBuilder(this);
+  }
+};
+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());
+  }
 };
 
 // src/builder/factory.ts
@@ -3034,14 +3071,17 @@ 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");
+      }
     }
   })();
   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) {
@@ -3104,6 +3144,7 @@ function findDie(node) {
       return void 0;
     case "sum":
     case "d20Roll":
+    case "half":
       return findDie(node.child);
     case "keep":
       return findDie(node.child.child);
@@ -3169,6 +3210,8 @@ function getASTSignature(node) {
       return `keep{c:${node.count},m:${node.mode},ch:${getASTSignature(
         node.child
       )}}`;
+    case "half":
+      return `half{ch:${getASTSignature(node.child)}}`;
     case "add": {
       let constantValue = 0;
       const otherChildrenSigs = [];
@@ -3538,6 +3581,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, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map