@yipe/dice 0.12.0 → 0.12.1

package/dist/index.js

@@ -3187,9 +3187,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();
@@ -3690,6 +3704,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;
@@ -3711,7 +3727,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;
       }
     }
@@ -3722,12 +3739,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;
@@ -3735,12 +3750,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;
     }
@@ -3751,12 +3764,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();
@@ -3765,19 +3776,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;
@@ -3867,6 +3880,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(
@@ -3901,7 +3942,7 @@ function followNaturalRoll(before, op, arg, after, clause) {
     const rights = advantage ? 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;
       })
@@ -3923,7 +3964,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)) };
   }
@@ -3950,7 +3994,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;
     }
   };
@@ -3968,7 +4018,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) {
@@ -3981,13 +4033,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) {
@@ -4004,6 +4064,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();
@@ -4017,27 +4084,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;
 }