@nano133/nanoterra 0.12.0 → 0.14.0

package/dist/input/index.d.ts

@@ -1,3 +1,5 @@
+export { createZoom, listenZoom, pinchedTo, wheelNotches, zoomedBy, PINCH, ZOOM_CURVE, ZOOM_EASE, ZOOM_STEP } from "./zoom.js";
+export type { Zoom, ZoomRange } from "./zoom.js";
 type Listens = Pick<EventTarget, "addEventListener" | "removeEventListener">;
 /**
  * Calls `release` each time what is held may be wrong. In it, clear every held key, thumb stick and drag, and any jump or tool that a key press queued.
@@ -29,4 +31,3 @@ export declare function pauseWhenLeft(pause: () => void, win?: Listens, doc?: Li
     hidden?: boolean;
     hasFocus?: () => boolean;
 }): () => void;
-export {};

package/dist/input/index.js

@@ -16,6 +16,9 @@
 // calls your `pause` when the player really left (a free round stops its clock and shows a Resume key). No package: plain browser events.
 //
 // A ROUND THAT COSTS MONEY must not pause: its deadline must not move. Keep `releaseWhenLost` (the character always stops) and leave `pauseWhenLeft` out.
+//
+// The camera's distance (the wheel, a pinch, the + and − keys, one curve) is `createZoom` and `listenZoom`, in ./zoom.ts.
+export { createZoom, listenZoom, pinchedTo, wheelNotches, zoomedBy, PINCH, ZOOM_CURVE, ZOOM_EASE, ZOOM_STEP } from "./zoom.js";
 /**
  * Calls `release` each time what is held may be wrong. In it, clear every held key, thumb stick and drag, and any jump or tool that a key press queued.
  * `keysOnly`, when given, is called when a menu opens (a right click): a menu takes a keyup, but on a touch screen a long press also asks for a menu,

package/dist/input/zoom.d.ts

@@ -0,0 +1,81 @@
+/** Where the camera may be (metres from the eyes): the farthest, the default, and the switch: nearer than `first` it is in the eyes. */
+export type ZoomRange = {
+    max: number;
+    start: number;
+    first: number;
+};
+/** One notch: about one mouse-wheel click (100 px of scroll). The + and − keys move `key` notches. */
+export declare const ZOOM_STEP: {
+    readonly perPx: 0.006;
+    readonly perPxPinch: 0.03;
+    readonly linePx: 16;
+    readonly pagePx: 400;
+    readonly key: 1.2;
+};
+/** The curve: a notch moves `base + scale × distance` metres. */
+export declare const ZOOM_CURVE: {
+    readonly base: 0.35;
+    readonly scale: 0.14;
+};
+/** The touch pinch: twice the spread divides `distance + base/scale` by 2^power. */
+export declare const PINCH: {
+    readonly power: 1.3;
+};
+/** How fast the camera eases to the distance asked for (1/s). */
+export declare const ZOOM_EASE = 9;
+/** One wheel event as notches (negative: in). A mouse notch arrives in lines or about 100 px, a trackpad in many small pixels, a pinch as a wheel with the ctrl key. */
+export declare function wheelNotches(e: {
+    deltaY: number;
+    deltaMode?: number;
+    ctrlKey?: boolean;
+}): number;
+/** The distance after `notches` (negative: in) from `want`. */
+export declare function zoomedBy(r: ZoomRange, want: number, notches: number): number;
+/** The distance during a touch pinch: `from` at the start, the fingers `spread0` apart then and `spread` now (px). Apart brings it in. */
+export declare function pinchedTo(r: ZoomRange, from: number, spread0: number, spread: number): number;
+export type Zoom = {
+    /** The distance asked for (metres from the eyes). */
+    want(): number;
+    /** The distance now, as the last `step` eased it. */
+    now(): number;
+    /** True while the camera is in the eyes (the distance now below `first`). */
+    eyes(): boolean;
+    /** Asks for a distance (clamped), writes it and tells the listeners. */
+    set(d: number): void;
+    /** Moves the distance by notches (negative: in), along the curve. */
+    by(notches: number): void;
+    /** A wheel event (or one like it) moves the distance. */
+    wheel(e: {
+        deltaY: number;
+        deltaMode?: number;
+        ctrlKey?: boolean;
+    }): void;
+    /** A touch pinch starts with the fingers `spread` apart (px); `pinch` follows it; `pinchEnd` ends it. */
+    pinchStart(spread: number): void;
+    pinch(spread: number): void;
+    pinchEnd(): void;
+    /** One frame: the distance eases to the one asked for (at once when `calm`, reduced motion). Returns it. */
+    step(dt: number, calm: boolean): number;
+    /** Calls `on` when the distance asked for changes. Returns the function that stops it. */
+    subscribe(on: () => void): () => void;
+};
+/**
+ * The camera's distance of one game. `read` gives the kept distance (null: none, the default `start`), and is read the first time the distance is
+ * asked for, so the server never calls it; `write` keeps a new one (on every change: put a delay in it if your storage is slow).
+ */
+export declare function createZoom(r: ZoomRange, keep?: {
+    read?: () => number | null;
+    write?: (d: number) => void;
+}): Zoom;
+type Listens = Pick<EventTarget, "addEventListener" | "removeEventListener">;
+/**
+ * The wheel over `el` (the game's canvas: the page does not scroll or zoom there) and the + and − keys on the window (also the number pad's) move
+ * `zoom`. A key with ctrl, alt or the command key is the browser's own zoom and is left alone, and so is a key typed in a field. `skip(e)` returns true
+ * for an event the game wants to keep from the zoom (a key the player is binding, a game that is paused). Returns the function that takes the listeners away.
+ * The touch pinch is yours to wire (`pinchStart`, `pinch`, `pinchEnd`), because the fingers are also your thumb stick and your look.
+ */
+export declare function listenZoom(zoom: Zoom, el: Listens, opts?: {
+    skip?: (e: Event) => boolean;
+    keys?: boolean;
+}, win?: Listens): () => void;
+export {};

