@yipe/dice 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -5,15 +5,30 @@ All notable changes to this project are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.4.0]
+## [0.5.0]
 
 Pushes damage-attribution / provenance and D&D-probability logic that the
 consuming app (dprcalc) had hand-rolled over PMF internals down into the
-library, so the provenance model and dice math stay owned here. All additive
-except the Elemental-Adept bounce fix noted below.
+library, so the provenance model and dice math stay owned here, and adds a
+**composable scale node** so a scaled/rounded sub-roll can nest inside a larger
+damage payload (per-damage-type resistance / immunity / vulnerability). All
+additive except the Elemental-Adept bounce fix noted below.
 
 ### Added
 
+- **`RollBuilder.scaleResult(numerator, denominator = 1, rounding = 'floor')`** —
+  wraps a builder in a composable `scale` AST node that scales its resolved PMF
+  by `numerator / denominator` with the given rounding. Unlike the old
+  `.half()` wrapper, a scaled builder composes: it survives `sumRolls(...)`
+  instead of being dropped on a flat-config merge, so a per-type resisted or
+  doubled sub-roll keeps its own scaling inside a larger hit/crit payload. The
+  rendered expression reflects it — `denominator === 1 → "N * (child)"`,
+  `numerator === 1 → "(child) // D"`, general → `"(child) * N // D"`. `.half()`
+  is now `scaleResult(1, 2, 'floor')`.
+- **`sumRolls(parts: RollBuilder[])`** — additive factory whose `toAST()` is an
+  `add` node over each part's AST, letting scaled and plain children sit side by
+  side without the flat `.plus()` merge collapsing them. `toExpression()` joins
+  the parts with ` + ` and `toPMF()` convolves them.
 - **`PMF.applyHitFrequency(frequency)`** — provenance-preserving mass
   redistribution for effects that only occur with some probability (conditional
   attacks, on-hit riders, sub-one AoE fractions): scales every hit bin (damage

package/dist/builder/index.cjs

@@ -4094,6 +4094,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);
@@ -4148,6 +4157,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);
@@ -4446,6 +4499,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) => {
@@ -4676,6 +4772,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);
@@ -4747,6 +4848,7 @@ function findDie(node) {
     case "d20Roll":
     case "half":
     case "maxOf":
+    case "scale":
       return findDie(node.child);
     case "keep":
       return findDie(node.child.child);
@@ -4931,6 +5033,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 = [];
@@ -5378,6 +5482,7 @@ exports.ParsedRollBuilder = ParsedRollBuilder;
 exports.PooledRollBuilder = PooledRollBuilder;
 exports.RollBuilder = RollBuilder;
 exports.SaveBuilder = SaveBuilder;
+exports.ScaleRollBuilder = ScaleRollBuilder;
 exports.builderPMFCache = builderPMFCache;
 exports.d = d;
 exports.d10 = d10;
@@ -5391,5 +5496,6 @@ exports.defaultConfig = defaultConfig;
 exports.flat = flat;
 exports.hd20 = hd20;
 exports.roll = roll;
+exports.sumRolls = sumRolls;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map