@yipe/dice 0.8.1 → 0.9.0

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./common/errors.js";
 export * from "./common/lru-cache.js";
 export * from "./common/types.js";
 export * from "./parser/parser.js";
+export * from "./parser/rollType.js";
 export * from "./pmf/mixture.js";
 export * from "./pmf/pmf.js";
 export * from "./pmf/query.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC"}

package/dist/index.js

@@ -207,6 +207,10 @@ var _DiceQuery = class _DiceQuery {
     if (this._combinedWithAttr) {
       return this._combinedWithAttr;
     }
+    if (this._combinedProvided) {
+      this._combinedWithAttr = this.combined.withAttribution();
+      return this._combinedWithAttr;
+    }
     if (this.singles.every((pmf) => pmf.hasAttribution())) {
       this._combinedWithAttr = this.combined;
       return this._combinedWithAttr;
@@ -977,6 +981,55 @@ var _DiceQuery = class _DiceQuery {
     }
     return out;
   }
+  /**
+   * Per-outcome probabilities and damage ranges, aggregated over the individual
+   * singles rather than read off the combined distribution.
+   *
+   * `damageRange` is the sum, over every single that can produce the outcome, of
+   * that single's own conditional damage range: "what this outcome contributes
+   * across the whole turn when every attack that can produce it does". Linear in
+   * the number of attacks by construction.
+   *
+   * Prefer this over {@link DiceQuery.snapshot} for a multi-attack query.
+   * `snapshot` reads `damageRange` off the combined PMF's `count`, which the
+   * convolution accumulates as an expected count, so its `avg` is size-biased
+   * for N≥2 (its own doc comment says so). The two agree for a single attack.
+   *
+   * Only outcomes that actually occur appear in the result.
+   *
+   * Like every `singles`-based helper on this class, it describes the singles
+   * and not an explicitly provided `combined`. `Turn.toQuery()` supplies one whose
+   * distribution also contains rider attacks that are absent from `singles`
+   * (an `otherwise([unarmed, unarmed])` flurry, say), so those attacks do not
+   * appear here. For rider-inclusive figures read the combined distribution
+   * directly: {@link DiceQuery.outcomeTotals}, {@link DiceQuery.outcomeDamageRanges}.
+   *
+   * @param outcomes Which outcomes to consider; defaults to every canonical one.
+   */
+  outcomeStats(outcomes = ALL_OUTCOME_TYPES) {
+    const stats = /* @__PURE__ */ new Map();
+    const perSingle = this.singles.map((pmf) => new _DiceQuery([pmf], void 0, this._eps));
+    for (const outcome of outcomes) {
+      const atLeastOneProbability = this.probAtLeastOne(outcome);
+      if (atLeastOneProbability <= 0) continue;
+      const damageRange = { min: 0, avg: 0, max: 0 };
+      let contributors = 0;
+      for (const single of perSingle) {
+        if (single.probAtLeastOne(outcome) <= 0) continue;
+        contributors++;
+        const stat = single.damageStatsFrom(outcome);
+        damageRange.min += stat.min;
+        damageRange.avg += stat.avg;
+        damageRange.max += stat.max;
+      }
+      stats.set(outcome, {
+        atLeastOneProbability,
+        allProbability: contributors > 0 ? this.probExactlyK(outcome, contributors) : 0,
+        damageRange
+      });
+    }
+    return stats;
+  }
   /**
    * Snapshot of the distribution in the exact shape the UI consumes.
    * - outcome probabilities are "at least one" (and equal to "all" for a single PMF)
@@ -3345,6 +3398,65 @@ function parseOperation(s) {
   return;
 }
 
+// src/parser/rollType.ts
+var DECIMAL_INTEGER = /^\s*[+-]?\d+\s*$/;
+function tryParse(expression) {
+  if (DECIMAL_INTEGER.test(expression)) {
+    const value = Number(expression);
+    return Number.isSafeInteger(value) ? PMF.delta(value) : PMF.empty();
+  }
+  try {
+    return parse(expression);
+  } catch {
+    return PMF.empty();
+  }
+}
+var CHECK_TOKEN = /\b(AC|DC)\b/i;
+var D20_RUN = /\bh?d20(?:\s*[><]\s*h?d20)*/i;
+var RUN_FOR_ROLL_TYPE = {
+  flat: "d20",
+  advantage: "d20 > d20",
+  disadvantage: "d20 < d20",
+  "elven accuracy": "d20 > d20 > d20"
+};
+function withRollType(expression, rollType) {
+  const scopes = enclosingScopes(expression);
+  let rewritten = "";
+  let copiedUpTo = 0;
+  for (const run of expression.matchAll(new RegExp(D20_RUN, "gi"))) {
+    const at = run.index;
+    if (!isAttackRoll(expression, scopes, at)) continue;
+    const replacement = run[0].toLowerCase().startsWith("h") ? `h${RUN_FOR_ROLL_TYPE[rollType]}` : RUN_FOR_ROLL_TYPE[rollType];
+    rewritten += expression.slice(copiedUpTo, at) + replacement;
+    copiedUpTo = at + run[0].length;
+  }
+  return rewritten + expression.slice(copiedUpTo);
+}
+function enclosingScopes(expression) {
+  const open = [];
+  const scopes = [];
+  for (let i = 0; i < expression.length; i++) {
+    if (expression[i] === "(") open.push(i);
+    else if (expression[i] === ")") {
+      const start = open.pop();
+      if (start !== void 0) scopes.push({ start, end: i + 1 });
+    }
+  }
+  return scopes.sort((a, b) => a.end - a.start - (b.end - b.start));
+}
+function isAttackRoll(expression, scopes, at) {
+  let scoped = false;
+  for (const scope of scopes) {
+    if (at < scope.start || at >= scope.end) continue;
+    scoped = true;
+    const check2 = CHECK_TOKEN.exec(expression.slice(scope.start, scope.end));
+    if (check2) return check2[1].toUpperCase() === "AC";
+  }
+  if (scoped) return false;
+  const check = CHECK_TOKEN.exec(expression);
+  return check !== null && check[1].toUpperCase() === "AC";
+}
+
 // src/pmf/mixture.ts
 var Mixture = class _Mixture {
   constructor(eps = EPS) {
@@ -3463,6 +3575,6 @@ var Mixture = class _Mixture {
   }
 };
 
-export { ALL_OUTCOME_TYPES, DiceParseError, DiceQuery, EPS, LRUCache, MISS_NONE_OUTCOME, Mixture, OUTCOME_DISPLAY_ORDER, PMF, calculateBounceOdds, clearParserCache, critProbability, getCachingEnabled, onAnyHit, onCritOnly, onHitOnly, onMissDamageOnly, onMissOnly, onPotentCantripOnly, onSaveFailOnly, onSaveHalfOnly, parse, pmfCache, setCachingEnabled, sortOutcomes };
+export { ALL_OUTCOME_TYPES, DiceParseError, DiceQuery, EPS, LRUCache, MISS_NONE_OUTCOME, Mixture, OUTCOME_DISPLAY_ORDER, PMF, calculateBounceOdds, clearParserCache, critProbability, getCachingEnabled, onAnyHit, onCritOnly, onHitOnly, onMissDamageOnly, onMissOnly, onPotentCantripOnly, onSaveFailOnly, onSaveHalfOnly, parse, pmfCache, setCachingEnabled, sortOutcomes, tryParse, withRollType };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map