@nano133/nanoterra 0.4.0 → 0.6.0

package/src/admin/panel/shelf.ts

@@ -10,7 +10,7 @@ import { diffLooks, removalProblems } from "../../looks/change.js";
 import { SLOTS_MAX } from "../../looks/look.js";
 import { looksJson, slugId } from "../../looks/json.js";
 import { PRICE_LADDER, priceText, rungOf, rungUsd } from "../../looks/ladder.js";
-import { COLOR_PATTERN, HATS, lookProblems, usdText, type Hat, type Look, type Problem } from "../../looks/look.js";
+import { COLOR_PATTERN, HATS, isOutfit, lookProblems, OUTFIT, SLOT_NAME_PATTERN, usdText, wearOf, type Change, type Hat, type Look, type Problem } from "../../looks/look.js";
 import { copy, dollars, h, plural } from "./dom.js";
 import { icon } from "./icons.js";
 import { aiPrompt, changeText, ownedIds, shelfStats, soldText, type LookStats, type ShelfOrder, type ShelfPlayer } from "./shelfData.js";
@@ -38,8 +38,23 @@ function hatShapes(hat: Hat, fill: string): Element[] {
   return hats[hat]();
 }
 
-/** A small flat picture of a look: the body in its colour and the hat in its colour. (The game draws the real character; a game can give its own picture.) */
+/**
+ * A small flat picture of a look: an outfit's body in its colour and its hat in its colour; an item of another wear slot as a tag with the slot's name (the game
+ * knows what the item is). (The game draws the real thing; a game can give its own picture.)
+ */
 export function lookPicture(l: Look): Element {
+  if (!isOutfit(l)) {
+    const wear = wearOf(l);
+    const label = svg("text", { x: 33, y: 40, "font-size": 9, "font-family": "system-ui, sans-serif", "text-anchor": "middle", fill: INK });
+    label.textContent = wear.slice(0, 8);
+    return svg(
+      "svg",
+      { viewBox: "0 0 64 72", width: 56, height: 63, role: "img", "aria-label": `${l.name}: worn in the ${wear} slot` },
+      shape("path", { d: "M14 20 L36 20 L52 36 L36 52 L14 52 Z", fill: "#f6e7c1" }),
+      shape("circle", { cx: 22, cy: 36, r: 3.5, fill: "#ffffff" }),
+      label,
+    );
+  }
   const hat = l.change.hat;
   return svg(
     "svg",
@@ -72,7 +87,7 @@ export function previewPicture(load: () => Promise<(l: Look) => Promise<string |
   return (l) => {
     const box = h("span", { class: "shelf-preview" }, fallback(l));
     ready ??= load().catch(() => null);
-    const look: Look = { ...l, change: { ...l.change }, ...(l.slots ? { slots: { ...l.slots } } : {}) };
+    const look = copyLook(l);
     void ready
       .then((render) => (render ? render(look) : null))
       .then((src) => {
@@ -85,7 +100,9 @@ export function previewPicture(load: () => Promise<(l: Look) => Promise<string |
   };
 }
 
-const clone = (ls: readonly Look[]): Look[] => ls.map((l) => ({ id: l.id, name: l.name, priceUsd: l.priceUsd, change: { ...l.change }, ...(l.slots ? { slots: { ...l.slots } } : {}) }));
+/** A copy of a look that shares nothing with it: its wear slot, an outfit's change, its slots. */
+const copyLook = (l: Look): Look => ({ id: l.id, name: l.name, priceUsd: l.priceUsd, ...(l.wear !== undefined ? { wear: l.wear } : {}), ...(l.change ? { change: { ...l.change } } : {}), ...(l.slots ? { slots: { ...l.slots } } : {}) });
+const clone = (ls: readonly Look[]): Look[] => ls.map(copyLook);
 
 /** The names of the slots that differ between two looks (added, removed or another value). */
 function slotNamesChanged(before: Look, after: Look): string {
@@ -98,7 +115,8 @@ function fieldWords(d: ReturnType<typeof diffLooks>["changed"][number]): string
     if (f === "name") return `name "${d.before.name}" to "${d.after.name}"`;
     if (f === "priceUsd") return `price ${usdText(d.before.priceUsd)} to ${usdText(d.after.priceUsd)}`;
     if (f === "body") return "body colour";
-    if (f === "hat") return `hat ${d.before.change.hat ?? "none"} to ${d.after.change.hat ?? "none"}`;
+    if (f === "hat") return `hat ${d.before.change?.hat ?? "none"} to ${d.after.change?.hat ?? "none"}`;
+    if (f === "wear") return `wear slot ${wearOf(d.before)} to ${wearOf(d.after)}`;
     if (f === "slots") return `slots changed (${slotNamesChanged(d.before, d.after)})`;
     return "hat colour";
   });
@@ -187,7 +205,12 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
   const stats = () => shelfStats(data.orders, data.players);
   const owned = () => ownedIds(data.players);
   const isOriginal = (id: string) => LOOKS.some((l) => l.id === id);
-  const freeCount = () => draft.filter((l) => l.priceUsd === 0).length;
+  /** Free outfits in the draft: one must stay (every player starts with it). */
+  const freeCount = () => draft.filter((l) => l.priceUsd === 0 && wearOf(l) === OUTFIT).length;
+  /** The wear slots that the draft uses besides the outfit, for the wear slot field's suggestions. */
+  const wearSlots = () => [...new Set(draft.map(wearOf).filter((w) => w !== OUTFIT))].sort();
+  /** What a card says under the price: who has it (a free outfit), what it sold, or that it is new. */
+  const fineWords = (l: Look, s: LookStats | undefined) => (l.priceUsd === 0 && wearOf(l) === OUTFIT ? "Every player starts with it" : soldText(s));
   /** Whether the draft differs from the game's looks.json in any way, the order of the looks too (the file's own text is compared). */
   const changedFromGame = () => looksJson(draft) !== looksJson(LOOKS);
 
@@ -198,7 +221,7 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
   const pictures = new Map<string, Element>();
   let used = new Set<string>();
   function pictureOf(l: Look): Element {
-    const key = JSON.stringify([l.id, l.name, l.priceUsd, l.change, l.slots ?? null]);
+    const key = JSON.stringify([l.id, l.name, l.priceUsd, l.wear ?? null, l.change ?? null, l.slots ?? null]);
     const kept = pictures.get(key);
     if (kept && !used.has(key)) {
       used.add(key);
@@ -331,10 +354,16 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
 
   function stage(l: Look, ...extra: (Node | null)[]): HTMLElement {
     const box = h("div", { class: "shelf-stage" }, h("div", { class: "shelf-pic" }, pictureOf(l)), ...extra);
-    if (COLOR_PATTERN.test(l.change.body)) box.style.setProperty("--tint", l.change.body);
+    const body = l.change?.body;
+    if (body && COLOR_PATTERN.test(body)) box.style.setProperty("--tint", body);
     return box;
   }
 
+  /** An item's wear slot, under its name ("Worn in the shovel slot"); nothing for an outfit. */
+  function wearLine(l: Look): HTMLElement | null {
+    return wearOf(l) === OUTFIT ? null : h("span", { class: "fine shelf-wear" }, `Worn in the ${wearOf(l)} slot`);
+  }
+
   function slotList(l: Look): HTMLElement | null {
     const entries = Object.entries(l.slots ?? {});
     if (!entries.length) return null;
@@ -353,7 +382,8 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
         "div",
         { class: "shelf-body" },
         h("strong", { class: "shelf-name" }, l.name || "(no name)"),
-        h("span", { class: "fine" }, l.priceUsd === 0 ? "Every player starts with it" : soldText(s)),
+        wearLine(l),
+        h("span", { class: "fine" }, fineWords(l, s)),
         share ? h("div", { class: "share", title: `${share}% of the money from sales` }, bar, h("span", { class: "fine" }, `${share}% of sales`)) : null,
         slotList(l),
       ),
@@ -400,7 +430,8 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
         { class: "shelf-body" },
         h("strong", { class: "shelf-name" }, l.name || "(no name)"),
         h("span", { class: "shelf-price" }, priceWords(l.priceUsd)),
-        h("span", { class: "fine" }, isOriginal(l.id) ? (l.priceUsd === 0 ? "Every player starts with it" : soldText(st.get(l.id))) : "New: not in your game yet"),
+        wearLine(l),
+        h("span", { class: "fine" }, isOriginal(l.id) ? fineWords(l, st.get(l.id)) : "New: not in your game yet"),
         marks(l, own, mine, mark),
       ),
       h(
@@ -448,7 +479,7 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
     const stageBox = h("div", { class: "shelf-stage is-big" }, pic);
     const nameLine = h("strong", { class: "shelf-name" }, l.name || "(no name)");
     const priceLine = h("span", { class: "shelf-price" }, priceWords(l.priceUsd));
-    const tint = () => (COLOR_PATTERN.test(l.change.body) ? stageBox.style.setProperty("--tint", l.change.body) : stageBox.style.removeProperty("--tint"));
+    const tint = () => (l.change && COLOR_PATTERN.test(l.change.body) ? stageBox.style.setProperty("--tint", l.change.body) : stageBox.style.removeProperty("--tint"));
     tint();
     // The real picture is drawn a moment after the last change: a colour dragged across the picker draws once, not at every step.
     let later: ReturnType<typeof setTimeout> | null = null;
@@ -459,8 +490,10 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
       if (later) clearTimeout(later);
       later = setTimeout(() => pic.replaceChildren(pictureOf(l)), 150);
       ladder.querySelectorAll<HTMLButtonElement>("button").forEach((c) => c.setAttribute("aria-pressed", Number(c.dataset.usd) === l.priceUsd ? "true" : "false"));
-      swatches.querySelectorAll<HTMLButtonElement>("button").forEach((c) => c.setAttribute("aria-pressed", c.dataset.colour === l.change.body.toLowerCase() ? "true" : "false"));
-      hatChoices.style.setProperty("color", l.change.hatColor ?? "#9aa4b2");
+      if (outfit) {
+        lookParts?.swatches.querySelectorAll<HTMLButtonElement>("button").forEach((c) => c.setAttribute("aria-pressed", c.dataset.colour === outfit.change.body.toLowerCase() ? "true" : "false"));
+        lookParts?.hatChoices.style.setProperty("color", outfit.change.hatColor ?? "#9aa4b2");
+      }
       refreshFoot();
     };
 
@@ -486,6 +519,85 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
     ladder.append(step(0, "Free", "everyone", "Every player has it"));
     for (const r of PRICE_LADDER) ladder.append(step(rungUsd(r), priceText(rungUsd(r)), r.name, `${r.name}: ${r.for}`));
 
+    // An outfit's body colour and hat (an item of another wear slot has neither).
+    const outfit = isOutfit(l) ? l : null;
+    const lookParts = outfit ? outfitFields(outfit, i, sync) : null;
+    const lastFree = l.priceUsd === 0 && wearOf(l) === OUTFIT && freeCount() === 1;
+    const keep = isOriginal(l.id) && own.has(l.id);
+    const remove = h("button", { class: "btn btn-danger", type: "button", disabled: keep || lastFree, title: keep ? "A player owns this look. Keep it in the file." : lastFree ? "Keep one free outfit: every player starts with it." : "", onclick: () => {
+      draft = draft.filter((x) => x !== l);
+      open = null;
+      redraw();
+    } }, icon("trash", 18), "Remove");
+    const dup = h("button", { class: "btn", type: "button", onclick: () => addLook(l) }, icon("dup", 18), "Duplicate");
+
+    const openMarks = marks(l, own, mine, mark);
+    const openProblems = h("ul", { class: "card-problems" }, ...mine.map((p) => h("li", {}, p.message)));
+    openProblems.hidden = !mine.length;
+    openParts = { marks: openMarks, problems: openProblems };
+    const group = (title: string, ...kids: (Node | null)[]) => h("div", { class: "edit-group" }, h("h3", {}, title), ...kids);
+    return h(
+      "article",
+      { class: `shelf-card shelf-editing${mark ? ` is-${mark}` : ""}${mine.length ? " has-problem" : ""}`, tabindex: -1, "aria-label": `Editing ${l.name || "a look"}` },
+      h(
+        "div",
+        { class: "edit-top" },
+        stageBox,
+        h(
+          "div",
+          { class: "shelf-body" },
+          nameLine,
+          priceLine,
+          wearLine(l),
+          h("span", { class: "fine" }, isOriginal(l.id) ? fineWords(l, st.get(l.id)) : "New: not in your game yet"),
+          openMarks,
+        ),
+        h("button", { class: "btn btn-small card-done", type: "button", "aria-expanded": "true", onclick: () => openCard(null) }, icon("check", 16), "Done"),
+      ),
+      openProblems,
+      h(
+        "div",
+        { class: "edit-groups" },
+        group("Name", h("label", { class: "field" }, h("span", {}, "What players read"), name)),
+        group("Price", h("label", { class: "field" }, h("span", {}, "Price in US dollars"), priceInput), ladder),
+        wearEditor(l, keep || lastFree, i),
+        lookParts?.group ?? null,
+        slotsEditor(l, isOriginal(l.id) && own.has(l.id)),
+      ),
+      keep ? h("p", { class: "fine owned-note" }, icon("lock", 14), "A player owns this look: its id stays, and it cannot be removed.") : null,
+      h("div", { class: "shelf-actions" }, dup, remove),
+    );
+  }
+
+  /**
+   * The wear slot of a look: "outfit" (the character's own look) or one of the game's own slots ("shovel"). Typed, with the slots the draft already uses as
+   * suggestions. Locked for a look that a player owns (it stays in its slot) and for the last free outfit. An outfit that becomes an item loses its colours; an
+   * item that becomes an outfit gets the free look's blue body.
+   */
+  function wearEditor(l: Look, locked: boolean, i: number): HTMLElement {
+    const list = `n133-wears-${i}`;
+    const input = h("input", { class: "input", type: "text", maxlength: 24, value: wearOf(l), list, autocapitalize: "none", spellcheck: false, disabled: locked, "aria-label": `Wear slot of ${l.name}`, onchange: (e: Event) => {
+      const v = (e.target as HTMLInputElement).value.trim();
+      if (v === "" || v === OUTFIT) {
+        delete l.wear;
+        l.change ??= { body: "#4aa8ff" };
+      } else {
+        l.wear = v;
+        if (SLOT_NAME_PATTERN.test(v)) delete l.change;
+      }
+      redraw();
+    } });
+    return h(
+      "div",
+      { class: "edit-group" },
+      h("h3", {}, "Wear slot"),
+      h("label", { class: "field" }, h("span", {}, "outfit (the character's colour and hat), or a slot of your game for an item (shovel, charm)"), input),
+      h("datalist", { id: list }, ...[OUTFIT, ...wearSlots()].map((w) => h("option", { value: w }))),
+    );
+  }
+
+  /** An outfit's fields: the body colour (swatches and a picker), the hat (pictures) and the hat colour, as the editor's "Look" group. */
+  function outfitFields(l: Look & { change: Change }, i: number, sync: () => void): { group: HTMLElement; swatches: HTMLElement; hatChoices: HTMLElement } {
     const body = h("input", { class: "colour", type: "color", value: l.change.body, "aria-label": `Body colour of ${l.name}`, oninput: (e: Event) => {
       l.change.body = (e.target as HTMLInputElement).value;
       sync();
@@ -524,61 +636,19 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
       hatChoices.append(h("label", { class: `hat-choice${(l.change.hat ?? null) === x ? " is-on" : ""}` }, input, hatChoicePicture(x), h("span", {}, x ? HAT_WORDS[x] : "No hat")));
     }
     hatChoices.style.setProperty("color", l.change.hatColor ?? "#9aa4b2");
-
-    const lastFree = l.priceUsd === 0 && freeCount() === 1;
-    const keep = isOriginal(l.id) && own.has(l.id);
-    const remove = h("button", { class: "btn btn-danger", type: "button", disabled: keep || lastFree, title: keep ? "A player owns this look. Keep it in the file." : lastFree ? "Keep one free look: every player starts with it." : "", onclick: () => {
-      draft = draft.filter((x) => x !== l);
-      open = null;
-      redraw();
-    } }, icon("trash", 18), "Remove");
-    const dup = h("button", { class: "btn", type: "button", onclick: () => addLook(l) }, icon("dup", 18), "Duplicate");
-
-    const openMarks = marks(l, own, mine, mark);
-    const openProblems = h("ul", { class: "card-problems" }, ...mine.map((p) => h("li", {}, p.message)));
-    openProblems.hidden = !mine.length;
-    openParts = { marks: openMarks, problems: openProblems };
-    const group = (title: string, ...kids: (Node | null)[]) => h("div", { class: "edit-group" }, h("h3", {}, title), ...kids);
-    return h(
-      "article",
-      { class: `shelf-card shelf-editing${mark ? ` is-${mark}` : ""}${mine.length ? " has-problem" : ""}`, tabindex: -1, "aria-label": `Editing ${l.name || "a look"}` },
-      h(
-        "div",
-        { class: "edit-top" },
-        stageBox,
-        h(
-          "div",
-          { class: "shelf-body" },
-          nameLine,
-          priceLine,
-          h("span", { class: "fine" }, isOriginal(l.id) ? (l.priceUsd === 0 ? "Every player starts with it" : soldText(st.get(l.id))) : "New: not in your game yet"),
-          openMarks,
-        ),
-        h("button", { class: "btn btn-small card-done", type: "button", "aria-expanded": "true", onclick: () => openCard(null) }, icon("check", 16), "Done"),
-      ),
-      openProblems,
+    const group = h(
+      "div",
+      { class: "edit-group group-look" },
+      h("h3", {}, "Look"),
       h(
         "div",
-        { class: "edit-groups" },
-        group("Name", h("label", { class: "field" }, h("span", {}, "What players read"), name)),
-        group("Price", h("label", { class: "field" }, h("span", {}, "Price in US dollars"), priceInput), ladder),
-        h(
-          "div",
-          { class: "edit-group group-look" },
-          h("h3", {}, "Look"),
-          h(
-            "div",
-            { class: "look-fields" },
-            h("div", { class: "field" }, h("span", {}, "Body colour"), h("div", { class: "colour-row" }, swatches, body)),
-            h("div", { class: "field" }, h("span", {}, "Hat"), hatChoices),
-            h("label", { class: "field" }, h("span", {}, "Hat colour"), hatColor),
-          ),
-        ),
-        slotsEditor(l, isOriginal(l.id) && own.has(l.id)),
+        { class: "look-fields" },
+        h("div", { class: "field" }, h("span", {}, "Body colour"), h("div", { class: "colour-row" }, swatches, body)),
+        h("div", { class: "field" }, h("span", {}, "Hat"), hatChoices),
+        h("label", { class: "field" }, h("span", {}, "Hat colour"), hatColor),
       ),
-      keep ? h("p", { class: "fine owned-note" }, icon("lock", 14), "A player owns this look: its id stays, and it cannot be removed.") : null,
-      h("div", { class: "shelf-actions" }, dup, remove),
     );
+    return { group, swatches, hatChoices };
   }
 
   /** The slots of a look: names and values (words or #rrggbb colours) that the game reads. Rows to type in, at most SLOTS_MAX. */
@@ -622,7 +692,7 @@ export function shelfView(first: ShelfData, looks: readonly Look[], picture: (l:
 
   function addLook(from?: Look) {
     const name = from ? `${from.name} copy`.slice(0, 40) : "New look";
-    const base: Look = from ? { id: "", name, priceUsd: from.priceUsd, change: { ...from.change }, ...(from.slots ? { slots: { ...from.slots } } : {}) } : { id: "", name, priceUsd: 0.05, change: { body: "#4aa8ff" } };
+    const base: Look = from ? { ...copyLook(from), id: "", name } : { id: "", name, priceUsd: 0.05, change: { body: "#4aa8ff" } };
     // An id that a player owns is never given to a new look (even when that look is not in looks.json now): the new look would be what the owners own.
     base.id = slugId(name, [...draft.map((x) => x.id), ...owned()]);
     const at = from ? draft.indexOf(from) + 1 : draft.length;

package/src/admin/panel/shelfData.ts

@@ -76,7 +76,7 @@ export function aiPrompt(text: string, diff: LooksDiff, owned: readonly string[]
     diff.changed.length ? `Changed: ${names(diff.changed.map((c) => c.after))}.` : "",
     "",
     `Looks that players own and that must stay in the file with the same id: ${ownedOk.length ? quote(ownedOk) : "none yet"}${odd ? ` (and ${odd} more with an id that is not a valid look id: do not remove any look)` : ""}.`,
-    `Rules: keep one free look (priceUsd 0), prices in US dollars with at most 2 decimals, never change or remove the id of a look that someone owns, never change the slots of a look that someone owns (slots are words and #rrggbb colours that the game reads, at most 8 on a look), and a look never changes a score or a rule. (The file had ${before.length} looks before.)`,
+    `Rules: keep one free outfit (priceUsd 0, no "wear"), prices in US dollars with at most 2 decimals, never change or remove the id of a look that someone owns, never change the wear slot or the slots of a look that someone owns (a look with "wear" is an item of that slot, such as a shovel, and has no "change"; slots are words and #rrggbb colours that the game reads, at most 8 on a look), and a look never changes a score or a rule. (The file had ${before.length} looks before.)`,
     "",
     "looks.json:",
     "```json",

package/src/admin/panel/style.css

@@ -1679,7 +1679,16 @@
   font-size: 12px;
 }
 
-/* ---- The "Game" card: two switches (gameCard.ts). Each is a button of at least 44 px ---- */
+/* ---- The "Game" card: two switches and the friends choice (gameCard.ts). Each is a button of at least 44 px ---- */
+
+/* The friends choice: three keys in a row that wraps on a narrow phone, each 44 px tall. */
+.n133-admin .game-card .friends-row .switch-head {
+  flex-wrap: wrap;
+}
+
+.n133-admin .game-card .friends-choice .seg-btn {
+  min-height: 44px;
+}
 
 .n133-admin .game-card .switch-row {
   display: grid;

package/src/admin/store.ts

@@ -48,13 +48,13 @@ export type AdminLogin = { at: number; country: string | null; browser: string }
 export const ADMIN_LOGINS_SHOWN = 10;
 
 /**
- * The game's database, as the handler needs it. An adapter writes ONLY what these calls say: the two settings and, when the game turns it on, the deletion of the admin sessions
+ * The game's database, as the handler needs it. An adapter writes ONLY what these calls say: the three settings and, when the game turns it on, the deletion of the admin sessions
  * (`signOutEverywhere`). Nothing else.
  * (There is no call that writes a look, a price or an order: the Shelf gives text to copy, and a change of looks is a change of the repository.)
  */
 export interface AdminStore {
   /** The settings that /admin has saved. A value that is not a known word is ignored by the handler, so an adapter returns what it holds. */
-  readSettings(): Promise<{ character?: unknown; signin?: unknown }>;
+  readSettings(): Promise<{ character?: unknown; signin?: unknown; friends?: unknown }>;
   /** Saves a checked patch: all of it or none of it. */
   saveSettings(patch: GamePatch, now: number): Promise<void>;
   summary(now: number): Promise<StoreSummary>;

package/src/admin/switches.ts

@@ -1,46 +1,72 @@
-// The two switches of the "Game" card in /admin, and the words that say what each does. The handler checks a press with `parsePatch`; the panel
-// draws the card from `SWITCHES`. A switch changes ONLY these two settings; never a look, a price or an order.
+// The switches of the "Game" card in /admin, and the words that say what each does. The handler checks a press with `parsePatch`; the panel
+// draws the card from `SWITCHES` and `FRIENDS_CHOICES`. A switch changes ONLY these three settings; never a look, a price or an order.
 
 /** Which character the player is: Nanoterra's island character (the one the player has there) or the game's own. */
 export type Character = "nanoterra" | "own";
 /** How the game signs a Nanoterra player in: the code exchange, a signed ticket (a game with no server), or not at all. */
 export type Signin = "exchange" | "ticket" | "none";
-export type GameSettings = { character: Character; signin: Signin };
+/**
+ * Which friends list the game shows: Nanoterra's (the nano133 window, "@nano133/nanoterra/friends/panel"), the game's own (its own players and store), or none.
+ * A three-way choice, not an On/Off switch.
+ */
+export type Friends = "nanoterra" | "own" | "off";
+/** The game's own words for the switches. `friends` may be left out: it is "nanoterra" then (on by default). */
+export type GameSettings = { character: Character; signin: Signin; friends?: Friends };
 /** What a press can set: sign-in is on ("exchange": a game with a server) or off ("none"). */
-export type GamePatch = { character?: Character; signin?: "exchange" | "none" };
+export type GamePatch = { character?: Character; signin?: "exchange" | "none"; friends?: Friends };
 /** The settings as they are now, and which ones /admin has set (the others still have the game's default). */
-export type GameState = GameSettings & { fromAdmin: { character: boolean; signin: boolean } };
+export type GameState = { character: Character; signin: Signin; friends: Friends; fromAdmin: { character: boolean; signin: boolean; friends: boolean } };
 
 export const isCharacter = (v: unknown): v is Character => v === "nanoterra" || v === "own";
 export const isSigninChoice = (v: unknown): v is "exchange" | "none" => v === "exchange" || v === "none";
 export const isSignin = (v: unknown): v is Signin => v === "exchange" || v === "ticket" || v === "none";
+export const isFriends = (v: unknown): v is Friends => v === "nanoterra" || v === "own" || v === "off";
+/** The friends list a game shows while neither its own words nor /admin say: Nanoterra's. */
+export const DEFAULT_FRIENDS: Friends = "nanoterra";
 /** The sign-in switch is on for any way but "none". */
 export const signinOn = (s: Signin): boolean => s !== "none";
 
 /** A request body for a press: only the two known words, at least one. Anything else is refused, with the reason in words. */
 export function parsePatch(body: unknown): { ok: true; patch: GamePatch } | { ok: false; error: string } {
-  if (!body || typeof body !== "object" || Array.isArray(body)) return { ok: false, error: 'Send an object with "character" or "signin".' };
+  if (!body || typeof body !== "object" || Array.isArray(body)) return { ok: false, error: 'Send an object with "character", "signin" or "friends".' };
   const patch: GamePatch = {};
   for (const [key, value] of Object.entries(body as Record<string, unknown>)) {
     if (key === "character" && isCharacter(value)) patch.character = value;
     else if (key === "signin" && isSigninChoice(value)) patch.signin = value;
+    else if (key === "friends" && isFriends(value)) patch.friends = value;
+    else if (key === "friends") return { ok: false, error: '"friends" must be "nanoterra", "own" or "off".' };
     else if (key === "character") return { ok: false, error: '"character" must be "nanoterra" or "own".' };
     else if (key === "signin") return { ok: false, error: '"signin" must be "exchange" or "none".' };
     else return { ok: false, error: `"${key}" is not a game switch.` };
   }
-  if (!Object.keys(patch).length) return { ok: false, error: 'Send "character" or "signin".' };
+  if (!Object.keys(patch).length) return { ok: false, error: 'Send "character", "signin" or "friends".' };
   return { ok: true, patch };
 }
 
 /** The settings from what the store kept and the game's defaults. A stored value that is not one of the known words is ignored. */
-export function mergeSettings(stored: { character?: unknown; signin?: unknown }, defaults: GameSettings): GameState {
+export function mergeSettings(stored: { character?: unknown; signin?: unknown; friends?: unknown }, defaults: GameSettings): GameState {
   return {
     character: isCharacter(stored.character) ? stored.character : defaults.character,
     signin: isSigninChoice(stored.signin) ? stored.signin : defaults.signin,
-    fromAdmin: { character: isCharacter(stored.character), signin: isSigninChoice(stored.signin) },
+    friends: isFriends(stored.friends) ? stored.friends : isFriends(defaults.friends) ? defaults.friends : DEFAULT_FRIENDS,
+    fromAdmin: { character: isCharacter(stored.character), signin: isSigninChoice(stored.signin), friends: isFriends(stored.friends) },
   };
 }
 
+/** The friends choice of the card: its title, and for each choice its short name (the card's three keys) and one plain sentence. Nanoterra's is the default. */
+export const FRIENDS_TITLE = "Friends list";
+export const FRIENDS_CHOICES: Record<Friends, { name: string; note: string }> = {
+  nanoterra: {
+    name: "Nanoterra",
+    note: "Nanoterra: a player signed in on nano133 sees their Nanoterra friends in a small nano133 frame in your game, and their friends see that they are playing it. The friends stay on nano133: your game gets none of them.",
+  },
+  own: {
+    name: "The game's own",
+    note: "The game's own: a friends list of this game's players, kept in this game's own database. Nanoterra friends do not show.",
+  },
+  off: { name: "Off", note: "Off: the game shows no friends list." },
+};
+
 /** One switch of the card: its title, and one plain sentence for each state. */
 export type SwitchId = "character" | "signin";
 export const SWITCHES: Record<SwitchId, { title: string; on: string; off: string }> = {

package/src/friends/adapters/d1.sql

@@ -0,0 +1,33 @@
+-- The friends tables of "@nano133/nanoterra/friends/d1". Add this file to the game's migrations (for example migrations/0005_friends.sql) and run
+-- `wrangler d1 migrations apply`. The adapter reads and writes only these three tables.
+
+-- One row for each pair of players (a < b): a request, a friendship or a block. `edge` is the opaque id the browser sees.
+CREATE TABLE IF NOT EXISTS friend_edges (
+  edge TEXT PRIMARY KEY,
+  a TEXT NOT NULL,
+  b TEXT NOT NULL,
+  from_player TEXT NOT NULL,
+  state TEXT NOT NULL CHECK (state IN ('pending', 'friend', 'blocked')),
+  blocked_by TEXT NOT NULL DEFAULT '[]',
+  at INTEGER NOT NULL,
+  invite_from TEXT,
+  invite_where TEXT,
+  invite_at INTEGER,
+  rev INTEGER NOT NULL DEFAULT 1,
+  UNIQUE (a, b)
+);
+CREATE INDEX IF NOT EXISTS friend_edges_b ON friend_edges (b);
+
+-- Where a player is now, and which tab said so. A row older than two minutes does not count.
+CREATE TABLE IF NOT EXISTS friend_presence (
+  player TEXT PRIMARY KEY,
+  place TEXT NOT NULL,
+  lease TEXT NOT NULL,
+  at INTEGER NOT NULL
+);
+
+-- A player's "show me online" choice (1 or 0). No row: shown.
+CREATE TABLE IF NOT EXISTS friend_prefs (
+  player TEXT PRIMARY KEY,
+  show_online INTEGER NOT NULL DEFAULT 1
+);

package/src/friends/adapters/d1.ts

@@ -0,0 +1,146 @@
+// The friends store for a game on Cloudflare D1. The tables are in ./d1.sql (the package ships it: "@nano133/nanoterra/friends/d1.sql"); add it to
+// the game's migrations. It reads and writes ONLY friend_edges, friend_presence and friend_prefs.
+//
+//   import { createD1Friends } from "@nano133/nanoterra/friends/d1";
+//   const friends = createD1Friends(env.DB);
+//
+// D1 has no transaction that reads and then writes, so each write is ONE statement that holds its own check: a change of an edge says which `rev`
+// it read (a row that changed in between is not written, and the player is asked to try again), and a new edge is written only while both players
+// have room (the count is in the same statement) and the pair has no row yet (UNIQUE (a, b)).
+
+import type { D1Like } from "../../admin/adapters/d1.js";
+import { buildRows, checkPulse, pairOf, planAccept, planBlock, planDecline, planInvite, planRemove, planRequest, planUnblock, shownOthers, type EdgeRec, type Plan, type PresenceRec } from "../rules.js";
+import { FRIEND_LIMIT, FRIEND_REQUEST_MS, FriendsError, type FriendView, type FriendsStore, type PlayerDirectory } from "../types.js";
+
+export type { D1Like, D1StatementLike } from "../../admin/adapters/d1.js";
+
+type Row = { edge: string; a: string; b: string; from_player: string; state: string; blocked_by: string; at: number; invite_from: string | null; invite_where: string | null; invite_at: number | null; rev: number };
+
+const COLS = "edge, a, b, from_player, state, blocked_by, at, invite_from, invite_where, invite_at, rev";
+
+function recOf(r: Row): EdgeRec {
+  let blockedBy: string[] = [];
+  try {
+    const v: unknown = JSON.parse(r.blocked_by);
+    if (Array.isArray(v)) blockedBy = v.filter((x): x is string => typeof x === "string");
+  } catch {
+    blockedBy = [];
+  }
+  const state = r.state === "friend" || r.state === "blocked" ? r.state : "pending";
+  const invite = typeof r.invite_from === "string" && typeof r.invite_where === "string" && typeof r.invite_at === "number" ? { from: r.invite_from, where: r.invite_where, at: Number(r.invite_at) } : null;
+  return { edge: r.edge, a: r.a, b: r.b, from: r.from_player, state, blockedBy, at: Number(r.at), invite, rev: Number(r.rev) };
+}
+
+const CHANGED = "That changed just now. Try again.";
+
+export function createD1Friends(db: D1Like): FriendsStore {
+  const changes = (res: unknown): number => Number((res as { meta?: { changes?: number } } | undefined)?.meta?.changes ?? 0);
+  const byEdge = async (edge: string) => {
+    const r = await db.prepare(`SELECT ${COLS} FROM friend_edges WHERE edge = ?`).bind(edge).first<Row>();
+    return r ? recOf(r) : null;
+  };
+  const byPair = async (x: string, y: string) => {
+    const [a, b] = pairOf(x, y);
+    const r = await db.prepare(`SELECT ${COLS} FROM friend_edges WHERE a = ? AND b = ?`).bind(a, b).first<Row>();
+    return r ? recOf(r) : null;
+  };
+  /** Live edges of a player, as SQL (?1 the player, ?2 the oldest request time that still counts). */
+  const LIVE_COUNT = "(SELECT COUNT(*) FROM friend_edges WHERE (a = ?1 OR b = ?1) AND (state != 'pending' OR at > ?2))";
+  const liveCount = async (player: string, now: number) => Number((await db.prepare(`SELECT ${LIVE_COUNT} AS n`).bind(player, now - FRIEND_REQUEST_MS).first<{ n: number }>())?.n ?? 0);
+
+  async function apply(plan: Plan, prev: EdgeRec | null, now: number): Promise<void> {
+    if ("none" in plan) return;
+    if ("drop" in plan) {
+      if (changes(await db.prepare("DELETE FROM friend_edges WHERE edge = ? AND rev = ?").bind(plan.drop.edge, plan.drop.rev).run()) !== 1) throw new FriendsError(409, CHANGED);
+      return;
+    }
+    const r = plan.put;
+    const inv = r.invite;
+    if (prev && prev.edge === r.edge) {
+      const res = await db
+        .prepare("UPDATE friend_edges SET from_player = ?, state = ?, blocked_by = ?, at = ?, invite_from = ?, invite_where = ?, invite_at = ?, rev = ? WHERE edge = ? AND rev = ?")
+        .bind(r.from, r.state, JSON.stringify(r.blockedBy), r.at, inv?.from ?? null, inv?.where ?? null, inv?.at ?? null, r.rev, r.edge, prev.rev)
+        .run();
+      if (changes(res) !== 1) throw new FriendsError(409, CHANGED);
+      return;
+    }
+    // A new edge: only while both players have room, in the same statement (the pair's UNIQUE (a, b) refuses a second row).
+    const cut = now - FRIEND_REQUEST_MS;
+    const other = r.from === r.a ? r.b : r.a;
+    const sql =
+      `INSERT INTO friend_edges (${COLS}) SELECT ?3, ?4, ?5, ?6, ?7, ?8, ?9, NULL, NULL, NULL, ?10 ` +
+      `WHERE (SELECT COUNT(*) FROM friend_edges WHERE (a = ?1 OR b = ?1) AND (state != 'pending' OR at > ?11)) < ?12 ` +
+      `AND (SELECT COUNT(*) FROM friend_edges WHERE (a = ?2 OR b = ?2) AND (state != 'pending' OR at > ?11)) < ?12 ` +
+      `ON CONFLICT (a, b) DO NOTHING`;
+    const res = await db.prepare(sql).bind(r.from, other, r.edge, r.a, r.b, r.from, r.state, JSON.stringify(r.blockedBy), r.at, r.rev, cut, FRIEND_LIMIT).run();
+    if (changes(res) !== 1) throw new FriendsError(409, CHANGED);
+  }
+
+  async function onEdge(_player: string, edge: string, plan: (rec: EdgeRec | null) => Plan, now: number) {
+    const rec = await byEdge(edge);
+    await apply(plan(rec), rec, now);
+  }
+
+  return {
+    async view(player: string, directory: PlayerDirectory, now: number): Promise<FriendView> {
+      const recs = (await db.prepare(`SELECT ${COLS} FROM friend_edges WHERE a = ?1 OR b = ?1`).bind(player).all<Row>()).results.map(recOf);
+      // The presence and the choice of the player's friends, in one statement each (a friend's id is the other side of a friend edge).
+      const OTHER = "CASE WHEN e.a = ?1 THEN e.b ELSE e.a END";
+      const pres = (
+        await db
+          .prepare(`SELECT p.player, p.place, p.lease, p.at FROM friend_edges e JOIN friend_presence p ON p.player = ${OTHER} WHERE (e.a = ?1 OR e.b = ?1) AND e.state = 'friend'`)
+          .bind(player)
+          .all<{ player: string; place: string; lease: string; at: number }>()
+      ).results;
+      const hidden = (
+        await db.prepare(`SELECT f.player FROM friend_edges e JOIN friend_prefs f ON f.player = ${OTHER} WHERE (e.a = ?1 OR e.b = ?1) AND e.state = 'friend' AND f.show_online = 0`).bind(player).all<{ player: string }>()
+      ).results;
+      const me = await db.prepare("SELECT show_online FROM friend_prefs WHERE player = ?").bind(player).first<{ show_online: number }>();
+      const names = await directory.names(shownOthers(player, recs, now));
+      const presence = new Map<string, PresenceRec>(pres.map((p) => [p.player, { player: p.player, where: p.place, lease: p.lease, at: Number(p.at) }]));
+      const shows = new Map<string, boolean>(hidden.map((x) => [x.player, false]));
+      return { showOnline: !me || Number(me.show_online) !== 0, people: buildRows(player, recs, now, names, presence, shows) };
+    },
+
+    async request(player, other, now) {
+      const rec = await byPair(player, other);
+      const plan = await planRequest(player, other, rec, now, async () => ({ mine: await liveCount(player, now), theirs: await liveCount(other, now) }));
+      // A request that went stale is still the pair's row: it is changed in place (its count is the one just read).
+      await apply(plan, rec, now);
+    },
+    accept: (player, edge, now) => onEdge(player, edge, (r) => planAccept(player, r, now), now),
+    decline: (player, edge) => onEdge(player, edge, (r) => planDecline(player, r, Date.now()), Date.now()),
+    remove: (player, edge) => onEdge(player, edge, (r) => planRemove(player, r, Date.now()), Date.now()),
+    block: (player, edge, now) => onEdge(player, edge, (r) => planBlock(player, r, now), now),
+    unblock: (player, edge, now) => onEdge(player, edge, (r) => planUnblock(player, r, now), now),
+    invite: (player, edge, where, now) => onEdge(player, edge, (r) => planInvite(player, r, where, now), now),
+
+    async pulse(player, where, lease, now) {
+      const p = checkPulse(where, lease);
+      if (p.where !== null) {
+        await db
+          .prepare("INSERT INTO friend_presence (player, place, lease, at) VALUES (?, ?, ?, ?) ON CONFLICT (player) DO UPDATE SET place = excluded.place, lease = excluded.lease, at = excluded.at")
+          .bind(player, p.where, p.lease, now)
+          .run();
+        return;
+      }
+      // Leaving: only the tab that holds the row may clear it (planPulse's rule, in the statement).
+      await db.prepare("DELETE FROM friend_presence WHERE player = ? AND lease = ?").bind(player, p.lease).run();
+    },
+
+    async setShowOnline(player, on) {
+      const stmts = [db.prepare("INSERT INTO friend_prefs (player, show_online) VALUES (?, ?) ON CONFLICT (player) DO UPDATE SET show_online = excluded.show_online").bind(player, on ? 1 : 0)];
+      if (!on) stmts.push(db.prepare("DELETE FROM friend_presence WHERE player = ?").bind(player));
+      await db.batch(stmts);
+    },
+
+    async forget(player) {
+      const done = await db.batch([
+        db.prepare("DELETE FROM friend_edges WHERE a = ?1 OR b = ?1").bind(player),
+        db.prepare("DELETE FROM friend_presence WHERE player = ?").bind(player),
+        db.prepare("DELETE FROM friend_prefs WHERE player = ?").bind(player),
+      ]);
+      return done.reduce<number>((n, r) => n + changes(r), 0);
+    },
+  };
+}