@scrthq/runlog 0.0.45 → 0.0.46

package/dist/runlog.js

@@ -26718,6 +26718,12 @@ var ResourceDef = external_exports.object({
 }).strict().describe(
   "A numeric track the player fills or spends: a progress clock, a word count, training volume, stock on hand."
 );
+var Clock = external_exports.object({
+  kind: external_exports.enum(["stopwatch", "timer"]).describe("A stopwatch counts up from the start of the unit; a timer counts down from `minutes`."),
+  minutes: external_exports.number().positive().max(24 * 60).optional().describe("How long a timer runs. Required for a timer; ignored by a stopwatch."),
+  label: external_exports.string().optional().describe("What the clock is called on screen. Defaults to the unit's name and number."),
+  auto: external_exports.boolean().default(true).describe("Start it when the unit is entered and stop it when the unit closes. Off, the player starts it by hand; it still stops with the unit.")
+}).strict().refine((c) => c.kind !== "timer" || c.minutes !== void 0, { message: "a timer needs minutes", path: ["minutes"] }).describe("A clock the unit runs: `stopwatch` to time it, `timer` with `minutes` to limit it. The time lands in the log when the unit closes.");
 var Requirement = external_exports.object({
   id: Id.describe("Unique among requirements. Table entries name it in `needs`."),
   label: external_exports.string().min(1).describe("What it is, in the words a person would use: Rocket League, a potter's wheel, an oven."),
@@ -26875,6 +26881,7 @@ 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."
   ),
+  clock: Clock.optional().describe("This mode's clock on every unit, instead of the pack's `unit.clock`."),
   moderated: external_exports.object({
     contestants: external_exports.object({
       min: external_exports.number().int().min(1).default(2).describe("Fewest contestants."),
@@ -26969,6 +26976,7 @@ var Pack = external_exports.object({
   ),
   vocabulary: Vocabulary,
   unit: external_exports.object({
+    clock: Clock.optional().describe("A clock every unit runs. A mode can set its own with `clock`."),
     createsSubject: external_exports.boolean().default(true).describe("Whether entering a unit produces a new subject."),
     min: external_exports.number().int().min(1).default(1).describe("Fewest units in a run."),
     max: external_exports.number().int().min(1).default(20).describe("Most units in a run.")
@@ -27316,6 +27324,7 @@ function lintPack(pack) {
           }
           usesDecks = true;
           break;
+        case "startStopwatch":
         case "startTimer":
           usesTimers = true;
           break;
@@ -27619,7 +27628,8 @@ function lintPack(pack) {
   requireCap("decks", usesDecks, "uses decks");
   requireCap("resources", usesResources, "uses resources");
   requireCap("counters", counterIds.size > 0, "declares counters");
-  requireCap("timers", usesTimers, "starts timers");
+  const unitClock = Boolean(pack.unit.clock) || Object.values(pack.modes).some((m) => m.clock);
+  requireCap("timers", usesTimers || unitClock, "runs a clock");
   requireCap(
     "backwardTargeting",
     usesResolveTarget || !!pack.targeting && pack.targeting.strategy !== "none",
@@ -27994,6 +28004,14 @@ function howConsulted(table) {
       return "Find the row whose key matches what was drawn.";
   }
 }
+function an(word, capital = false) {
+  const w = word.trim().toLowerCase();
+  const vowel = /^[aeiou]/.test(w);
+  const soundsConsonant = /^(u[^aeiou]|un[aeiou]|uni|use|usu|ute|eu|one(?![a-z])|onc)/.test(w) || /^u[st][aeiou]/.test(w);
+  const silentH = /^(hour|honest|honor|heir|herb)/.test(w);
+  const article = vowel && !soundsConsonant || silentH ? "an" : "a";
+  return `${capital ? article[0].toUpperCase() + article.slice(1) : article} ${word}`;
+}
 function nouns(pack) {
   const v = pack.vocabulary;
   return {
@@ -28110,6 +28128,8 @@ function actionInWords(pack, a) {
     }
     case "startTimer":
       return a.label ? `${a.label} (${a.minutes} min)` : `start a ${a.minutes}-minute timer`;
+    case "startStopwatch":
+      return a.label ? `start the ${a.label} stopwatch` : "start a stopwatch";
     case "note":
       return a.text;
     case "setFlag":
@@ -28138,7 +28158,7 @@ function triggerPointInWords(pack, on) {
     case "immediately":
       return "Then";
     case "onEnterUnit":
-      return `When a ${n.unit} begins`;
+      return `When ${an(n.unit)} begins`;
     case "onDeclareSubject":
       return `When the ${n.subject} is declared`;
     case "afterWork":
@@ -28309,7 +28329,8 @@ function whatYouNeed(pack) {
     if (deck.kind === "standard52") items.push(`A standard deck of playing cards${deck.includeJokers ? " with the jokers in" : ""}.`);
     else items.push(`${plural(deck.cards.length, "card", "cards")} for ${deck.title} \u2014 write them out, or use the app.`);
   }
-  if (pack.capabilities.includes("timers")) items.push("A timer.");
+  if (pack.capabilities.includes("timers") && !pack.unit.clock) items.push("A timer.");
+  if (pack.unit.clock) items.push(pack.unit.clock.kind === "timer" ? `A clock: every ${n.unit} is timed, ${pack.unit.clock.minutes} minutes. The app keeps it.` : `A clock: every ${n.unit} is timed. The app keeps it.`);
   items.push(pack.journal?.enabled === false ? `Somewhere to keep the ${n.run} log.` : `Somewhere to keep the ${n.run} log \u2014 the run log sheet, or the app.`);
   return items;
 }
@@ -28385,7 +28406,7 @@ function summaryDoc(pack) {
   b.h(2, "How it plays");
   const unitRange = `${pack.unit.min === pack.unit.max ? pack.unit.min : `${pack.unit.min}\u2013${pack.unit.max}`}`;
   b.p(
-    `A ${n.run} is a series of ${n.units}${pack.unit.createsSubject ? `, each producing a ${n.subject}` : ""}; ${unitRange} of them, depending on the mode. Each ${n.unit} moves through ${plural(pack.phases.length, "phase", "phases")}: ${pack.phases.map((p) => p.label).join(", ")}.`
+    `${an(n.run, true)} is a series of ${n.units}${pack.unit.createsSubject ? `, each producing ${an(n.subject)}` : ""}; ${unitRange} of them, depending on the mode. Each ${n.unit} moves through ${plural(pack.phases.length, "phase", "phases")}: ${pack.phases.map((p) => p.label).join(", ")}.`
   );
   b.table(["Mode", "Length", "Players", "About"], modeRows(pack, { notes: false }));
   b.h(2, "What is inside");
@@ -28395,7 +28416,7 @@ function summaryDoc(pack) {
   if (tables.length) parts.push(`${plural(tables.length, "table", "tables")}: ${tables.map((t) => `${t.title} (${howConsulted(t).replace(/\.$/, "").toLowerCase()}, ${plural(t.entries.length, "entry", "entries")})`).join("; ")}.`);
   if (decks.length) parts.push(`${plural(decks.length, "deck", "decks")}: ${decks.map((d) => d.kind === "cards" ? `${d.title} (${plural(d.cards.length, "card", "cards")})` : `${d.title} (a standard deck)`).join("; ")}.`);
   const states = Object.values(pack.states ?? {});
-  if (states.length) parts.push(`${plural(states.length, "state", "states")} a ${n.subject} or ${n.run} can carry: ${states.map((s) => s.label).join(", ")}.`);
+  if (states.length) parts.push(`${plural(states.length, "state", "states")} ${an(n.subject)} or ${n.run} can carry: ${states.map((s) => s.label).join(", ")}.`);
   const counters = Object.values(pack.counters ?? {}).filter((c) => !c.hidden);
   if (counters.length) parts.push(`${plural(counters.length, "tally", "tallies")}: ${counters.map((c) => c.label).join(", ")}.`);
   const resources = Object.values(pack.resources ?? {});
@@ -28420,14 +28441,14 @@ function rulebookDoc(pack) {
   b.list(whatYouNeed(pack));
   b.h(2, "Terms");
   b.terms([
-    { term: cap(n.run), text: `One session of play. A ${n.run} is a series of ${n.units}, and ends when you say so or when the game does.` },
+    { term: cap(n.run), text: `One session of play. ${an(n.run, true)} is a series of ${n.units}, and ends when you say so or when the game does.` },
     { term: cap(n.unit), text: `One round. Every ${n.unit} passes through the same phases${pack.unit.createsSubject ? ` and produces one ${n.subject}` : ""}.` },
-    ...pack.unit.createsSubject ? [{ term: cap(n.subject), text: `The thing a ${n.unit} makes. States attach to it, and consequences can land on it later.` }] : [],
-    { term: cap(n.finalize), text: `Closing a ${n.unit}. Once ${n.finalize.toLowerCase()}d, what it made is fixed unless a rule says otherwise.` },
+    ...pack.unit.createsSubject ? [{ term: cap(n.subject), text: `The thing ${an(n.unit)} makes. States attach to it, and consequences can land on it later.` }] : [],
+    { term: cap(n.finalize), text: `Closing ${an(n.unit)}. Once ${n.finalize.toLowerCase()}d, what it made is fixed unless a rule says otherwise.` },
     ...Object.entries(pack.vocabulary.terms ?? {}).map(([term, text]) => ({ term, text }))
   ]);
   if (pack.hierarchy?.length) b.p(`When rules contradict each other, the more specific wins, in this order: ${pack.hierarchy.join(" > ")}.`, "note");
-  b.h(2, `A ${n.unit}, step by step`);
+  b.h(2, `${an(n.unit, true)}, step by step`);
   b.list(flowSteps(pack, { detail: true }), true);
   if (pack.journal?.enabled !== false) b.p(`${pack.journal?.prompt ? `After each ${n.unit}: \u201C${pack.journal.prompt}\u201D` : `Keep a line of notes per ${n.unit}.`}${pack.journal?.required ? " A note is required before moving on." : ""}`);
   b.h(2, "Modes");
@@ -28462,7 +28483,7 @@ function rulebookDoc(pack) {
       ["State", "On", "Means"],
       states.map(([, s]) => [
         s.short ? `${s.label} (${s.short})` : s.label,
-        s.scope === "run" ? `the ${n.run}` : s.scope === "contestant" ? "a contestant" : `a ${n.subject}`,
+        s.scope === "run" ? `the ${n.run}` : s.scope === "contestant" ? "a contestant" : an(n.subject),
         [s.description ?? "", ...(s.semantics ?? []).map(semanticInWords), s.group ? `Replaces any other \u201C${s.group}\u201D state.` : "", s.until === "unitEnd" ? `Lifts when the ${n.unit} closes.` : ""].filter(Boolean).join(" ")
       ])
     );
@@ -28507,7 +28528,7 @@ function rulebookDoc(pack) {
     b.list(pack.triggers.map((t) => sentence(cap(triggerInWords(pack, t)))));
   }
   if (pack.endings?.length) {
-    b.h(2, `Ending a ${n.run}`);
+    b.h(2, `Ending ${an(n.run)}`);
     b.terms(pack.endings.map((e) => ({ term: e.label, text: [e.text ?? "", e.requires?.length ? `Available when ${conditionsInWords(pack, e.requires)}.` : ""].filter(Boolean).join(" ") })));
   }
   return { kind: "rulebook", layout: "book", title: pack.title, subtitle: byline(pack), blocks: b.blocks };
@@ -28519,7 +28540,7 @@ function quickstartDoc(pack) {
   b.h(2, "What you need");
   b.list(whatYouNeed(pack));
   b.h(2, "The words");
-  b.p(`A ${n.run} is one session. It is made of ${n.units}${pack.unit.createsSubject ? `, and each ${n.unit} makes one ${n.subject}` : ""}. Closing a ${n.unit} is called \u201C${n.finalize}\u201D.`);
+  b.p(`${an(n.run, true)} is one session. It is made of ${n.units}${pack.unit.createsSubject ? `, and each ${n.unit} makes one ${n.subject}` : ""}. Closing a ${n.unit} is called \u201C${n.finalize}\u201D.`);
   b.h(2, `Each ${n.unit}`);
   b.list(flowSteps(pack, { detail: false }), true);
   const d = pack.modes[pack.defaultMode];
@@ -28850,6 +28871,7 @@ function initialState(pack, e) {
     obligations: [],
     firedOnce: [],
     lacks: e.lacks ?? [],
+    clocks: [],
     contestants: [],
     awards: [],
     ending: null
@@ -29063,6 +29085,50 @@ function reduce(pack, log) {
         state.status = "ended";
         state.ending = event.ending;
         break;
+      case "ClockStarted":
+        if (!state.clocks.some((c) => c.id === event.clock)) {
+          state.clocks.push({
+            id: event.clock,
+            kind: event.kind,
+            label: event.label,
+            seconds: event.kind === "timer" ? event.seconds ?? null : null,
+            unit: state.unit,
+            status: "running",
+            startedAt: event.at,
+            runningSince: event.at,
+            accumulatedMs: 0,
+            elapsedMs: null,
+            expired: false
+          });
+        }
+        break;
+      case "ClockPaused": {
+        const c = state.clocks.find((x) => x.id === event.clock);
+        if (c && c.status === "running" && c.runningSince) {
+          c.accumulatedMs += Math.max(0, Date.parse(event.at) - Date.parse(c.runningSince));
+          c.runningSince = null;
+          c.status = "paused";
+        }
+        break;
+      }
+      case "ClockResumed": {
+        const c = state.clocks.find((x) => x.id === event.clock);
+        if (c && c.status === "paused") {
+          c.runningSince = event.at;
+          c.status = "running";
+        }
+        break;
+      }
+      case "ClockStopped": {
+        const c = state.clocks.find((x) => x.id === event.clock);
+        if (c && c.status !== "done") {
+          c.elapsedMs = event.elapsedMs;
+          c.runningSince = null;
+          c.status = "done";
+          c.expired = event.expired === true;
+        }
+        break;
+      }
       case "ContestantAdded":
         if (!state.contestants.some((c) => c.id === event.contestant)) {
           state.contestants.push({ id: event.contestant, name: event.name, states: [] });

package/package.json

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