@yipe/dice 0.12.0 → 0.12.1

package/README.md

@@ -189,13 +189,17 @@ when used as a payload that doubles (`onHit`, `doubleDice()`); as a rider it is
 crit, like the attack or save builder it stands for.
 An attack string with no crit clause crits too: `"(d20 + 8 AC 16) * (2d6)"` rolls its natural 20 as
 `4d6`, like `d20.plus(8).ac(16).onHit(roll(2, d6))`; a `crit (…)` clause still wins. A term after
-the payload joined by `+`, `*`, `**`, `/` or `//` applies only where the attack deals damage (the
-grammar reads left to right, and `+` adds to non-zero totals), so it is part of the payload:
-`(d20 + 5 AC 15) * (1d8) + 1d6` crits as `2d8 + 2d6`, like `onHit(roll(1, d8).plus(roll(1, d6)))`,
-and keeps its hit, crit and miss labels. After a `crit (…)` clause the term is added to the crit as
-written. The crit rate reads the check's natural die, its one d20 wherever it sits in the sum (with
-no d20, its largest die), through bonus to-hit dice, advantage (`d20 > d20`, `d20!`, `2kh1d20`),
-disadvantage (`2kl1(1d20)`), elven accuracy (`3kh1(1d20)`) and halfling luck (`hd20`,
+the payload joined by `+`, `*`, `**`, `/` or `//` is part of the payload and never applies to a
+miss (the grammar reads left to right). `+` adds to every landed hit and crit, and to every
+other outcome that carries a payload (miss damage, a potent-cantrip half, a save's failure or half),
+one whose payload rolled 0 included, like the builder's `plus`: `(d20 + 5 AC 12) * (1d4 - 1) + 1d6` is
+`onHit(roll(1, d4).minus(1).plus(d6))` (mean 3.8). `*`, `**`, `/` and `//` act on the payload's
+value, so a hit that deals 0 still deals 0. `(d20 + 5 AC 15) * (1d8) + 1d6` crits as `2d8 + 2d6`,
+like `onHit(roll(1, d8).plus(roll(1, d6)))`, and keeps its hit, crit and miss labels. After a
+`crit (…)` clause the term is added to the crit as written, and after a `miss (…)` clause to the
+miss damage too. The crit rate reads the check's natural die, its one d20 wherever it sits in the
+sum (with no d20, its largest die), through bonus to-hit dice, advantage (`d20 > d20`, `d20!`,
+`2kh1d20`), disadvantage (`2kl1(1d20)`), elven accuracy (`3kh1(1d20)`) and halfling luck (`hd20`,
 `d20 reroll 1`), for `crit` and `xcrit N` alike: `(d20 > d20 + 5 + 1d4 AC 15) * (2d6)` crits at
 39/400, like `d20.withAdvantage().plus(5).plus(d4)`, `(1d4 + d20 + 5 AC 15)` crits on the d20, not
 the d4, and `(d20 + d100 AC 60)` on the d20, not the d100 (61/2000). A max or min against another
@@ -438,7 +442,7 @@ associates left to right**: `1d6 + 2 * 3` is `(1d6 + 2) * 3`. Parenthesise to gr
 | `7`, `d6`, `3d6`, `hd20` | A number, a die, a sum of dice, a die whose 1 is rerolled once (halfling luck, `d20 reroll 1`). |
 | `N(X)`, `(X)d6` | N independent copies of X, summed. The count may be rolled: `(1d4)d6`. A count of 0 is 0 (`0d6`, `(1d4 - 1)d6` has P(0) = 1/4); a count that can be negative throws. |
 | `NkhK(X)`, `NklK(X)` | The sum of the K highest (lowest) of N independent copies of X, exact for any X: `4kh3d6`, `2kl1(1d20)`, `4kh1(2d20)`. `2kl1(2d6)` keeps the lower of two 2d6 *sums*. |
-| `X + Y` | Adds Y where the total so far is not 0, so a miss (0) stays 0: `(d20 + 5 AC 15) * (1d8) + 1d6`. Inside a check total (left of `AC`/`DC`) `+` always adds, so `d20 - 5 + 1d4 AC 1` adds the d4 on a natural 5 too. |
+| `X + Y` | Adds Y where the total so far is not 0, so a miss (0) stays 0. After an attack's or a save's payload it adds to every outcome that carries a payload (a landed hit or crit, a miss clause's damage, a potent-cantrip half, a save's failure or half), one that deals 0 included: `(d20 + 5 AC 15) * (1d4 - 1) + 1d6`. Inside a check total (left of `AC`/`DC`) `+` always adds, so `d20 - 5 + 1d4 AC 1` adds the d4 on a natural 5 too. |
 | `X ~+ Y` | Always adds. |
 | `X - Y`, `-X` | Subtracts. A leading `-` negates the argument after it, repeat included: `-2d6` is `-(2d6)`, `1d6 + -3` is `1d6 - 3`, `-1d8 + 1d6` has mean -1. There is no unary `+`. |
 | `X * Y` | Y where X is not 0, else 0: the hit gate of `(check) * (damage)`. |
@@ -449,7 +453,7 @@ associates left to right**: `1d6 + 2 * 3` is `(1d6 + 2) * 3`. Parenthesise to gr
 | `X = Y` | 1 where X equals Y, else 0. |
 | `X & Y` | A mix weighted by each side's count of outcomes (see the refused shapes above). |
 | `X reroll R` | Rolls X, and on a result in the face set R rolls X again and keeps the second roll. |
-| `X AC T`, `X DC T` | An attack check (X where X ≥ T, else 0) and a saving throw (0 on a save, 1 on a failure). |
+| `X AC T`, `X DC T` | An attack check (X where X ≥ T, else 0) and a saving throw (0 on a save, 1 on a failure). A total of exactly 0 that meets a T of 0 or less lands, though it reads 0 like a miss: `(d20 - 5 AC 0) * (1d6)` hits on a natural 5 and crits on a 20, like `d20.minus(5).ac(0).onHit(roll(1, d6))`. |
 | `… crit (Y)`, `… xcritN (Y)`, `… miss (Y)`, `… save half`, `… pc` | Outcome clauses after an attack's or a save's payload. `xcrit0 (Y)` never crits: every landing is a hit. |
 
 **Rerolls.** `reroll N` rerolls the face N only; `reroll dN` rerolls every face from 1 to N; the
@@ -465,8 +469,8 @@ The reroll decides on the raw face and a minimum applies after: `3>(d6 reroll 1)
 **Labels.** An attack labels its outcomes `hit`, `crit`, `missNone` and `missDamage`. A save labels a
 failed save `saveFail` (whatever the payload rolls, 0 included), a halved success `saveHalf`, and a
 success with no `save half` `missNone`, like the builder's `onSaveFailure()`. A landed hit whose
-payload deals 0 is still `hit` (a 0-damage crit is `crit`), like the builder; only a miss is
-`missNone`.
+payload deals 0 is still `hit` (a 0-damage crit is `crit`), like the builder, and so is an AC
+check's landed total of exactly 0; only a miss is `missNone`.
 
 A `d0` has no faces: it is only a face set (`reroll d0`); rolled on its own it throws, as does a
 string the grammar cannot read, always as a `DiceParseError`.

package/dist/builder/index.cjs

@@ -3377,9 +3377,23 @@ var Dice = class _Dice {
     result.privateData.isDCCheck = true;
     return result;
   }
+  /**
+   * An attack check: a total that meets the target lands at its own value, and a miss is 0. A total
+   * of exactly 0 that meets the target (a target of 0 or less) lands at 0 too, where the misses sit:
+   * its count is recorded under `hit` at 0, like a payload's 0-damage hit, so the ops after the
+   * check tell it from a miss.
+   */
   ac(other) {
     const acCheck = (a, b) => a >= b ? a : 0;
-    return this.checkTarget(other, acCheck);
+    const result = this.checkTarget(other, acCheck);
+    const zero = this.get(0);
+    if (zero > 0) {
+      let met = 0;
+      if (typeof other === "number") met = other <= 0 ? 1 : 0;
+      else for (const [target, count] of other.getFaceEntries()) if (target <= 0) met += count;
+      if (met > 0) result.setOutcomeDistribution("hit", { 0: zero * met });
+    }
+    return result;
   }
   deleteFace(face) {
     const result = new _Dice();
@@ -3657,6 +3671,8 @@ function parseExpression(arr, n, inCheck = false) {
     const hitText = pending?.slice(0, pending.length - arr.length);
     const termText = opText?.slice(0, opText.length - arr.length);
     const before = finalResult;
+    const attack = isAttack(finalResult);
+    const acCheck = finalResult.privateData.isACCheck === true;
     if (op === Dice.prototype.combine) assertMixable(before, arg, arr);
     let crit;
     let critNorm = 1;
@@ -3678,7 +3694,8 @@ function parseExpression(arr, n, inCheck = false) {
       } else {
         ({ crit, rest: finalResult } = splitCrit(finalResult, count));
         critNorm = crit.total();
-        crit = op.call(crit, critClause ? parseBinaryArgument(arg, arr, n) : critPayload(hitText, n));
+        const critArg = critClause ? parseBinaryArgument(arg, arr, n) : critPayload(hitText, n);
+        crit = HIT_ONLY_OPS.has(op) ? applyToLanded(crit, op, critArg, crit.get(0), acCheck) : op.call(crit, critArg);
         critNorm = crit && critNorm ? crit.total() / critNorm : 1;
       }
     }
@@ -3689,12 +3706,10 @@ function parseExpression(arr, n, inCheck = false) {
       assertToken(arr, "a");
       assertToken(arr, "v");
       assertToken(arr, "e");
-      save = new Dice();
-      const min = finalResult.minFace();
-      save.increment(min > 0 ? min : 1, finalResult.get(min));
-      saveNorm = save.total();
-      finalResult = finalResult.deleteFace(min);
-      save = op.call(save, parseBinaryArgument(arg, arr, n));
+      const { miss: missed, rest } = splitMiss(finalResult, attack);
+      finalResult = rest;
+      saveNorm = missed.total();
+      save = op.call(missed, parseBinaryArgument(arg, arr, n));
       saveNorm = save && saveNorm ? save.total() / saveNorm : 1;
     }
     let pc;
@@ -3702,12 +3717,10 @@ function parseExpression(arr, n, inCheck = false) {
     if (arr.length >= 2 && arr[0] === "p" && arr[1] === "c") {
       assertToken(arr, "p");
       assertToken(arr, "c");
-      pc = new Dice();
-      const min = finalResult.minFace();
-      pc.increment(min > 0 ? min : 1, finalResult.get(min));
-      const missBefore = pc.total();
-      finalResult = finalResult.deleteFace(min);
-      pc = op.call(pc, parseBinaryArgument(arg, arr, n)).divideRoundDown(2);
+      const { miss: missed, rest } = splitMiss(finalResult, attack);
+      finalResult = rest;
+      const missBefore = missed.total();
+      pc = op.call(missed, parseBinaryArgument(arg, arr, n)).divideRoundDown(2);
       const missAfter = pc ? pc.total() : 0;
       pcNorm = missBefore ? missAfter / missBefore : 1;
     }
@@ -3718,12 +3731,10 @@ function parseExpression(arr, n, inCheck = false) {
       assertToken(arr, "i");
       assertToken(arr, "s");
       assertToken(arr, "s");
-      miss = new Dice();
-      const min = finalResult.minFace();
-      miss.increment(min > 0 ? min : 1, finalResult.get(min));
-      missNorm = miss.total();
-      finalResult = finalResult.deleteFace(min);
-      miss = op.call(miss, parseBinaryArgument(arg, arr, n));
+      const { miss: missed, rest } = splitMiss(finalResult, attack);
+      finalResult = rest;
+      missNorm = missed.total();
+      miss = op.call(missed, parseBinaryArgument(arg, arr, n));
       missNorm = miss && missNorm ? miss.total() / missNorm : 1;
     }
     let norm = finalResult.total();
@@ -3732,19 +3743,21 @@ function parseExpression(arr, n, inCheck = false) {
     const operand = finalResult;
     if (!clause && labelled && HIT_ONLY_OPS.has(op)) {
       finalResult = applyByOutcome(finalResult, op, arg, termText, n);
+    } else if (HIT_ONLY_OPS.has(op)) {
+      finalResult = applyToLanded(finalResult, op, arg, landedAtZero(finalResult), acCheck);
     } else {
       finalResult = op.call(finalResult, arg);
     }
     if (operand.privateData.isDCCheck && HIT_ONLY_OPS.has(op)) {
       finalResult.setOutcomeDistribution("saveFail", op.call(operand.deleteFace(0), arg).getFaceMap());
     }
-    if (!operand.privateData.isDCCheck && HIT_ONLY_OPS.has(op) && (hitText !== void 0 || operand.privateData.attackPayload)) {
+    if (attack && HIT_ONLY_OPS.has(op)) {
       finalResult.privateData.attackPayload = true;
-      const landed = landedHitsAtZero(operand, op, arg);
+      const landed = landedHitsAtZero(operand, op, arg, acCheck);
       if (landed > 0) finalResult.setOutcomeDistribution("hit", { 0: landed });
-    } else if (op === Dice.prototype.combine && typeof arg !== "number" && arg.privateData.attackPayload) {
-      finalResult.privateData.attackPayload = true;
-      const landed = operand.getOutcomeCount("hit", 0) + arg.getOutcomeCount("hit", 0);
+    } else if (op === Dice.prototype.combine && typeof arg !== "number") {
+      if (arg.privateData.attackPayload) finalResult.privateData.attackPayload = true;
+      const landed = landedAtZero(operand) + landedAtZero(arg);
       if (landed > 0) finalResult.setOutcomeDistribution("hit", { 0: landed });
     }
     const gated = op === Dice.prototype.combine && typeof arg !== "number" && arg.privateData.isACCheck;
@@ -3834,6 +3847,34 @@ function branchesOf(value) {
 }
 var hasOutcomeLabels = (value) => typeof value !== "number" && Object.keys(value.getFullOutcomeDistribution()).some((label) => label !== "hit");
 var isSave = (value) => typeof value !== "number" && value.privateData.isDCCheck === true;
+var isAttack = (value) => value.privateData.isDCCheck !== true && (value.privateData.isACCheck === true || value.privateData.attackPayload === true);
+var landedAtZero = (value) => typeof value === "number" ? 0 : value.getOutcomeCount("hit", 0);
+function applyToLanded(value, op, arg, landed, gate) {
+  const lands = op === Dice.prototype.addNonZero || gate && op === Dice.prototype.conditionalApply;
+  if (!(landed > 0) || !lands) return op.call(value, arg);
+  const misses = value.deleteFace(0);
+  const missed = value.get(0) - landed;
+  if (missed > 0) misses.setFace(0, missed);
+  const result = op.call(misses, arg);
+  result.combineInPlace(asValue(arg).normalize(landed));
+  return result;
+}
+function applyToAttack(value, op, arg, gate) {
+  const result = applyToLanded(value, op, arg, landedAtZero(value), gate);
+  result.privateData.attackPayload = true;
+  const landed = landedHitsAtZero(value, op, arg, gate);
+  if (landed > 0) result.setOutcomeDistribution("hit", { 0: landed });
+  return result;
+}
+function splitMiss(check, attack) {
+  const face = attack ? 0 : check.minFace();
+  const landed = face === 0 ? landedAtZero(check) : 0;
+  const miss = new Dice();
+  miss.increment(face > 0 ? face : 1, check.get(face) - landed);
+  const rest = check.deleteFace(face);
+  if (landed > 0) rest.setFace(0, landed);
+  return { miss, rest };
+}
 function assertMixable(left, right, rest) {
   if (hasOutcomeLabels(left) || hasOutcomeLabels(right)) {
     throw new Error(
@@ -3868,7 +3909,7 @@ function followNaturalRoll(before, op, arg, after, clause) {
     const rights = advantage2 ? lefts : gate ? [asValue(arg)] : branchesOf(arg);
     data.branches = lefts.flatMap(
       (left) => rights.map((right) => {
-        const part = pairOp.call(left, right);
+        const part = HIT_ONLY_OPS.has(pairOp) && isAttack(left) ? applyToAttack(left, pairOp, right, left.privateData.isACCheck === true) : pairOp.call(left, right);
         followNaturalRoll(left, pairOp, right, part, false);
         return part;
       })
@@ -3890,7 +3931,10 @@ function followNaturalRoll(before, op, arg, after, clause) {
   } else if (extremum && track?.bare && argTrack?.bare && sides === argSides) {
     data.critTrack = bareTrack(after);
   } else if (followed) {
-    const apply = own ? (value) => op.call(value, arg) : (value) => op.call(before, value);
+    const attack = HIT_ONLY_OPS.has(op) && isAttack(before);
+    const gated = before.privateData.isACCheck === true;
+    const call = (value, other) => attack ? applyToAttack(value, op, other, gated) : op.call(value, other);
+    const apply = own ? (value) => call(value, arg) : (value) => call(before, value);
     const step = extremum ? (slice) => keptPart(slice, apply) : apply;
     data.critTrack = { sides: followed.sides, bare: false, slice: (face) => step(followed.slice(face)) };
   }
@@ -3917,7 +3961,13 @@ function mixNaturalRolls(after, branches) {
     bare: tracks.length === branches.length && tracks.every((track) => track.bare),
     slice: (face) => {
       const slice = new Dice();
-      for (const track of tracks) slice.combineInPlace(track.slice(face));
+      let landed = 0;
+      for (const track of tracks) {
+        const part = track.slice(face);
+        slice.combineInPlace(part);
+        landed += landedAtZero(part);
+      }
+      if (landed > 0) slice.setOutcomeDistribution("hit", { 0: landed });
       return slice;
     }
   };
@@ -3935,7 +3985,9 @@ function keptPart(slice, apply) {
 function splitCrit(check, count) {
   if (count === 0) {
     const none = new Dice();
-    return { crit: none, rest: subtractCounts(check, none) };
+    const rest2 = subtractCounts(check, none);
+    if (landedAtZero(check) > 0) rest2.setOutcomeDistribution("hit", { 0: landedAtZero(check) });
+    return { crit: none, rest: rest2 };
   }
   const track = check.privateData.critTrack;
   if (!track) {
@@ -3948,13 +4000,21 @@ function splitCrit(check, count) {
     throw new Error(`xcrit${count} is wider than the d${sides} it reads its natural roll from`);
   }
   let crit = new Dice();
-  for (let face = sides; face > sides - count; face--) crit.combineInPlace(track.slice(face));
+  let landed = 0;
+  for (let face = sides; face > sides - count; face--) {
+    const slice = track.slice(face);
+    crit.combineInPlace(slice);
+    landed += landedAtZero(slice);
+  }
   const rest = subtractCounts(check, crit);
-  const missed = crit.get(0);
+  const missed = crit.get(0) - landed;
   if (missed) {
     crit = crit.deleteFace(0);
+    if (landed > 0) crit.setFace(0, landed);
     rest.increment(0, missed);
   }
+  const restLanded = landedAtZero(check) - landed;
+  if (restLanded > 0) rest.setOutcomeDistribution("hit", { 0: restLanded });
   return { crit, rest };
 }
 function critPayload(text, n) {
@@ -3971,6 +4031,13 @@ function critPayload(text, n) {
   }
   return payload;
 }
+var PAYLOAD_OUTCOMES = {
+  crit: true,
+  missDamage: true,
+  pc: true,
+  saveFail: true,
+  saveHalf: true
+};
 function applyByOutcome(labelled, op, arg, termText, n) {
   const implicit = labelled.privateData.implicitCrit;
   const argTotal = typeof arg === "number" ? 1 : arg.total();
@@ -3984,27 +4051,29 @@ function applyByOutcome(labelled, op, arg, termText, n) {
     rest = subtractCounts(rest, part);
     let applied;
     if (label === "crit" && implicit && termText !== void 0) {
-      payload = implicit.payload + termText;
+      payload = implicit.payload + (op === Dice.prototype.addNonZero ? "~" : "") + termText;
       const doubled = critPayload(payload, n);
       applied = doubled.normalize(part.total() * argTotal / doubled.total());
+    } else if (PAYLOAD_OUTCOMES[label] === true) {
+      applied = applyToLanded(part, op, arg, part.get(0), false);
     } else {
       applied = op.call(part, arg);
     }
     result.combineInPlace(applied);
     result.setOutcomeDistribution(label, applied.getFaceMap());
   }
-  result.combineInPlace(op.call(rest, arg));
+  result.combineInPlace(applyToLanded(rest, op, arg, landedAtZero(labelled), false));
   if (labelled.privateData.isDCCheck) result.privateData.isDCCheck = true;
   if (payload !== void 0) result.privateData.implicitCrit = { payload };
   return result;
 }
-function landedHitsAtZero(operand, op, arg) {
+function landedHitsAtZero(operand, op, arg, gate) {
   let landed = 0;
   for (const [face, count] of Object.entries(operand.calculateHitDistribution())) {
     if (!(count > 0)) continue;
     const hit = new Dice();
     hit.setFace(Number(face), count);
-    landed += op.call(hit, arg).get(0);
+    landed += applyToLanded(hit, op, arg, Number(face) === 0 ? count : 0, gate).get(0);
   }
   return landed;
 }