@scrthq/runlog 0.0.41 → 0.0.43

package/dist/runlog.js

@@ -26318,6 +26318,9 @@ var Predicate = external_exports.lazy(
       "Tests whether any earlier subject was created from an entry carrying this tag \u2014 for results that only make sense once something of a given kind exists."
     ),
     external_exports.object({ modeIs: external_exports.array(Id).min(1).describe("Mode ids in which this holds true.") }).strict().describe("Tests which mode the run is being played in."),
+    external_exports.object({ phaseDone: Id.describe("Id of a phase in the flow.") }).strict().describe(
+      "True once the named phase has been completed in the current unit. This is how a move that records an outcome is kept off the screen until there is something to have an outcome about."
+    ),
     external_exports.object({ not: Predicate }).strict().describe("True when the inner predicate is false."),
     external_exports.object({ allOf: external_exports.array(Predicate).min(1) }).strict().describe("True only when every listed predicate holds."),
     external_exports.object({ anyOf: external_exports.array(Predicate).min(1) }).strict().describe("True when at least one listed predicate holds.")
@@ -26380,6 +26383,7 @@ var Action = external_exports.lazy(
       do: external_exports.literal("rollOn").describe("Roll on another table and resolve whatever comes up."),
       table: Id.describe("Id of the table to roll on."),
       times: external_exports.number().int().min(1).max(10).optional().describe("How many times to roll. Defaults to 1."),
+      timesFrom: external_exports.string().min(1).optional().describe("Name a total bound earlier with `roll \u2026 into`; that many times, instead of `times`. How a pack rolls for how many to roll."),
       choose: external_exports.enum(["one", "all"]).optional().describe(
         "With times > 1: `one` lets the player pick a single result to apply, `all` applies every result. Defaults to `all`."
       ),
@@ -26516,7 +26520,10 @@ var EntryBase = {
   grants: external_exports.array(Id).optional().describe(
     "States applied to the relevant subject on resolution. Shorthand for an applyState trigger."
   ),
-  tags: external_exports.array(external_exports.string()).optional().describe("Free tags, for cross-referencing and for filtering results out in some modes.")
+  tags: external_exports.array(external_exports.string()).optional().describe("Free tags, for cross-referencing and for filtering results out in some modes."),
+  points: external_exports.number().int().min(0).optional().describe(
+    "What a contestant earns for completing this result in a moderated mode. A result with points is a challenge the moderator can award; one without is an effect that lands on everyone."
+  )
 };
 var LookupEntry = external_exports.object({
   ...EntryBase,
@@ -26636,7 +26643,8 @@ var Capability = external_exports.enum([
   "journal",
   "bandsResolution",
   "opposedResolution",
-  "keyedResolution"
+  "keyedResolution",
+  "moderated"
 ]).describe("An engine feature this pack needs in order to play correctly.");
 var Vocabulary = external_exports.object({
   run: external_exports.object({
@@ -26667,6 +26675,9 @@ var StateDef = external_exports.object({
   ).optional().describe(
     "What this state means mechanically. Without it the engine would have to know what your state names mean, which is exactly what keeps an engine game-specific. `makesUntargetable` removes the subject from targeting; `excludesFromResult` leaves it in the run but out of the finished piece; `removesFromPlay` takes it out entirely."
   ),
+  group: Id.optional().describe(
+    "States in the same group are mutually exclusive on one holder: applying one removes the others. Use it for outcomes that cannot both be true, like landed and missed."
+  ),
   description: external_exports.string().optional().describe("Explanation shown to the player on hover.")
 }).strict().describe("A persistent condition that sticks to a subject, or to the run, once applied.");
 var CounterDef = external_exports.object({
@@ -26703,12 +26714,16 @@ var ChecklistItem = external_exports.union([
   external_exports.string().min(1),
   external_exports.object({
     text: external_exports.string().min(1).describe("The point to tick off."),
+    optional: external_exports.boolean().optional().describe("May be left unticked: closing the unit does not wait for it. For boxes that record an outcome rather than promise one."),
+    tally: Id.optional().describe(
+      "Each box ticked under this point adds one to this counter, and unticking takes it back. With `shows`, one box per result; without, the point's own box."
+    ),
     shows: external_exports.object({
       table: external_exports.string().describe("Results from this table are listed under the item."),
       scope: external_exports.enum(["unit", "subject", "run"]).default("unit").describe(
         "Which results: those rolled this unit, those that reached this unit's subject, or every one in the run."
       )
-    }).strict().describe("What to look at while ticking this: a table's results, listed under the point with a box each.")
+    }).strict().optional().describe("What to look at while ticking this: a table's results, listed under the point with a box each.")
   }).strict().describe("A point with the results it is about shown beneath it.")
 ]).describe("A point to tick off: plain text, or text with the table results it is about.");
 var Step = external_exports.discriminatedUnion("kind", [
@@ -26844,6 +26859,16 @@ var Mode = external_exports.object({
   ).optional().describe(
     "Per-unit overrides, for modes with a fixed shape \u2014 'unit three always suffers a consequence', and the like."
   ),
+  moderated: external_exports.object({
+    contestants: external_exports.object({
+      min: external_exports.number().int().min(1).default(2).describe("Fewest contestants."),
+      max: external_exports.number().int().min(1).default(10).describe("Most contestants.")
+    }).strict().default({ min: 2, max: 10 }).describe("How many people race. The moderator is not one of them."),
+    award: external_exports.enum(["first", "everyone"]).default("first").describe("Whether only the first to finish a challenge scores it, or everyone who finishes does."),
+    firstBonus: external_exports.number().int().min(0).default(0).describe("Extra points for finishing first, on top of the result's own. Meaningful with `everyone`.")
+  }).strict().optional().describe(
+    "Moderated play: one person runs the game on the device, a roster of named contestants races every drawn result, and the moderator awards points. Results with `points` are the challenges; everything else lands on everyone."
+  ),
   notes: external_exports.array(external_exports.string()).optional().describe("Reminders shown to the player in this mode.")
 }).strict().describe(
   "A set of deltas over the base ruleset. Keeping modes as deltas rather than separate rulesets is what stops them drifting apart as the pack evolves."
@@ -26856,6 +26881,9 @@ var MoveDef = external_exports.object({
   ),
   oncePerRun: external_exports.boolean().default(false).describe("Whether the move is spent after a single use."),
   do: external_exports.array(Action).min(1).describe("What happens when the player takes it."),
+  finalizes: external_exports.boolean().optional().describe(
+    "Taking this move also closes the current unit: the rest of its flow is recorded as done and the unit is finalized. For moves that are outcomes, like landed or missed, so the player is not asked to close the unit a second time."
+  ),
   /** Where the move belongs in the interface. */
   when: external_exports.enum(["anytime", "betweenUnits", "beforeEnding"]).default("anytime").describe(
     "When the move is offered: at any point, only between units, or only when the player is deciding whether to stop."
@@ -27332,6 +27360,9 @@ function lintPack(pack) {
           }
         }
       }
+      if ("phaseDone" in p && !pack.phases.some((ph) => ph.id === p.phaseDone)) {
+        d.push(err("ref/unknown-phase", site.path, `predicate references unknown phase ${p.phaseDone}`));
+      }
     });
   }
   const seenPhaseIds = /* @__PURE__ */ new Set();
@@ -27350,8 +27381,11 @@ function lintPack(pack) {
       }
       const points = step.kind === "manual" ? step.checklist : step.kind === "finalizeUnit" ? step.confirm : void 0;
       points?.forEach((item, ii) => {
-        if (typeof item !== "string" && !tableIds.has(item.shows.table)) {
-          const field = step.kind === "manual" ? "checklist" : "confirm";
+        const field = step.kind === "manual" ? "checklist" : "confirm";
+        if (typeof item !== "string" && item.tally && !counterIds.has(item.tally)) {
+          d.push(err("ref/unknown-counter", `${path}.${field}[${ii}]`, `tallies unknown counter ${item.tally}`));
+        }
+        if (typeof item !== "string" && item.shows && !tableIds.has(item.shows.table)) {
           d.push(err("ref/unknown-table", `${path}.${field}[${ii}]`, `shows unknown table ${item.shows.table}`));
         }
       });
@@ -27535,6 +27569,17 @@ function lintPack(pack) {
       );
     }
   };
+  const moderatedModes = Object.values(pack.modes).filter((m) => m.moderated);
+  const scoringEntries = Object.values(pack.tables).some((t) => t.entries.some((e) => (e.points ?? 0) > 0));
+  requireCap("moderated", moderatedModes.length > 0, "has a moderated mode");
+  if (moderatedModes.length > 0 && !scoringEntries) {
+    d.push(warn("mode/nothing-to-award", "modes", "a mode is moderated, but no table entry carries points, so there is nothing to award"));
+  }
+  for (const [modeId, m] of Object.entries(pack.modes)) {
+    if (m.moderated && m.moderated.contestants.max < m.moderated.contestants.min) {
+      d.push(err("mode/contestant-range", `modes.${modeId}.moderated.contestants`, `max (${m.moderated.contestants.max}) is below min (${m.moderated.contestants.min})`));
+    }
+  }
   requireCap("decks", usesDecks, "uses decks");
   requireCap("resources", usesResources, "uses resources");
   requireCap("counters", counterIds.size > 0, "declares counters");
@@ -27593,7 +27638,8 @@ var IMPLEMENTED_CAPABILITIES = [
   "journal",
   "bandsResolution",
   "opposedResolution",
-  "keyedResolution"
+  "keyedResolution",
+  "moderated"
 ];
 function parsePack(input2) {
   if (typeof input2 !== "object" || input2 === null) {
@@ -27969,6 +28015,7 @@ function predicateInWords(pack, p) {
   if ("subjectHasState" in p) return `${targetInWords(pack, p.of)} is ${label(pack, "states", p.subjectHasState)}`;
   if ("priorSubjectTagged" in p) return `an earlier ${n.subject} was tagged \u201C${p.priorSubjectTagged}\u201D`;
   if ("modeIs" in p) return `playing ${p.modeIs.map((m) => label(pack, "modes", m)).join(" or ")}`;
+  if ("phaseDone" in p) return `${pack.phases.find((ph) => ph.id === p.phaseDone)?.label ?? p.phaseDone} is done`;
   if ("not" in p) return `not (${predicateInWords(pack, p.not)})`;
   if ("allOf" in p) return p.allOf.map((q) => predicateInWords(pack, q)).join(" and ");
   if ("anyOf" in p) return p.anyOf.map((q) => predicateInWords(pack, q)).join(" or ");
@@ -28085,6 +28132,11 @@ function modeLength(pack, mode) {
   return `as many ${n.units} as you like${max ? `, up to ${max}` : ""}`;
 }
 function modePlayers(mode) {
+  const m = mode.moderated;
+  if (m) {
+    const n = m.contestants.min === m.contestants.max ? `${m.contestants.min}` : `${m.contestants.min}\u2013${m.contestants.max}`;
+    return `moderated, ${n} contestants, ${m.award === "everyone" ? "everyone who finishes scores" : "first to finish scores"}${m.firstBonus ? ` (+${m.firstBonus} for first)` : ""}`;
+  }
   const p = mode.players;
   if (!p || p.min <= 1 && p.max <= 1) return "solo";
   return p.min === p.max ? `${p.min} players` : `${p.min}\u2013${p.max} players`;
@@ -28273,7 +28325,8 @@ function tableRows(pack, table, opts) {
       if (e.requires?.length) extras.push(`Only if ${conditionsInWords(pack, e.requires)}; otherwise roll again.`);
     }
     const text = [e.title ? `${e.title}. ` : "", sentence(e.text), ...extras.map((x) => ` ${x}`)].join("");
-    return [keys[i] ?? "", text];
+    const pts = e.points !== void 0 && e.points > 0 ? `${keys[i] ?? ""} \xB7 ${e.points} pt${e.points === 1 ? "" : "s"}` : keys[i] ?? "";
+    return [pts, text];
   });
 }
 function license(pack) {
@@ -28370,7 +28423,7 @@ function rulebookDoc(pack) {
       states.map(([, s]) => [
         s.short ? `${s.label} (${s.short})` : s.label,
         s.scope === "run" ? `the ${n.run}` : `a ${n.subject}`,
-        [s.description ?? "", ...(s.semantics ?? []).map(semanticInWords)].filter(Boolean).join(" ")
+        [s.description ?? "", ...(s.semantics ?? []).map(semanticInWords), s.group ? `Replaces any other \u201C${s.group}\u201D state.` : ""].filter(Boolean).join(" ")
       ])
     );
   }
@@ -28401,7 +28454,7 @@ function rulebookDoc(pack) {
       moves.map(([, m]) => [
         m.label,
         [whenInWords(m.when, n), m.oncePerRun ? `once per ${n.run}` : "", m.available?.length ? `if ${conditionsInWords(pack, m.available)}` : ""].filter(Boolean).join("; "),
-        [m.description ?? "", sentence(cap(actionsInWords(pack, m.do)))].filter(Boolean).join(" ")
+        [m.description ?? "", sentence(cap(actionsInWords(pack, m.do))), m.finalizes ? `Closes the ${n.unit}.` : ""].filter(Boolean).join(" ")
       ])
     );
   }
@@ -28743,6 +28796,7 @@ function initialState(pack, e) {
     unit: 0,
     phasesDone: [],
     stepsDone: [],
+    checks: [],
     subjects: [],
     runStates: [],
     counters,
@@ -28755,6 +28809,8 @@ function initialState(pack, e) {
     outcomes: [],
     obligations: [],
     firedOnce: [],
+    contestants: [],
+    awards: [],
     ending: null
   };
 }
@@ -28824,6 +28880,7 @@ function reduce(pack, log) {
         state.unit += 1;
         state.phasesDone = [];
         state.stepsDone = [];
+        state.checks = [];
         resetThisUnit = /* @__PURE__ */ new Set();
         if (state.forcedUnits > 0) state.forcedUnits -= 1;
         if (pack.unit.createsSubject) {
@@ -28861,12 +28918,18 @@ function reduce(pack, log) {
         });
         break;
       case "StateApplied": {
-        const scope = pack.states?.[event.state]?.scope ?? "subject";
+        const def = pack.states?.[event.state];
+        const scope = def?.scope ?? "subject";
+        const rivals = (held) => def?.group ? held.filter((s) => s === event.state || pack.states?.[s]?.group !== def.group) : held;
         if (scope === "run" || event.subject === void 0) {
+          state.runStates = rivals(state.runStates);
           if (!state.runStates.includes(event.state)) state.runStates.push(event.state);
         } else {
           const subject = subjectById(state, event.subject);
-          if (subject && !subject.states.includes(event.state)) subject.states.push(event.state);
+          if (subject) {
+            subject.states = rivals(subject.states);
+            if (!subject.states.includes(event.state)) subject.states.push(event.state);
+          }
         }
         break;
       }
@@ -28955,6 +29018,40 @@ function reduce(pack, log) {
         state.status = "ended";
         state.ending = event.ending;
         break;
+      case "ContestantAdded":
+        if (!state.contestants.some((c) => c.id === event.contestant)) {
+          state.contestants.push({ id: event.contestant, name: event.name });
+        }
+        break;
+      case "ContestantRemoved":
+        state.contestants = state.contestants.filter((c) => c.id !== event.contestant);
+        break;
+      case "Awarded":
+        if (!state.awards.some((a) => a.contestant === event.contestant && a.outcome === event.outcome)) {
+          state.awards.push({
+            contestant: event.contestant,
+            outcome: event.outcome,
+            table: event.table,
+            entryId: event.entryId,
+            points: event.points,
+            at: event.at
+          });
+        }
+        break;
+      case "AwardRevoked":
+        state.awards = state.awards.filter((a) => !(a.contestant === event.contestant && a.outcome === event.outcome));
+        break;
+      case "Checked": {
+        const key = `${event.step}|${event.item}`;
+        if (event.on) {
+          if (!state.checks.includes(key)) state.checks.push(key);
+        } else {
+          state.checks = state.checks.filter((k) => k !== key);
+        }
+        break;
+      }
+      case "Corrected":
+        break;
       case "Undone":
         break;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrthq/runlog",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "Validate, lint, bundle and test Runlog rule packs.",
   "type": "module",
   "license": "MIT",