@yipe/dice 0.4.0 → 0.5.0

package/dist/builder/index.d.cts

@@ -98,7 +98,7 @@ declare class DCBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
 }
 
-type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode | ScaleNode;
 type DieNode = {
     type: "die";
     sides: number;
@@ -142,6 +142,22 @@ type MaxOfNode = {
     count: number;
     child: ExpressionNode;
 };
+/**
+ * Scale the child's result by `numerator / denominator`, then round.
+ *
+ * Unlike {@link HalfNode} (a fixed `// 2` with floor), this is a general, composable
+ * multiplier/divider — the building block for damage-type resistance (`1/2`, floor),
+ * vulnerability (`2/1`), and similar per-source transforms. It renders as
+ * `N * (child)` when the denominator is 1, `(child) // D` when the numerator is 1,
+ * and `(child) * N // D` otherwise.
+ */
+type ScaleNode = {
+    type: "scale";
+    numerator: number;
+    denominator: number;
+    rounding: "floor" | "round" | "ceil";
+    child: ExpressionNode;
+};
 
 declare const defaultConfig: RollConfig;
 declare class RollBuilder {
@@ -202,6 +218,13 @@ declare class RollBuilder {
     get rollType(): RollType;
     get baseReroll(): number;
     half(): HalfRollBuilder;
+    /**
+     * Scale this roll's result by `numerator / denominator`, rounding each outcome.
+     * A general, composable form of {@link half} — used to model damage-type resistance
+     * (`scaleResult(1, 2)` → `(expr) // 2`) and vulnerability (`scaleResult(2)` → `2 * (expr)`).
+     * Compose several of these (and plain rolls) into one payload with {@link sumRolls}.
+     */
+    scaleResult(numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil"): ScaleRollBuilder;
     maxOf(count: number): MaxOfRollBuilder;
     ac(_targetAC: number): ACBuilder;
     dc(_saveDC: number): DCBuilder;
@@ -217,6 +240,25 @@ declare class HalfRollBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
     copy(): HalfRollBuilder;
 }
+/**
+ * A roll whose result is scaled by `numerator / denominator` and rounded — the composable
+ * generalization of {@link HalfRollBuilder}. Renders as `N * (inner)`, `(inner) // D`, or
+ * `(inner) * N // D`. Terminal (like `half`): use {@link sumRolls} to combine with other rolls.
+ */
+declare class ScaleRollBuilder extends RollBuilder {
+    private readonly innerRoll;
+    private readonly numerator;
+    private readonly denominator;
+    private readonly rounding;
+    constructor(innerRoll: RollBuilder, numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil");
+    hasHiddenState(): boolean;
+    get lastConfig(): RollConfig;
+    getSubRollConfigs(): readonly RollConfig[];
+    toExpression(): string;
+    toAST(): ExpressionNode;
+    toPMF(eps?: number): PMF;
+    copy(): ScaleRollBuilder;
+}
 declare class MaxOfRollBuilder extends RollBuilder {
     private readonly innerRoll;
     private readonly count;
@@ -305,6 +347,14 @@ declare class PooledRollBuilder extends RollBuilder {
     scaleDice(scale: number): RollBuilder;
     times(count: number): PooledRollBuilder;
 }
+/**
+ * Combine several rolls into one additive payload whose PMF is their convolution and whose
+ * expression is them joined with ` + `. Unlike `a.plus(b)`, this preserves parts that carry
+ * hidden state (e.g. `roll.scaleResult(1, 2)` / `roll.half()`), so per-damage-type resistance
+ * and vulnerability survive into both the distribution and the rendered expression.
+ * Empty parts collapse to `0`; a single part is returned unwrapped.
+ */
+declare function sumRolls(parts: readonly RollBuilder[]): RollBuilder;
 
 type ActionEffect = RollBuilder;
 declare class AttackBuilder implements CheckBuilder {
@@ -376,4 +426,4 @@ declare const flat: (n: number) => RollBuilder;
 declare const roll: RollFactory;
 declare const builderPMFCache: LRUCache<string, PMF>;
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, RollType, SaveBuilder, type SaveOutcome, type SaveResolution, ScaleRollBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };

package/dist/builder/index.d.ts

@@ -98,7 +98,7 @@ declare class DCBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
 }
 
-type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode;
+type ExpressionNode = DieNode | ConstantNode | SumNode | AddNode | KeepNode | D20RollNode | HalfNode | MaxOfNode | ScaleNode;
 type DieNode = {
     type: "die";
     sides: number;
@@ -142,6 +142,22 @@ type MaxOfNode = {
     count: number;
     child: ExpressionNode;
 };
+/**
+ * Scale the child's result by `numerator / denominator`, then round.
+ *
+ * Unlike {@link HalfNode} (a fixed `// 2` with floor), this is a general, composable
+ * multiplier/divider — the building block for damage-type resistance (`1/2`, floor),
+ * vulnerability (`2/1`), and similar per-source transforms. It renders as
+ * `N * (child)` when the denominator is 1, `(child) // D` when the numerator is 1,
+ * and `(child) * N // D` otherwise.
+ */
+type ScaleNode = {
+    type: "scale";
+    numerator: number;
+    denominator: number;
+    rounding: "floor" | "round" | "ceil";
+    child: ExpressionNode;
+};
 
 declare const defaultConfig: RollConfig;
 declare class RollBuilder {
@@ -202,6 +218,13 @@ declare class RollBuilder {
     get rollType(): RollType;
     get baseReroll(): number;
     half(): HalfRollBuilder;
+    /**
+     * Scale this roll's result by `numerator / denominator`, rounding each outcome.
+     * A general, composable form of {@link half} — used to model damage-type resistance
+     * (`scaleResult(1, 2)` → `(expr) // 2`) and vulnerability (`scaleResult(2)` → `2 * (expr)`).
+     * Compose several of these (and plain rolls) into one payload with {@link sumRolls}.
+     */
+    scaleResult(numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil"): ScaleRollBuilder;
     maxOf(count: number): MaxOfRollBuilder;
     ac(_targetAC: number): ACBuilder;
     dc(_saveDC: number): DCBuilder;
@@ -217,6 +240,25 @@ declare class HalfRollBuilder extends RollBuilder {
     toPMF(eps?: number): PMF;
     copy(): HalfRollBuilder;
 }
+/**
+ * A roll whose result is scaled by `numerator / denominator` and rounded — the composable
+ * generalization of {@link HalfRollBuilder}. Renders as `N * (inner)`, `(inner) // D`, or
+ * `(inner) * N // D`. Terminal (like `half`): use {@link sumRolls} to combine with other rolls.
+ */
+declare class ScaleRollBuilder extends RollBuilder {
+    private readonly innerRoll;
+    private readonly numerator;
+    private readonly denominator;
+    private readonly rounding;
+    constructor(innerRoll: RollBuilder, numerator: number, denominator?: number, rounding?: "floor" | "round" | "ceil");
+    hasHiddenState(): boolean;
+    get lastConfig(): RollConfig;
+    getSubRollConfigs(): readonly RollConfig[];
+    toExpression(): string;
+    toAST(): ExpressionNode;
+    toPMF(eps?: number): PMF;
+    copy(): ScaleRollBuilder;
+}
 declare class MaxOfRollBuilder extends RollBuilder {
     private readonly innerRoll;
     private readonly count;
@@ -305,6 +347,14 @@ declare class PooledRollBuilder extends RollBuilder {
     scaleDice(scale: number): RollBuilder;
     times(count: number): PooledRollBuilder;
 }
+/**
+ * Combine several rolls into one additive payload whose PMF is their convolution and whose
+ * expression is them joined with ` + `. Unlike `a.plus(b)`, this preserves parts that carry
+ * hidden state (e.g. `roll.scaleResult(1, 2)` / `roll.half()`), so per-damage-type resistance
+ * and vulnerability survive into both the distribution and the rendered expression.
+ * Empty parts collapse to `0`; a single part is returned unwrapped.
+ */
+declare function sumRolls(parts: readonly RollBuilder[]): RollBuilder;
 
 type ActionEffect = RollBuilder;
 declare class AttackBuilder implements CheckBuilder {
@@ -376,4 +426,4 @@ declare const flat: (n: number) => RollBuilder;
 declare const roll: RollFactory;
 declare const builderPMFCache: LRUCache<string, PMF>;
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, RollType, SaveBuilder, type SaveOutcome, type SaveResolution, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, type AttackConfig, type AttackResolution, type CheckBuilder, DCBuilder, HalfRollBuilder, type KeepMode, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, type Resolution, RollBuilder, type RollConfig, type RollFactory, RollType, SaveBuilder, type SaveOutcome, type SaveResolution, ScaleRollBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };

package/dist/builder/index.js

@@ -4092,6 +4092,15 @@ var RollBuilder = class _RollBuilder {
   half() {
     return new HalfRollBuilder(this);
   }
+  /**
+   * Scale this roll's result by `numerator / denominator`, rounding each outcome.
+   * A general, composable form of {@link half} — used to model damage-type resistance
+   * (`scaleResult(1, 2)` → `(expr) // 2`) and vulnerability (`scaleResult(2)` → `2 * (expr)`).
+   * Compose several of these (and plain rolls) into one payload with {@link sumRolls}.
+   */
+  scaleResult(numerator, denominator = 1, rounding = "floor") {
+    return new ScaleRollBuilder(this, numerator, denominator, rounding);
+  }
   // Create a "max of N rolls" version of this roll for crit damage with keep operations
   maxOf(count) {
     return new MaxOfRollBuilder(this, count);
@@ -4146,6 +4155,50 @@ var HalfRollBuilder = class _HalfRollBuilder extends RollBuilder {
     return new _HalfRollBuilder(this.innerRoll.copy());
   }
 };
+var ScaleRollBuilder = class _ScaleRollBuilder extends RollBuilder {
+  constructor(innerRoll, numerator, denominator = 1, rounding = "floor") {
+    super(0);
+    this.innerRoll = innerRoll;
+    this.numerator = numerator;
+    this.denominator = denominator;
+    this.rounding = rounding;
+  }
+  hasHiddenState() {
+    return this.innerRoll.hasHiddenState();
+  }
+  get lastConfig() {
+    return this.innerRoll.lastConfig;
+  }
+  getSubRollConfigs() {
+    return this.innerRoll.getSubRollConfigs();
+  }
+  toExpression() {
+    const inner = this.innerRoll.toExpression();
+    if (this.denominator === 1) return `${this.numerator} * (${inner})`;
+    if (this.numerator === 1) return `(${inner}) // ${this.denominator}`;
+    return `(${inner}) * ${this.numerator} // ${this.denominator}`;
+  }
+  toAST() {
+    return {
+      type: "scale",
+      numerator: this.numerator,
+      denominator: this.denominator,
+      rounding: this.rounding,
+      child: this.innerRoll.toAST()
+    };
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  copy() {
+    return new _ScaleRollBuilder(
+      this.innerRoll.copy(),
+      this.numerator,
+      this.denominator,
+      this.rounding
+    );
+  }
+};
 var MaxOfRollBuilder = class _MaxOfRollBuilder extends RollBuilder {
   constructor(innerRoll, count, diceCount, diceSides) {
     super(0);
@@ -4444,6 +4497,49 @@ var PooledRollBuilder = class _PooledRollBuilder extends RollBuilder {
     return new _PooledRollBuilder(sumNode, newExpr);
   }
 };
+var CompositeSumRollBuilder = class _CompositeSumRollBuilder extends RollBuilder {
+  constructor(parts) {
+    super(0);
+    this.parts = parts;
+  }
+  hasHiddenState() {
+    return true;
+  }
+  getSubRollConfigs() {
+    return [];
+  }
+  toAST() {
+    return {
+      type: "add",
+      children: this.parts.map((p) => ({
+        node: p.toAST(),
+        sign: 1
+      }))
+    };
+  }
+  toExpression() {
+    const exprs = this.parts.map((p) => p.toExpression()).filter((e) => e && e !== "0");
+    if (exprs.length === 0) return "0";
+    let result = exprs[0];
+    for (let i = 1; i < exprs.length; i++) {
+      const e = exprs[i];
+      result += e.startsWith("-") ? ` - ${e.substring(1)}` : ` + ${e}`;
+    }
+    return result.replace(/\+ -/g, "-");
+  }
+  toPMF(eps = 0) {
+    return pmfFromRollBuilder(this, eps);
+  }
+  copy() {
+    return new _CompositeSumRollBuilder(this.parts.map((p) => p.copy()));
+  }
+};
+function sumRolls(parts) {
+  const meaningful = parts.filter((p) => p !== void 0);
+  if (meaningful.length === 0) return new RollBuilder(0);
+  if (meaningful.length === 1) return meaningful[0];
+  return new CompositeSumRollBuilder(meaningful);
+}
 
 // src/builder/factory.ts
 var rollFn = (count, sidesOrDie, modifier) => {
@@ -4674,6 +4770,11 @@ function resolve(node, eps = defaultEps) {
         if (count === 1) return childPMF;
         return computeMaxOfPMF(childPMF, count, eps);
       }
+      case "scale": {
+        const childPMF = resolve(node.child, eps);
+        const denom = node.denominator === 0 ? 1 : node.denominator;
+        return childPMF.scaleDamage(node.numerator / denom, node.rounding);
+      }
     }
   })();
   builderPMFCache.set(cacheKey, result);
@@ -4745,6 +4846,7 @@ function findDie(node) {
     case "d20Roll":
     case "half":
     case "maxOf":
+    case "scale":
       return findDie(node.child);
     case "keep":
       return findDie(node.child.child);
@@ -4929,6 +5031,8 @@ function getASTSignature(node) {
       return `half{ch:${getASTSignature(node.child)}}`;
     case "maxOf":
       return `maxOf{c:${node.count},ch:${getASTSignature(node.child)}}`;
+    case "scale":
+      return `scale{n:${node.numerator},d:${node.denominator},r:${node.rounding},ch:${getASTSignature(node.child)}}`;
     case "add": {
       let constantValue = 0;
       const otherChildrenSigs = [];
@@ -5365,6 +5469,6 @@ RollBuilder.prototype.dc = function(saveDC) {
   return new DCBuilder(this).dc(saveDC);
 };
 
-export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll };
+export { ACBuilder, AlwaysCritBuilder, AlwaysHitBuilder, AttackBuilder, DCBuilder, HalfRollBuilder, MaxOfRollBuilder, ParsedRollBuilder, PooledRollBuilder, RollBuilder, SaveBuilder, ScaleRollBuilder, builderPMFCache, d, d10, d100, d12, d20, d4, d6, d8, defaultConfig, flat, hd20, roll, sumRolls };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map