package/dist/input/zoom.js

@@ -0,0 +1,140 @@
+// The camera's distance for a game the player walks in: the mouse wheel, a trackpad's two-finger scroll or pinch, a two-finger pinch on a touch
+// screen, and the + and − keys move one number, the camera's distance from the eyes, along ONE curve. 0 is first person; below `first` the camera
+// is in the eyes. It eases to the distance asked for (at once with reduced motion). No package: plain browser events.
+//
+// THE FEEL is nano133.com's island (app/island/zoom.ts). Each notch moves the distance in proportion to it (`0.35 + 0.14 × distance` metres a
+// notch), so a notch feels the same near and far. Every bit of a scroll counts: a dead zone and a speed limit dropped most of a quick spin in
+// Echo Island, and its wheel needed about five times the spins of the island's (Wes, 2026-11-01). Close in, the last notch goes all the way to
+// the eyes; out of the eyes, the first notch goes past the switch, so the camera never rests half inside the head.
+//
+// THE PINCH follows the same curve: the curve is a constant ratio of `distance + 2.5`, so spreading the fingers to twice their start divides it
+// by 2^PINCH.power, wherever the camera is.
+/** One notch: about one mouse-wheel click (100 px of scroll). The + and − keys move `key` notches. */
+export const ZOOM_STEP = { perPx: 0.006, perPxPinch: 0.03, linePx: 16, pagePx: 400, key: 1.2 };
+/** The curve: a notch moves `base + scale × distance` metres. */
+export const ZOOM_CURVE = { base: 0.35, scale: 0.14 };
+/** The touch pinch: twice the spread divides `distance + base/scale` by 2^power. */
+export const PINCH = { power: 1.3 };
+/** How fast the camera eases to the distance asked for (1/s). */
+export const ZOOM_EASE = 9;
+const clamp = (r, d) => Math.min(r.max, Math.max(0, d));
+/** One wheel event as notches (negative: in). A mouse notch arrives in lines or about 100 px, a trackpad in many small pixels, a pinch as a wheel with the ctrl key. */
+export function wheelNotches(e) {
+    const px = e.deltaMode === 1 ? e.deltaY * ZOOM_STEP.linePx : e.deltaMode === 2 ? e.deltaY * ZOOM_STEP.pagePx : e.deltaY;
+    return px * (e.ctrlKey ? ZOOM_STEP.perPxPinch : ZOOM_STEP.perPx);
+}
+/** The snap: close in, a move into the switch goes to the eyes; out of the eyes, a move out goes past the switch. */
+function snapped(r, from, to) {
+    if (to < from && to < r.first)
+        return 0;
+    if (to > from && from < r.first)
+        return clamp(r, Math.max(to, r.first + 1));
+    return clamp(r, to);
+}
+/** The distance after `notches` (negative: in) from `want`. */
+export function zoomedBy(r, want, notches) {
+    return snapped(r, want, want + notches * (ZOOM_CURVE.base + want * ZOOM_CURVE.scale));
+}
+/** The distance during a touch pinch: `from` at the start, the fingers `spread0` apart then and `spread` now (px). Apart brings it in. */
+export function pinchedTo(r, from, spread0, spread) {
+    if (!(spread0 > 0) || !(spread > 0))
+        return from;
+    const k = ZOOM_CURVE.base / ZOOM_CURVE.scale;
+    return snapped(r, from, (from + k) * (spread0 / spread) ** PINCH.power - k);
+}
+/**
+ * The camera's distance of one game. `read` gives the kept distance (null: none, the default `start`), and is read the first time the distance is
+ * asked for, so the server never calls it; `write` keeps a new one (on every change: put a delay in it if your storage is slow).
+ */
+export function createZoom(r, keep = {}) {
+    let want = r.start;
+    let now = r.start;
+    let loaded = false;
+    let pinchFrom = null;
+    const listeners = new Set();
+    const load = () => {
+        if (loaded)
+            return;
+        loaded = true;
+        const v = keep.read?.();
+        if (typeof v === "number" && Number.isFinite(v))
+            want = now = clamp(r, v);
+    };
+    const set = (d) => {
+        load();
+        want = clamp(r, d);
+        keep.write?.(want);
+        for (const on of listeners)
+            on();
+    };
+    const by = (notches) => {
+        load();
+        if (notches !== 0)
+            set(zoomedBy(r, want, notches));
+    };
+    return {
+        want: () => (load(), want),
+        now: () => (load(), now),
+        eyes: () => (load(), now < r.first),
+        set,
+        by,
+        wheel: (e) => by(wheelNotches(e)),
+        pinchStart(spread) {
+            load();
+            pinchFrom = { d: want, spread };
+        },
+        pinch(spread) {
+            if (pinchFrom)
+                set(pinchedTo(r, pinchFrom.d, pinchFrom.spread, spread));
+        },
+        pinchEnd() {
+            pinchFrom = null;
+        },
+        step(dt, calm) {
+            load();
+            now = calm ? want : now + (want - now) * (1 - Math.exp(-dt * ZOOM_EASE));
+            if (Math.abs(now - want) < 0.002)
+                now = want;
+            return now;
+        },
+        subscribe(on) {
+            listeners.add(on);
+            return () => void listeners.delete(on);
+        },
+    };
+}
+/**
+ * The wheel over `el` (the game's canvas: the page does not scroll or zoom there) and the + and − keys on the window (also the number pad's) move
+ * `zoom`. A key with ctrl, alt or the command key is the browser's own zoom and is left alone, and so is a key typed in a field. `skip(e)` returns true
+ * for an event the game wants to keep from the zoom (a key the player is binding, a game that is paused). Returns the function that takes the listeners away.
+ * The touch pinch is yours to wire (`pinchStart`, `pinch`, `pinchEnd`), because the fingers are also your thumb stick and your look.
+ */
+export function listenZoom(zoom, el, opts = {}, win = window) {
+    const wheel = (e) => {
+        e.preventDefault();
+        if (opts.skip?.(e))
+            return;
+        zoom.wheel(e);
+    };
+    const key = (e) => {
+        const k = e;
+        if (k.metaKey || k.altKey || k.ctrlKey || opts.skip?.(e))
+            return;
+        const t = k.target;
+        if (t && (t.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName ?? "")))
+            return;
+        if (k.code === "Equal" || k.code === "NumpadAdd")
+            zoom.by(-ZOOM_STEP.key);
+        else if (k.code === "Minus" || k.code === "NumpadSubtract")
+            zoom.by(ZOOM_STEP.key);
+    };
+    el.addEventListener("wheel", wheel, { passive: false });
+    const keys = opts.keys !== false;
+    if (keys)
+        win.addEventListener("keydown", key);
+    return () => {
+        el.removeEventListener("wheel", wheel);
+        if (keys)
+            win.removeEventListener("keydown", key);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nano133/nanoterra",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Nanoterra for a creator's game, in one package: the player's sign-in ticket, the player's character (a toon body on the island's skeleton), the looks ladder, the admin and its wallet sign-in, the friends list, an options menu, emotes, the player's sign-in (a passkey or a wallet app) and a shop that sells looks for Nano with no key on the server.",
   "type": "module",
   "main": "dist/index.js",

package/src/admin/adapters/d1.ts

@@ -1,5 +1,5 @@
 // The admin store for a game on Cloudflare D1, with the tables of the game starter (migrations/0001_init.sql): `meta`, `orders` and `owned`.
-// It writes ONLY the four settings (`setting:character`, `setting:signin`, `setting:friends`, `setting:emotes` in `meta`); everything else it does is a read, except when the game turns the sign-in list on
+// It writes ONLY the five settings (`setting:character`, `setting:signin`, `setting:friends`, `setting:emotes`, `setting:freePlay` in `meta`); everything else it does is a read, except when the game turns the sign-in list on
 // (`logins: true`): then the one other write is `DELETE FROM sessions WHERE scope = 'admin'` ("sign out everywhere").
 //
 //   import { createD1Store } from "@nano133/nanoterra/admin/d1";
@@ -21,7 +21,7 @@ export interface D1Like {
   batch(statements: D1StatementLike[]): Promise<unknown[]>;
 }
 
-export const D1_KEYS = { character: "setting:character", signin: "setting:signin", friends: "setting:friends", emotes: "setting:emotes" } as const;
+export const D1_KEYS = { character: "setting:character", signin: "setting:signin", friends: "setting:friends", emotes: "setting:emotes", freePlay: "setting:freePlay" } as const;
 
 type Row = { id: string; player: string; look_id: string; usd: string; amount: string; status: string; created_at: number; expires_at: number; paid_at: number | null; payer: string | null; hash: string | null };
 
@@ -34,9 +34,9 @@ type Row = { id: string; player: string; look_id: string; usd: string; amount: s
 export function createD1Store(db: D1Like, options: { logins?: boolean } = {}): AdminStore {
   const store: AdminStore = {
     async readSettings() {
-      const rows = (await db.prepare("SELECT key, value FROM meta WHERE key IN (?, ?, ?, ?)").bind(D1_KEYS.character, D1_KEYS.signin, D1_KEYS.friends, D1_KEYS.emotes).all<{ key: string; value: string }>()).results;
+      const rows = (await db.prepare("SELECT key, value FROM meta WHERE key IN (?, ?, ?, ?, ?)").bind(D1_KEYS.character, D1_KEYS.signin, D1_KEYS.friends, D1_KEYS.emotes, D1_KEYS.freePlay).all<{ key: string; value: string }>()).results;
       const row = (key: string) => rows.find((r) => r.key === key)?.value;
-      return { character: row(D1_KEYS.character), signin: row(D1_KEYS.signin), friends: row(D1_KEYS.friends), emotes: row(D1_KEYS.emotes) };
+      return { character: row(D1_KEYS.character), signin: row(D1_KEYS.signin), friends: row(D1_KEYS.friends), emotes: row(D1_KEYS.emotes), freePlay: row(D1_KEYS.freePlay) };
     },
 
     async saveSettings(patch: GamePatch, now: number) {
@@ -47,6 +47,7 @@ export function createD1Store(db: D1Like, options: { logins?: boolean } = {}): A
       if (patch.signin) batch.push(write(D1_KEYS.signin, patch.signin));
       if (patch.friends) batch.push(write(D1_KEYS.friends, patch.friends));
       if (patch.emotes) batch.push(write(D1_KEYS.emotes, patch.emotes));
+      if (patch.freePlay) batch.push(write(D1_KEYS.freePlay, patch.freePlay));
       if (batch.length) await db.batch(batch);
     },
 

package/src/admin/adapters/firestore.ts

@@ -1,8 +1,8 @@
 // The admin store for a game on Firestore (the Admin SDK). The package has no Firebase dependency: the adapter uses the small interface below, which the
-// Admin SDK's `Firestore` fits. It writes ONLY the four settings; everything else it does is a read.
+// Admin SDK's `Firestore` fits. It writes ONLY the five settings; everything else it does is a read.
 //
 // The data model (the names a game must have; only the three collection names can be changed):
-//   meta/{key}          { value: string, at: number }          keys "setting:character", "setting:signin", "setting:friends", "setting:emotes", "rate" (value is JSON { usd, sources })
+//   meta/{key}          { value: string, at: number }          keys "setting:character", "setting:signin", "setting:friends", "setting:emotes", "setting:freePlay", "rate" (value is JSON { usd, sources })
 //   orders/{id}         { player, lookId, usd, amount, status, createdAt, expiresAt, paidAt, payer, hash }   `amount` is the raw amount as text
 //   owned/{player__lookId}  { player, lookId, orderId, grantedAt }
 //
@@ -33,7 +33,7 @@ export interface FirestoreLike {
 }
 
 export const FIRESTORE_SCAN_LIMIT = 5000;
-export const FIRESTORE_KEYS = { character: "setting:character", signin: "setting:signin", friends: "setting:friends", emotes: "setting:emotes" } as const;
+export const FIRESTORE_KEYS = { character: "setting:character", signin: "setting:signin", friends: "setting:friends", emotes: "setting:emotes", freePlay: "setting:freePlay" } as const;
 
 const text = (v: unknown, fallback = ""): string => (typeof v === "string" ? v : fallback);
 const num = (v: unknown, fallback = 0): number => (typeof v === "number" && Number.isFinite(v) ? v : fallback);
@@ -49,8 +49,14 @@ export function createFirestoreStore(db: FirestoreLike, collections: { meta?: st
   };
   return {
     async readSettings() {
-      const [character, signin, friends, emotes] = await Promise.all([valueOf(FIRESTORE_KEYS.character), valueOf(FIRESTORE_KEYS.signin), valueOf(FIRESTORE_KEYS.friends), valueOf(FIRESTORE_KEYS.emotes)]);
-      return { character: character?.value, signin: signin?.value, friends: friends?.value, emotes: emotes?.value };
+      const [character, signin, friends, emotes, freePlay] = await Promise.all([
+        valueOf(FIRESTORE_KEYS.character),
+        valueOf(FIRESTORE_KEYS.signin),
+        valueOf(FIRESTORE_KEYS.friends),
+        valueOf(FIRESTORE_KEYS.emotes),
+        valueOf(FIRESTORE_KEYS.freePlay),
+      ]);
+      return { character: character?.value, signin: signin?.value, friends: friends?.value, emotes: emotes?.value, freePlay: freePlay?.value };
     },
 
     async saveSettings(patch: GamePatch, now: number) {
@@ -60,6 +66,7 @@ export function createFirestoreStore(db: FirestoreLike, collections: { meta?: st
       if (patch.signin) (batch.set(db.collection(meta).doc(FIRESTORE_KEYS.signin), { value: patch.signin, at: now }), n++);
       if (patch.friends) (batch.set(db.collection(meta).doc(FIRESTORE_KEYS.friends), { value: patch.friends, at: now }), n++);
       if (patch.emotes) (batch.set(db.collection(meta).doc(FIRESTORE_KEYS.emotes), { value: patch.emotes, at: now }), n++);
+      if (patch.freePlay) (batch.set(db.collection(meta).doc(FIRESTORE_KEYS.freePlay), { value: patch.freePlay, at: now }), n++);
       if (n) await batch.commit();
     },
 

package/src/admin/conformance.ts

@@ -104,7 +104,7 @@ async function read(res: Response): Promise<{ status: number; text: string; json
 const REFUSAL_KEYS = new Set(["error", "reason", "signedInAs"]);
 
 /** Words of the game's data that a refusal or an answer to a visitor must never hold. */
-const DATA_WORDS = /"orders"|"players"|"totals"|"counts"|"character"|"signin"|"friends"|"emotes"|"warnings"/;
+const DATA_WORDS = /"orders"|"players"|"totals"|"counts"|"character"|"signin"|"friends"|"emotes"|"freePlay"|"warnings"/;
 
 export function adminConformance(host: ConformanceHost): ConformanceCase[] {
   const cases: ConformanceCase[] = [];
@@ -337,7 +337,7 @@ export function adminConformance(host: ConformanceHost): ConformanceCase[] {
 export type StoreHarness = {
   store: AdminStore;
   seed(data: { orders?: OrderRow[]; owned?: { player: string; lookId: string; at: number }[]; rate?: { value: string; at: number } }): Promise<void>;
-  /** Every row that the store could change by mistake, as one text: the orders, the owned looks and the meta rows that are NOT the four settings. Same rows, same text. */
+  /** Every row that the store could change by mistake, as one text: the orders, the owned looks and the meta rows that are NOT the five settings. Same rows, same text. */
   snapshot(): Promise<string>;
   /** Only for a store with `recentLogins` and `signOutEverywhere`: put admin sign-ins in the game's database (the store only reads them). */
   seedLogins?(rows: { at: number; country: string | null; browser: string }[]): Promise<void>;
@@ -363,7 +363,7 @@ export function adminStoreConformance(make: () => Promise<StoreHarness>): Confor
 
   add("a new store has no settings of its own", async ({ store }) => {
     const s = await store.readSettings();
-    check(s.character === undefined && s.signin === undefined && s.friends === undefined && s.emotes === undefined, `expected no settings, got ${JSON.stringify(s)}`);
+    check(s.character === undefined && s.signin === undefined && s.friends === undefined && s.emotes === undefined && s.freePlay === undefined, `expected no settings, got ${JSON.stringify(s)}`);
   });
 
   add("the friends list is kept as its own setting: each of its three words, and a patch of it leaves the other two", async ({ store }) => {
@@ -384,6 +384,15 @@ export function adminStoreConformance(make: () => Promise<StoreHarness>): Confor
     }
   });
 
+  add("the free play switch is kept as its own setting: off and on, and a patch of it leaves the other four", async ({ store }) => {
+    await store.saveSettings({ signin: "none", character: "own", friends: "off", emotes: "off" }, NOW);
+    for (const [i, freePlay] of (["off", "on"] as const).entries()) {
+      await store.saveSettings({ freePlay }, NOW + 1 + i);
+      const s = await store.readSettings();
+      check(s.freePlay === freePlay && s.signin === "none" && s.character === "own" && s.friends === "off" && s.emotes === "off", `after freePlay ${freePlay}: ${JSON.stringify(s)}`);
+    }
+  });
+
   add("a patch saves only what it names; the next patch keeps the rest", async ({ store }) => {
     await store.saveSettings({ signin: "none" }, NOW);
     let s = await store.readSettings();
@@ -399,13 +408,13 @@ export function adminStoreConformance(make: () => Promise<StoreHarness>): Confor
   add("an empty patch writes nothing and does not fail", async ({ store }) => {
     await store.saveSettings({}, NOW);
     const s = await store.readSettings();
-    check(s.character === undefined && s.signin === undefined && s.friends === undefined && s.emotes === undefined, "an empty patch must save nothing");
+    check(s.character === undefined && s.signin === undefined && s.friends === undefined && s.emotes === undefined && s.freePlay === undefined, "an empty patch must save nothing");
   });
 
   add("saving changes nothing but the settings: no order, no owned look, no other meta row", async (h) => {
     await h.seed({ orders: [order("1", {}), order("2", { status: "open" })], owned: [{ player: A, lookId: "mint-cap", at: NOW }], rate: { value: JSON.stringify({ usd: 1.2, sources: ["x"] }), at: NOW } });
     const before = await h.snapshot();
-    await h.store.saveSettings({ character: "own", signin: "none", friends: "off", emotes: "off" }, NOW + 5);
+    await h.store.saveSettings({ character: "own", signin: "none", friends: "off", emotes: "off", freePlay: "off" }, NOW + 5);
     check((await h.snapshot()) === before, "the rows of the game changed after saving the settings");
   });
 

package/src/admin/handler.ts

@@ -2,7 +2,7 @@
 //
 //   GET  {base}/summary   the numbers: status, orders, the looks that players own
 //   GET  {base}/game      the game switches
-//   POST {base}/game      a press: { character }, { signin }, { friends } or { emotes } (only the known words)
+//   POST {base}/game      a press: { character }, { signin }, { friends }, { emotes } or { freePlay } (only the known words)
 //   POST {base}/check     the payment check, when the game gives one
 //
 // EVERY request under the base goes through `adminAccess` first, before the route is even looked up: a visitor who is not the owner gets 401 or 403
@@ -190,7 +190,7 @@ export function createAdminHandler(options: AdminHandlerOptions): AdminHandler {
   return { routes, basePath: options.basePath ?? "/api/admin", handle };
 }
 
-/** The settings as the game's own routes need them (the listing file, the character, the friends list, the emotes): the stored words, or the game's defaults. A fault in the store gives the defaults. */
+/** The settings as the game's own routes need them (the listing file, the character, the friends list, the emotes, free play): the stored words, or the game's defaults. A fault in the store gives the defaults. */
 export async function loadGameSettings(store: Pick<AdminStore, "readSettings">, defaults: GameSettings): Promise<GameState> {
   try {
     return mergeSettings(await store.readSettings(), defaults);

package/src/admin/index.ts

@@ -17,5 +17,5 @@ export type { AdminLogin, AdminOrder, AdminPlayer, AdminStatus, AdminStore, Admi
 export { ORDERS_SHOWN, moneyOf, parseRate, shapeOrders, shapePlayers, statusOf, summarize } from "./summary.js";
 export type { OrderRow } from "./summary.js";
 export { RAW_PER_XNO, xnoText } from "./amount.js";
-export { CHARACTER_NEEDS_SIGNIN, CHARACTER_SIGNIN_OFF, DEFAULT_EMOTES, DEFAULT_FRIENDS, FRIENDS_CHOICES, FRIENDS_TITLE, REVIEW_LINK, REVIEW_NOTE, SWITCHES, isCharacter, isEmotes, isFriends, isSignin, isSigninChoice, mergeSettings, parsePatch, pressOf, signinOn, stateOf } from "./switches.js";
-export type { Character, Emotes, Friends, GamePatch, GameSettings, GameState, Signin, SwitchId } from "./switches.js";
+export { CHARACTER_NEEDS_SIGNIN, CHARACTER_SIGNIN_OFF, DEFAULT_EMOTES, DEFAULT_FREE_PLAY, DEFAULT_FRIENDS, FREE_PLAY_NOTE, FRIENDS_CHOICES, FRIENDS_TITLE, REVIEW_LINK, REVIEW_NOTE, SWITCHES, freePlayOn, isCharacter, isEmotes, isFreePlay, isFriends, isSignin, isSigninChoice, mergeSettings, parsePatch, pressOf, signinOn, stateOf } from "./switches.js";
+export type { Character, Emotes, FreePlay, Friends, GamePatch, GameSettings, GameState, Signin, SwitchId } from "./switches.js";

package/src/admin/memory.ts

@@ -35,13 +35,14 @@ export function createMemoryStore(seed: { orders?: OrderRow[]; owned?: { player:
     pendingAdminRequests: 0,
     pendingGameRequests: 0,
     async readSettings() {
-      return { character: store.rows.get("setting:character"), signin: store.rows.get("setting:signin"), friends: store.rows.get("setting:friends"), emotes: store.rows.get("setting:emotes") };
+      return { character: store.rows.get("setting:character"), signin: store.rows.get("setting:signin"), friends: store.rows.get("setting:friends"), emotes: store.rows.get("setting:emotes"), freePlay: store.rows.get("setting:freePlay") };
     },
     async saveSettings(patch: GamePatch) {
       if (patch.character) store.rows.set("setting:character", patch.character);
       if (patch.signin) store.rows.set("setting:signin", patch.signin);
       if (patch.friends) store.rows.set("setting:friends", patch.friends);
       if (patch.emotes) store.rows.set("setting:emotes", patch.emotes);
+      if (patch.freePlay) store.rows.set("setting:freePlay", patch.freePlay);
       store.writes++;
     },
     async summary(now: number): Promise<StoreSummary> {

package/src/admin/panel/gameCard.ts

@@ -1,9 +1,9 @@
 // The "Game" card of /admin: two switches, "Players can play as their Nanoterra character" and "Players can sign in with Nanoterra", one three-way
-// choice, "Friends list: Nanoterra / The game's own / Off", and the switch "Allow Nanoterra emotes". A press saves at once (POST {api}/game, behind the
-// same admin guard as every admin call) and the game reads the setting at run time, so the creator pushes and deploys nothing. The words are in
-// ../switches.ts. The card changes ONLY these four settings: never a look, a price or an order.
+// choice, "Friends list: Nanoterra / The game's own / Off", and the switches "Allow Nanoterra emotes" and "Free play". A press saves at once (POST
+// {api}/game, behind the same admin guard as every admin call) and the game reads the setting at run time, so the creator pushes and deploys nothing.
+// The words are in ../switches.ts. The card changes ONLY these five settings: never a look, a price or an order.
 
-import { CHARACTER_NEEDS_SIGNIN, CHARACTER_SIGNIN_OFF, FRIENDS_CHOICES, FRIENDS_TITLE, REVIEW_LINK, REVIEW_NOTE, SWITCHES, pressOf, signinOn, stateOf, type Friends, type GameState, type SwitchId } from "../switches.js";
+import { CHARACTER_NEEDS_SIGNIN, CHARACTER_SIGNIN_OFF, FREE_PLAY_NOTE, FRIENDS_CHOICES, FRIENDS_TITLE, REVIEW_LINK, REVIEW_NOTE, SWITCHES, pressOf, signinOn, stateOf, type Friends, type GameState, type SwitchId } from "../switches.js";
 import { ApiError, type Api } from "./api.js";
 import { h } from "./dom.js";
 
@@ -17,7 +17,7 @@ export function gameCard(api: Api, initial: GameState, defaultsFile = "the game'
   /** Under the character switch: it works only through sign-in, so it says so, and says what a player gets while sign-in is Off. */
   const needs = h("p", { class: "fine switch-needs" });
   const card = h("section", { class: "admin-card game-card", "aria-labelledby": "game-title" }, h("div", { class: "card-head" }, h("h2", { id: "game-title" }, "Game")));
-  card.append(h("p", { class: "fine card-intro" }, `Four choices about your game. A press saves at once: you push nothing and deploy nothing. They start from ${defaultsFile}, and a press here wins.`));
+  card.append(h("p", { class: "fine card-intro" }, `Five choices about your game. A press saves at once: you push nothing and deploy nothing. They start from ${defaultsFile}, and a press here wins.`));
   /** The friends choice: a radio group of three keys (arrow keys move between them, as a radio group does). */
   const friendsKeys = new Map<Friends, HTMLButtonElement>();
   const friendsNote = h("p", { class: "switch-note", id: "switch-friends-note" });
@@ -112,6 +112,9 @@ export function gameCard(api: Api, initial: GameState, defaultsFile = "the game'
   }
   card.append(h("div", { class: "switch-row friends-row" }, h("div", { class: "switch-head" }, h("span", { class: "switch-title", id: "switch-friends-label" }, FRIENDS_TITLE), group), friendsNote, friendsStatus));
   switchRow("emotes");
+  // Free play is a word of the listing file too: Nanoterra's review decides what its listing says ("Free to play" or "Paid").
+  switchRow("freePlay");
+  card.append(h("p", { class: "fine switch-review" }, FREE_PLAY_NOTE, " ", h("a", { href: REVIEW_LINK, target: "_blank", rel: "noopener noreferrer" }, "Open the launch page")));
   draw();
   return card;
 }

package/src/admin/panel/overview.ts

@@ -47,7 +47,7 @@ export function overviewView(looks: readonly Look[], colourOf: (lookId: string)
   const linkKey = (words: string, to: () => void) => h("button", { class: "btn btn-small btn-quiet link-key", type: "button", onclick: to }, words, h("span", { "aria-hidden": "true" }, "→"));
 
   function drawGame() {
-    const rows = (["character", "signin", "emotes"] as const).map((id) => {
+    const rows = (["character", "signin", "emotes", "freePlay"] as const).map((id) => {
       const on = game ? stateOf(id, game) : null;
       return h("li", {}, h("span", {}, SWITCHES[id].title), on === null ? h("span", { class: "pill" }, "Unknown") : h("span", { class: `pill ${on ? "pill-on" : "pill-off"}` }, on ? "On" : "Off"));
     });

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 four 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 five 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; friends?: unknown; emotes?: unknown }>;
+  readSettings(): Promise<{ character?: unknown; signin?: unknown; friends?: unknown; emotes?: unknown; freePlay?: unknown }>;
   /** Saves a checked patch: all of it or none of it. */
   saveSettings(patch: GamePatch, now: number): Promise<void>;
   summary(now: number): Promise<StoreSummary>;