v0.4.4 — New Game dialog for the opening hand and the three revenue rates, Yard renamed Interchange, and two movement bugs behind a mirrored consist

src/web/main.ts

@@ -12,7 +12,8 @@ import type { Menu, Save } from './game.ts';
 import { PANEL_CSS, blockedHtml, facilitiesHtml, pilesHtml, timetableHtml, yardHtml } from './panels.ts';
 import { TOOLTIP_CSS, installTooltips } from './tooltip.ts';
 import { playCue } from './sound.ts';
-import { MOVES_PER_LOCAL_OPS } from '../engine/content.ts';
+import { MOVES_PER_LOCAL_OPS, STARTING_HAND_LABELS, houseRules } from '../engine/content.ts';
+import type { HouseRuleOverrides, HouseRules, RevenueRules, StartingHand } from '../engine/content.ts';
 import type { LocalSession } from './session.ts';
 import { createLocalSession } from './session.ts';
 
@@ -112,14 +113,73 @@ function renderTurnChart(f: Frame): void {
   $('turnchart').innerHTML = turnChartHtml(f, actorName);
 }
 
+/**
+ * The settings this game was dealt under, beside the seed, because the seed alone does not name it.
+ *
+ * Abbreviated to fit a header that must not wrap — `3 cards · 1/1/0` — with the whole of it in the
+ * tooltip. Written down at all because a playtest note is worthless without it: "scored 4" means one
+ * thing at 1 Revenue per transit and another at 5.
+ */
+function renderHouseRules(rules: HouseRules): void {
+  const { passengerPerCoach: pax, freightPerLoad: frt, trainPerTransit: trn } = rules.revenue;
+  const short = { threeRandom: '3 cards', sixRandom: '6 cards', threeTrackThreeOther: '3+3 cards' };
+  const el = $('houserules');
+  el.textContent = `· ${short[rules.startingHand]} · ${pax}/${frt}/${trn}`;
+  const handWords = STARTING_HAND_LABELS.find((o) => o.value === rules.startingHand)?.label ?? '';
+  el.title =
+    `Opening hand: ${handWords.toLowerCase()}.\n` +
+    `Passenger revenue per coach: ${pax} (paid on boarding and again on detraining).\n` +
+    `Freight revenue per load: ${frt} (paid on loading and again on unloading).\n` +
+    `Train revenue per transit: ${trn} (paid to every player when a train leaves the Division).`;
+}
+
+/**
+ * THE HOUSE RULES TRAVEL IN THE URL, BESIDE THE SEED.
+ *
+ * A seed on its own no longer names a game: `?seed=430` dealt three random cards is a different
+ * railroad from `?seed=430` dealt three track and three other, and at 0 Revenue per transit it is a
+ * different economy again. The link has to carry all of it or "same link, same deal" stops being
+ * true — and the New Game dialog navigates by URL, so this is also how its answers reach `start()`.
+ *
+ * Absent parameters mean the DEFAULTS, not the legacy rules: a bare `?seed=430` is a new game at
+ * today's settings. It is a save with no rules in it that is old (`game.ts`, `configFor`).
+ */
+const RULE_PARAMS = { passenger: 'passengerPerCoach', freight: 'freightPerLoad', transit: 'trainPerTransit' } as const;
+
+function rulesFromUrl(params: URLSearchParams): HouseRuleOverrides {
+  const rules: HouseRuleOverrides = {};
+  const hand = params.get('hand');
+  if (STARTING_HAND_LABELS.some((o) => o.value === hand)) rules.startingHand = hand as StartingHand;
+
+  const revenue: Partial<RevenueRules> = {};
+  for (const [param, key] of Object.entries(RULE_PARAMS)) {
+    const raw = params.get(param);
+    // `houseRules()` clamps and rounds, so anything hand-edited into the URL lands in range rather
+    // than dealing a game at 900 Revenue a coach.
+    if (raw !== null && raw.trim() !== '' && Number.isFinite(Number(raw))) revenue[key] = Number(raw);
+  }
+  if (Object.keys(revenue).length > 0) rules.revenue = revenue;
+  return rules;
+}
+
+function rulesToUrl(rules: HouseRules, seed: string): string {
+  const params = new URLSearchParams();
+  if (seed !== '') params.set('seed', seed);
+  params.set('hand', rules.startingHand);
+  for (const [param, key] of Object.entries(RULE_PARAMS)) params.set(param, String(rules.revenue[key]));
+  return `?${params}`;
+}
+
 function start(): void {
   const params = new URLSearchParams(location.search);
   const requested = params.get('seed');
 
   // A seed in the URL makes a game shareable and reproducible: same link, same deal.
   const seed = requested !== null ? Number(requested) || 1 : Math.floor(Math.random() * 1e9);
-  session = createLocalSession(seed);
+  session = createLocalSession(seed, rulesFromUrl(params));
 
+  // A saved game carries its OWN rules and re-deals itself under them, whatever the URL says — see
+  // `configFor`. That is why the restore happens after the session is built rather than feeding it.
   const saved = load();
   if (saved && requested === null) session.restore(saved);
 
@@ -185,6 +245,7 @@ function render(): void {
   obj.textContent = `${f.revenue} of ${f.objective.target} · ${f.objective.daysLeft} Day${f.objective.daysLeft === 1 ? '' : 's'} left`;
   obj.className = 'pace';
   $('seed').textContent = String(session.seed());
+  renderHouseRules(f.houseRules);
 
   // -- division
   $('division').innerHTML = divisionSvg(f.division);
@@ -828,35 +889,76 @@ if (saveBtn) saveBtn.onclick = downloadSave;
  * steps back one action at a time, but nothing brings back a game that has been dealt over, and the
  * replay download is right beside it.
  *
- * `location.search = ''` rather than a direct re-render, so a `?seed=` in the URL goes too — leaving
- * it would deal the same game again and look like the button had done nothing.
+ * Navigating rather than re-rendering, so a stale `?seed=` in the URL goes too — leaving it would
+ * deal the same game again and look like the button had done nothing.
  */
 const newBtn = document.getElementById('newgame');
-if (newBtn) {
+const dlg = document.getElementById('newgamedlg') as HTMLDialogElement | null;
+if (newBtn && dlg) {
+  const field = <T extends HTMLElement>(id: string): T => document.getElementById(id) as T;
+
+  /**
+   * ASK FOR ALL THREE, rather than documenting URL parameters in the title bar.
+   *
+   * It asked for the seed alone, through `prompt()`. The opening hand and the three revenue rates
+   * were constants in the source, so trying a variation meant an edit and a rebuild — and balance is
+   * the open question this game has (`TODO.md`). A dialog is what lets a playtest be a playtest.
+   *
+   * The dialog OPENS ON THE RULES IN PLAY rather than on the defaults: dealing a second game to
+   * compare against the first is the common case, and re-entering four settings each time is how a
+   * comparison silently stops comparing.
+   */
   newBtn.onclick = () => {
     const f = session.view();
     const day = f.day;
     const started = f.status === 'active' && (day > 1 || f.stage > 1);
     if (started && !confirm(`Forget this game (seed ${session.seed()}, Day ${day}) and deal a new one?`)) return;
-    /**
-     * ASK FOR THE SEED, rather than documenting a URL parameter in the title bar.
-     *
-     * The same deal can be replayed, shared or compared by seed, which is worth offering — it was
-     * offered as the note "add ?seed=1234 for a set deal", which spent width on the one line that
-     * must not wrap to explain a thing the button could simply ask. Blank means random.
-     */
-    const asked = prompt('Seed for the new game — leave blank for a random one:', '');
-    if (asked === null) return; // cancelled
-    clearSave();
-    const wanted = asked.trim();
-    if (wanted === '') {
-      // No `?seed=`, so `start()` rolls one. Reload rather than re-render, to clear any seed in the URL.
-      if (location.search === '') location.reload();
-      else location.search = '';
-      return;
+
+    const current = session.view().houseRules;
+    field<HTMLInputElement>('ng-seed').value = '';
+    for (const input of dlg.querySelectorAll<HTMLInputElement>('input[name="ng-hand"]')) {
+      input.checked = input.value === current.startingHand;
     }
-    location.search = `?seed=${encodeURIComponent(wanted)}`;
+    field<HTMLInputElement>('ng-passenger').value = String(current.revenue.passengerPerCoach);
+    field<HTMLInputElement>('ng-freight').value = String(current.revenue.freightPerLoad);
+    field<HTMLInputElement>('ng-transit').value = String(current.revenue.trainPerTransit);
+    dlg.showModal();
   };
+
+  /**
+   * One handler for every way the dialog can close — the Deal button, the Cancel button, and Esc,
+   * which `<dialog>` answers with an empty `returnValue` and no submit event at all.
+   *
+   * The answers go into the URL and the page navigates, which is the same path `?seed=` already
+   * took: `start()` reads them back, so there is exactly one place that turns a URL into a game.
+   */
+  dlg.addEventListener('close', () => {
+    if (dlg.returnValue !== 'deal') return;
+
+    const asked = field<HTMLInputElement>('ng-seed').value.trim();
+    // A seed the browser cannot parse is not a reason to refuse to deal — blank and unparseable
+    // both mean "surprise me", which is what leaving the box alone plainly asks for.
+    const seed = asked === '' || !Number.isFinite(Number(asked)) ? '' : String(Math.trunc(Number(asked)));
+    const picked = dlg.querySelector<HTMLInputElement>('input[name="ng-hand"]:checked')?.value;
+    const rules = houseRules({
+      houseRules: {
+        ...(STARTING_HAND_LABELS.some((o) => o.value === picked) ? { startingHand: picked as StartingHand } : {}),
+        revenue: {
+          passengerPerCoach: Number(field<HTMLInputElement>('ng-passenger').value),
+          freightPerLoad: Number(field<HTMLInputElement>('ng-freight').value),
+          trainPerTransit: Number(field<HTMLInputElement>('ng-transit').value),
+        },
+      },
+    });
+
+    clearSave();
+    const next = rulesToUrl(rules, seed);
+    // Assigning the search string the page ALREADY has does nothing at all, which reads as a button
+    // that did not work — and it is the common case: deal a random seed, decide it was a bad deal,
+    // deal another at the same settings. Reload instead, and `start()` rolls a fresh seed.
+    if (next === location.search) location.reload();
+    else location.search = next;
+  });
 }
 
 const soundBtn = document.getElementById('sound');