@gtanczyk/diorama 0.2.0 → 0.4.0

package/README.md

@@ -113,6 +113,7 @@ Model answers are memoised by a hash of their inputs, so running a step again wi
 - [Characters, style and icons](docs/characters.md)
 - [NPC story stages, optional walks and travel](docs/npc-motion.md)
 - [Sound and voices](docs/sound.md)
+- [Releasing and the changelog](docs/releasing.md) ([CHANGELOG.md](CHANGELOG.md))
 
 ## Built at the Meta AI Global Hackathon
 

package/app/src/actions/fix.ts

@@ -22,19 +22,11 @@ async function fixPlace(ctx: ActionContext, slug: string, place: string, from: '
   const dir = path.join(ctx.root, slug);
   const blocked = agentBlocked(dir, ctx.by, place);
   if (blocked) throw new ActionError(423, blocked);
-  // The agent's repair limit: after three fixes in a row that left the place unplayable, it is the person's turn.
-  if (ctx.by === 'agent') {
-    const since = new Date(Date.now() - 30 * 60_000).toISOString();
-    const tries = ctx.jobs.list(slug).filter((j) => j.by === 'agent' && j.args.includes('--place') && j.args[j.args.indexOf('--place') + 1] === place && (j.queuedAt ?? '') >= since);
-    const lastOk = tries.findLastIndex((j) => j.state === 'done');
-    if (tries.slice(lastOk + 1).filter((j) => j.state === 'failed').length >= 3) {
-      throw new ActionError(429, `three fixes of ${place} in a row left it unplayable: stop here and tell the person what you tried and what you would do next`);
-    }
-  }
+  const note = ctx.by === 'agent' ? repairGuard(ctx, slug, place, label, from) : undefined;
   const placeDir = path.join(dir, 'places', place);
   const needs = { layout: null, paint: 'blockin.png', masks: 'painting.png', derive: 'masks.json' }[from];
   if (needs && !fs.existsSync(path.join(placeDir, needs))) throw new ActionError(404, `${slug}/${place} has no ${needs} yet: build it first`);
-  return ctx.jobs.start(slug, ['build', slug, '--from', from, '--to', 'verify', '--place', place], `${label} · ${place}`, ctx.by, () => {
+  const job = ctx.jobs.start(slug, ['build', slug, '--from', from, '--to', 'verify', '--place', place], `${label} · ${place}`, ctx.by, () => {
     // The job snapshots first, then changes its source. Queued fixes must not change a running build.
     fs.mkdirSync(placeDir, { recursive: true });
     const fixes = readCorrections(placeDir);
@@ -42,6 +34,32 @@ async function fixPlace(ctx: ActionContext, slug: string, place: string, from: '
     writeCorrections(placeDir, Corrections.parse(fixes));
     fs.rmSync(path.join(placeDir, 'verify.json'), { force: true });
   }, addedThing ? { place, key: addedThing } : undefined);
+  return note ? { ...job, note } : job;
+}
+
+/** Fixes that repaint or relayout cost a Muse call; cheap ones only rerun SAM and the walk grid. */
+const COSTLY = new Set(['layout', 'paint']);
+
+/**
+ * The agent's repair guardrail. A streak of fixes that left the place unplayable does not stop the agent: it steers it.
+ * After three, a fix that already failed in the streak is refused (it would fail the same way) and a new path goes
+ * ahead with a short reminder; after six, costly repaints and relayouts wait for the person, while cheap fixes stay open.
+ */
+function repairGuard(ctx: ActionContext, slug: string, place: string, label: string, from: string): string | undefined {
+  const since = new Date(Date.now() - 30 * 60_000).toISOString();
+  const tries = ctx.jobs.list(slug).filter((j) => j.by === 'agent' && j.args.includes('--place') && j.args[j.args.indexOf('--place') + 1] === place && (j.queuedAt ?? '') >= since);
+  const lastOk = tries.findLastIndex((j) => j.state === 'done');
+  const failed = tries.slice(lastOk + 1).filter((j) => j.state === 'failed');
+  if (failed.length < 3) return undefined;
+  const tried = [...new Set(failed.map((j) => j.label.replace(` · ${place}`, '')))];
+  const paths = 'other paths: mask_brush (paint or erase a thing\'s mask by hand), floor_cells (add or take back 60 px floor cells), stand_set or hero_start_set, thing_remove, corrections_clear of a fix that made it worse, or ask_person';
+  if (tried.includes(label)) {
+    throw new ActionError(429, `${place}: "${label}" already failed in this streak (${failed.length} fixes in a row left it unplayable: ${tried.join(', ')}). Do not repeat it; look with place_view (walk, masks) and take a different path. ${paths}.`);
+  }
+  if (failed.length >= 6 && COSTLY.has(from)) {
+    throw new ActionError(429, `${place}: ${failed.length} fixes in a row left it unplayable (${tried.join(', ')}). A repaint or relayout now costs credits on a guess: ask_person first, or keep to the cheap fixes. ${paths}.`);
+  }
+  return `${failed.length} fixes of ${place} in a row left it unplayable (${tried.join(', ')}); this one is a new path. Check place_status after it ends; if it fails too, tell the person briefly what you tried.`;
 }
 
 const thingOf = (c: Corrections, key: string) => (c.things[key] ??= { strokes: [] });

package/app/src/actions/story.ts

@@ -82,6 +82,33 @@ defineAction({
   },
 });
 
+defineAction({
+  name: 'story_look',
+  description: 'Set what the hero says looking at one thing (a sign, a prop, a car), adding the look line where the story has none and rewording it where it has one. '
+    + 'Nothing else in the story changes (story_redo would write it all again). Kept across rebuilds. A spoken line needs run_step voices afterwards.',
+  input: z.object({ slug: Slug, place: Slug, thing: Slug, text: z.string().trim().min(1).max(400) }),
+  async run({ slug, place, thing, text }, ctx) {
+    const files = open(slug, ctx);
+    const blocked = agentBlocked(files.dir, ctx.by);
+    if (blocked) throw new ActionError(423, blocked);
+    const story = readStory(files);
+    if (!story) throw new ActionError(409, `${slug} has no story yet: run_step story first`);
+    const spot = files.world().places.find((p) => p.key === place);
+    if (!spot) throw new ActionError(400, `${place} is not a place of ${slug}`);
+    if (!spot.things.some((t) => t.key === thing)) throw new ActionError(400, `${thing} is not a thing in ${place}: ${spot.things.map((t) => t.key).join(', ')}`);
+    const busy = ctx.jobs.busy(slug);
+    if (busy) throw new ActionError(409, `${busy.label} is ${busy.state}; wait before editing story text`);
+    new History(files.dir).snapshot(`story look ${place}/${thing}`, ctx.by);
+    const fixes = readStoryFixes(files);
+    const look = { text, at: new Date().toISOString() };
+    fixes.looks = { ...fixes.looks, [`${place}/${thing}`]: look };
+    files.write(storyFixesFile(files), StoryFixes.parse(fixes));
+    const now = applyTexts(story, { texts: {}, looks: { [`${place}/${thing}`]: look } }).story;
+    files.write(files.path('story.json'), now);
+    return { place, thing, text, spoken: storyLines(files.world(), now).some((l) => l.text === text) };
+  },
+});
+
 defineAction({
   name: 'story_redo',
   description: 'Have Spark write the story again to a wish ("the ferrywoman should want something in return", "after receiving the key she goes to the garden and thanks me there"); '
@@ -95,7 +122,7 @@ defineAction({
     const blocked = agentBlocked(files.dir, ctx.by);
     if (blocked) throw new ActionError(423, blocked);
     return ctx.jobs.start(slug, ['story', slug], wish ? 'rewrite story' : 'first story', ctx.by, () => {
-      files.write(storyFixesFile(files), StoryFixes.parse({ ...(wish && { wish }), texts: {} }));
+      files.write(storyFixesFile(files), StoryFixes.parse({ ...(wish && { wish }), texts: {}, looks: readStoryFixes(files).looks }));
     });
   },
 });

package/app/src/actions/style.ts

@@ -4,6 +4,7 @@ import { z } from 'zod';
 import { readCastFixes } from '../scene/cast-fixes.ts';
 import { readCorrections } from '../scene/corrections.ts';
 import { agentBlocked } from '../studio/locks.ts';
+import { kidsWorld } from '../world/drawings.ts';
 import { WorldFiles } from '../world/files.ts';
 import { Slug } from '../world/schema.ts';
 import { castKeys, planLine, SCOPES, stylePlan } from '../world/style-plan.ts';
@@ -22,7 +23,7 @@ defineAction({
     const fixes = readCastFixes(files);
     return {
       style: world.style,
-      kids: world.audience === 'kids' || fs.existsSync(files.path('drawings')),
+      kids: kidsWorld(files, world),
       places: Object.fromEntries(world.places.map((p) => [p.key, readCorrections(files.place(p.key)).style ?? null])),
       cast: Object.fromEntries(castKeys(world, files).map((k) => [k, fixes[k]?.style ?? null])),
       painted: readStyled(files),
@@ -53,7 +54,7 @@ defineAction({
     if (scope === 'cast' && key && !castKeys(world, files).includes(key)) throw new ActionError(404, `${slug} has no character ${key}: ${castKeys(world, files).join(', ')}`);
     if (scope === 'world' && key) throw new ActionError(400, 'scope world takes no key');
     const plan = stylePlan(files, world, scope, key);
-    const kids = world.audience === 'kids' || fs.existsSync(files.path('drawings'));
+    const kids = kidsWorld(files, world);
     if (!go) {
       return {
         estimate: plan,

package/app/src/commands/backdrop.ts

@@ -9,7 +9,7 @@ import { Geometry } from '../play/geometry.ts';
 import { defineCommand } from '../registry.ts';
 import { BACKDROP_GROW, backdropFor, smearedBackdrop, type Card } from '../scene/backdrop.ts';
 import { carryBetween, carryFrom, paintingFor, ran, remakes, tilesLine, withChange } from '../scene/carry.ts';
-import { cloudSheet, CRITTER, critterSheet, Depth, FALLING, fallSheet, farFlats, floatSheet, cloneFill, mistSheet, smokeSheet, waterSheet } from '../scene/layers.ts';
+import { cloudSheet, CRITTER, critterSheet, Depth, FALLING, fallSheet, STREAM, streamSheet, farFlats, floatSheet, cloneFill, mistSheet, smokeSheet, waterSheet } from '../scene/layers.ts';
 import { maskFromPng as waterMaskOf } from '../image/mask.ts';
 import { WorldFiles } from '../world/files.ts';
 
@@ -80,8 +80,22 @@ defineCommand({
         png = await sharp(cloneFill(raw, FRAME.width, FRAME.height, dilate(critterMask, 3)), { raw: { width: FRAME.width, height: FRAME.height, channels: 3 } }).png().toBuffer();
         files.write(at('backdrop.png'), png);
       }
+      // Small things painted falling in a stream (code rain, snow, petals) fall on the page (layers/stream-<i>.png):
+      // cut out of the backdrop here, each column falling at its own pace. Other things' masks stay put (a doorway
+      // inside the rain keeps what is seen through it).
+      const looks = (k: string) => place.things.find((t) => t.key === k)?.looks ?? '';
+      const streamKeys = Object.keys(notes).filter((k) => !keys.includes(k) && !critterKeys.includes(k) && STREAM.test(`${k} ${notes[k].phrase} ${looks(k)}`) && fs.existsSync(at('masks', `${k}.png`)));
+      const streams: Array<{ png: Buffer; region: Buffer; box: [number, number, number, number] }> = [];
+      for (const k of streamKeys) {
+        const others = await Promise.all(Object.keys(notes).filter((o) => o !== k && fs.existsSync(at('masks', `${o}.png`))).map(async (o) => maskFromPng(fs.readFileSync(at('masks', `${o}.png`)))));
+        const made = await streamSheet(png, await maskFromPng(fs.readFileSync(at('masks', `${k}.png`))), dilate(unionAll(FRAME.width, FRAME.height, others), 2));
+        if (!made) continue;
+        png = made.backdrop;
+        streams.push(made);
+      }
+      if (streams.length) files.write(at('backdrop.png'), png);
       // Painted waterfalls pour (layers/fall-<i>.png); they stay out of the flat water below them.
-      const fallKeys = Object.keys(notes).filter((k) => !keys.includes(k) && FALLING.test(`${k} ${notes[k].phrase}`) && fs.existsSync(at('masks', `${k}.png`)));
+      const fallKeys = Object.keys(notes).filter((k) => !keys.includes(k) && !streamKeys.includes(k) && FALLING.test(`${k} ${notes[k].phrase}`) && fs.existsSync(at('masks', `${k}.png`)));
       const fallMasks = await Promise.all(fallKeys.map(async (k) => maskFromPng(fs.readFileSync(at('masks', `${k}.png`)))));
       // The far view as flats one behind another (layers/), so it has depth of its own.
       fs.rmSync(at('layers'), { recursive: true, force: true });
@@ -133,6 +147,11 @@ defineCommand({
       const falls = (await Promise.all(fallMasks.map((m) => fallSheet(png, m)))).filter((f) => !!f);
       falls.forEach((f, i) => files.write(at('layers', `fall-${i}.png`), f.png));
       if (falls.length) console.log(`  ${place.key}: ${falls.length} waterfall(s) pouring`);
+      streams.forEach((f, i) => {
+        files.write(at('layers', `stream-${i}.png`), f.png);
+        files.write(at('layers', `stream-${i}-region.png`), f.region);
+      });
+      if (streams.length) console.log(`  ${place.key}: ${streams.length} stream(s) of small things falling (${streamKeys.join(', ')})`);
       const critters = critterKeys.length ? await critterSheet(withCritters, critterMask, wetMask) : [];
       critters.forEach((c, i) => files.write(at('layers', `critter-${i}.png`), c.png));
       if (critters.length) console.log(`  ${place.key}: ${critters.length} painted animal(s) ${critters.some((c) => c.medium === 'air') ? 'flying and ' : ''}swimming (${critterKeys.join(', ')})`);
@@ -162,7 +181,7 @@ defineCommand({
         files.write(at('layers', 'mist-mask.png'), mist.mask);
         console.log(`  ${place.key}: painted ${mist.phrase} drifting ${mist.drift === null ? 'with the wind' : mist.drift < 0 ? 'left' : 'right'}${mist.speed !== 1 ? ` x${mist.speed}` : ''}`);
       }
-      if (far || water || mist || smoke.length || falls.length || critters.length || clouds) {
+      if (far || water || mist || smoke.length || falls.length || streams.length || critters.length || clouds) {
         if (far) {
           files.write(at('layers', 'sky.png'), far.sky);
           far.flats.forEach((f, i) => files.write(at('layers', `${i}.png`), f.png));
@@ -176,6 +195,7 @@ defineCommand({
           ...(smoke.length && { smoke: smoke.map((s, i) => ({ file: `layers/smoke-${i}.png`, box: s.box })) }),
           ...(floats.length && { floats: floats.map((s, i) => ({ file: `layers/float-${i}.png`, box: s.box })) }),
           ...(falls.length && { falls: falls.map((f, i) => ({ file: `layers/fall-${i}.png`, box: f.box })) }),
+          ...(streams.length && { streams: streams.map((f, i) => ({ file: `layers/stream-${i}.png`, region: `layers/stream-${i}-region.png`, box: f.box })) }),
           ...(critters.length && { critters: critters.map((c, i) => ({ file: `layers/critter-${i}.png`, box: c.box, medium: c.medium, facing: c.facing })) }),
           ...(clouds && { clouds: { box: clouds.box, clip: 'layers/cloud-clip.png', ...(clouds.keep && { keep: 'layers/cloud-keep.png' }), bands: clouds.bands.map((b, i) => ({ file: `layers/cloud-${i}.png`, box: b.box, speed: b.speed })) } }),
         });

package/app/src/commands/clip.ts

@@ -149,6 +149,13 @@ async function gameTake(port: number, work: string, actions: Action[], zoom: boo
         clicks.push({ wall: await rec.click(at.x, at.y, { ms: 450, dwell: 150 }), ...at, place: here, action: a });
         continue;
       }
+      if (a.kind === 'go' && a.to) {
+        // A car's destination is picked on the board the page shows over it.
+        const at = await page.evaluate(`window.diorama.destinationPoint(${JSON.stringify(a.to)})`) as { x: number; y: number } | null;
+        if (!at) throw new Error(`no destination ${a.to} on the board`);
+        clicks.push({ wall: await rec.click(at.x, at.y, { ms: 650 }), ...at, place: here, action: a });
+        continue;
+      }
       const step: { use: string; verb?: string; with?: string } = a.kind === 'go' ? { use: a.via } : a.kind === 'talk' ? { use: a.npc } : { use: a.thing, verb: a.verb, ...(a.with ? { with: a.with } : {}) };
       // The bag is hidden in the clip: the item is lifted from it unseen and rides the cursor to its target.
       const pick = async () => {

package/app/src/commands/derive.ts

@@ -156,6 +156,15 @@ defineCommand({
         });
         console.log(`  ${place.key}: closed ${faced.closed} walk cells on an upright face (feet over thin air)${faced.beyond ? ` and ${faced.beyond} only they led to` : ''}`);
       }
+      if (place.kind === 'drive') {
+        // A drive's scenery streams past, so everything one clicks stays put as a card of its own (a road sign
+        // left in the scenery would slide away from where it is clicked).
+        const carded = new Set(geometry.occluders.map((o) => o.thing ?? o.key));
+        for (const t of geometry.things) {
+          if (carded.has(t.key) || !t.mask || t.role === 'npc') continue;
+          geometry.occluders.push({ key: `${t.key}#1`, thing: t.key, box: t.box, mask: t.mask, baseY: t.box[3] });
+        }
+      }
       files.write(at('geometry.json'), geometry);
       files.write(at('walk.png'), await walkPicture(painting, geometry, out.footprint));
       ran(at(), 'derive', carry?.old ?? painting);

package/app/src/commands/export.ts

@@ -90,6 +90,7 @@ export async function exportWorld(slug: string, out: string, home?: string, url?
         entry.layers.mist.mask = await copy(entry.layers.mist.mask);
       }
       for (const f of entry.layers.flats) f.file = await art(f.file); // transparent around the flat
+      for (const f of entry.layers.streams ?? []) [f.file, f.region] = [await art(f.file), await copy(f.region)];
       for (const f of [...(entry.layers.smoke ?? []), ...(entry.layers.floats ?? []), ...(entry.layers.falls ?? []), ...(entry.layers.critters ?? []), ...(entry.layers.clouds?.bands ?? [])]) f.file = await art(f.file);
       if (entry.layers.clouds) {
         entry.layers.clouds.clip = await copy(entry.layers.clouds.clip);

package/app/src/commands/language.ts

@@ -8,6 +8,7 @@ import { castFixesFile, readCastFixes } from '../scene/cast-fixes.ts';
 import { SoundPlan } from '../sound/plan.ts';
 import { readStoryFixes, StoryFixes, storyFixesFile, textAt } from '../story/fixes.ts';
 import { Story } from '../story/schema.ts';
+import { kidsWorld } from '../world/drawings.ts';
 import { WorldFiles } from '../world/files.ts';
 import { applyWorldTexts, languagePlan, planLine, relanguage, translateTexts, worldTexts } from '../world/language.ts';
 import { placeSources, soundPlanFrom } from './sound.ts';
@@ -32,7 +33,7 @@ defineCommand({
 
     if (!plan.same) {
       const texts = worldTexts(world, story);
-      const kids = world.audience === 'kids' || fs.existsSync(files.path('drawings'));
+      const kids = kidsWorld(files, world);
       console.log(`translating ${Object.keys(texts).length} texts from ${plan.from} to ${plan.to}`);
       const translated = await translateTexts(files.memo, texts, plan.from, plan.to, kids);
       const now = applyWorldTexts(world, story, translated, plan.to);

package/app/src/commands/layout.ts

@@ -3,8 +3,10 @@ import fs from 'node:fs';
 import { renderBlockin, renderPlan } from '../scene/blockin.ts';
 import { readCorrections } from '../scene/corrections.ts';
 import { layOut } from '../scene/layout.ts';
+import { framePhoto, placePicture } from '../scene/photo.ts';
 import { defineCommand } from '../registry.ts';
 import { WorldFiles } from '../world/files.ts';
+import { placeSketch } from '../world/drawings.ts';
 import { approvedConcept } from '../world/sketch.ts';
 
 defineCommand({
@@ -16,10 +18,13 @@ defineCommand({
     const world = files.world();
     const places = world.places.filter((p) => only.length === 0 || only.includes(p.key));
     await Promise.all(places.map(async (place) => {
-      // A place made from a photo is measured from it, and the photo stands in for the block-in.
-      const photoFile = files.place(place.key, 'photo.png');
-      const photo = fs.existsSync(photoFile) ? fs.readFileSync(photoFile) : undefined;
-      const layout = await layOut(files.memo, world, place, photo, readCorrections(files.place(place.key)).layout?.guidance, approvedConcept(files, 'place', place.key));
+      // A place made from a photo is measured from it, and the photo stands in for the block-in. So does a
+      // grown-up's sketch of the place: drawn in perspective, it is the camera Muse would paint anyway.
+      const sketch = !fs.existsSync(files.place(place.key, 'photo.png')) && !fs.existsSync(files.place(place.key, 'sketch.png')) ? placeSketch(files, place.key) : undefined;
+      if (sketch) files.write(files.place(place.key, 'sketch.png'), (await framePhoto(sketch)).image);
+      const picture = placePicture(files.place(place.key));
+      const photo = picture && fs.readFileSync(picture.file);
+      const layout = await layOut(files.memo, world, place, photo, readCorrections(files.place(place.key)).layout?.guidance, approvedConcept(files, 'place', place.key), picture?.kind);
       files.write(files.place(place.key, 'layout.json'), layout);
       const blockin = photo ?? await renderBlockin(layout, place);
       files.write(files.place(place.key, 'blockin.png'), blockin);

package/app/src/commands/masks.ts

@@ -11,6 +11,7 @@ import { locateThings, markFloors } from '../scene/locate.ts';
 import { checkMasks, type MaskCheck } from '../scene/maskcheck.ts';
 import { maskFloors, maskThings } from '../scene/masks.ts';
 import { paintingLayoutHash } from '../scene/paint-layout.ts';
+import { placePicture } from '../scene/photo.ts';
 import { maskBox, type Rect } from '../image/raster.ts';
 import { WorldFiles } from '../world/files.ts';
 
@@ -30,7 +31,7 @@ defineCommand({
       const painting = fs.readFileSync(at('painting.png'));
       // A rejected/stale checked painting must not be rescued by masks and invented floor strokes.
       // Legacy worlds without a report remain editable; rebuilding from paint checks them too.
-      if (!fs.existsSync(at('photo.png')) && fs.existsSync(at('painting-layout.json'))) {
+      if (!placePicture(at()) && fs.existsSync(at('painting-layout.json'))) {
         const report = files.readJson(at('painting-layout.json')) as { ok?: boolean; inputs?: string };
         if (!report.ok || report.inputs !== paintingLayoutHash(place, layout, fs.readFileSync(at('blockin.png')), painting)) {
           throw new Error(`PAINT_LAYOUT_MISMATCH ${place.key}: painting/layout changed or its composition check failed; rebuild this place from paint to inspect and repair it before masks`);

package/app/src/commands/paint.ts

@@ -8,8 +8,9 @@ import { addsPerson, critique, paintedPeople, repaint } from '../scene/critic.ts
 import { readCorrections, writeCorrections } from '../scene/corrections.ts';
 import { Layout } from '../scene/layout.ts';
 import { paintPlace } from '../scene/paint.ts';
+import { heroVehicle } from '../scene/vehicle.ts';
 import { alignPainting, PaintingLayoutError, paintingLayoutHash } from '../scene/paint-layout.ts';
-import { paintPhoto } from '../scene/photo.ts';
+import { paintPhoto, placePicture } from '../scene/photo.ts';
 import { restylePlace } from '../scene/restyle.ts';
 import { refusedByFilter, reword, withWords, worded, type Words } from '../scene/words.ts';
 import { defineCommand, takeOption } from '../registry.ts';
@@ -21,6 +22,9 @@ import { markStyled, placeStyle, readStyled } from '../world/styled.ts';
 /** Rewords Spark may try after the image safety filter refuses a painting, before the place is set aside. */
 const REWORDS = 2;
 
+/** From this new take on, a place is painted without its approved concept (see paint below). */
+const CONCEPT_TAKES = 2;
+
 defineCommand({
   name: 'paint',
   usage: 'paint <slug> [place...]  brief, paint, critique and repaint laid-out places [--take N]',
@@ -39,8 +43,12 @@ defineCommand({
       const world = { ...base, style };
       const layout = Layout.parse(files.readJson(files.place(place.key, 'layout.json')));
       const blockin = fs.readFileSync(files.place(place.key, 'blockin.png'));
-      const fromPhoto = fs.existsSync(files.place(place.key, 'photo.png'));
-      const concept = approvedConcept(files, 'place', place.key);
+      const picture = placePicture(files.place(place.key));
+      const fromPhoto = !!picture;
+      // An approved concept steers Muse's camera toward its own; when it keeps pulling the painting off the plan
+      // (a second new take was asked for), the place is painted from the block-in alone.
+      const concept = take >= CONCEPT_TAKES ? undefined : approvedConcept(files, 'place', place.key);
+      if (take >= CONCEPT_TAKES && approvedConcept(files, 'place', place.key)) console.log(`  ${place.key}: take ${take}, painted from the block-in without its concept`);
       const styleReference = worldStyleReference(files, style);
       // The first painting is kept while its block-in, layout and take stay the same, even without the model
       // cache (a world copied without memo/): a person's region repaint must not repaint the whole place.
@@ -90,7 +98,7 @@ defineCommand({
         const again = await critique(files.memo, worded(place, words), brief, first);
         // People are looked for on the painting as the game shows it, with every fix in, not only the first one.
         const shown = fs.existsSync(files.place(place.key, 'painting.png')) ? fs.readFileSync(files.place(place.key, 'painting.png')) : first;
-        for (const p of shown === first ? [] : await paintedPeople(files.memo, place.key, shown)) {
+        for (const p of shown === first || place.kind === 'drive' ? [] : await paintedPeople(files.memo, place.key, shown)) {
           again.issues.push({ key: 'person', problem: 'unwanted', region: p.box, fix: `Paint out the ${p.what}: continue what is behind them (planks, water, wall), add nothing new` });
         }
         const had = new Set(found.issues.map((i) => JSON.stringify([i.region, i.fix])));
@@ -110,9 +118,9 @@ defineCommand({
           brief = withWords(await writeBrief(files.memo, world, told, layout), words);
           files.write(files.place(place.key, 'brief.json'), brief);
           try {
-            first = fromPhoto
-              ? await paintPhoto(files.memo, world, told, blockin, brief, take, concept, styleReference)
-              : await paintPlace(files.memo, world, told, layout, blockin, brief, take, drawingsIn(files, place), concept, styleReference);
+            first = picture
+              ? await paintPhoto(files.memo, world, told, blockin, brief, take, concept, styleReference, picture.kind)
+              : await paintPlace(files.memo, world, told, layout, blockin, brief, take, drawingsIn(files, place), concept, styleReference, await heroVehicle(files, world, place));
             break;
           } catch (error) {
             if (!refusedByFilter(error)) throw error;

package/app/src/commands/play.ts

@@ -65,6 +65,7 @@ export function worldData(files: WorldFiles) {
       ...(flats.smoke?.length && { smoke: flats.smoke.map((f) => ({ ...f, file: rel(f.file) })) }),
       ...(flats.floats?.length && { floats: flats.floats.map((f) => ({ ...f, file: rel(f.file) })) }),
       ...(flats.falls?.length && { falls: flats.falls.map((f) => ({ ...f, file: rel(f.file) })) }),
+      ...(flats.streams?.length && { streams: flats.streams.map((f) => ({ ...f, file: rel(f.file), region: rel(f.region) })) }),
       ...(flats.critters?.length && { critters: flats.critters.map((f) => ({ ...f, file: rel(f.file) })) }),
       ...(flats.clouds && { clouds: { ...flats.clouds, clip: rel(flats.clouds.clip), ...(flats.clouds.keep && { keep: rel(flats.clouds.keep) }), bands: flats.clouds.bands.map((b) => ({ ...b, file: rel(b.file) })) } }),
     };

package/app/src/commands/playthrough.ts

@@ -13,12 +13,12 @@ import { WorldFiles } from '../world/files.ts';
 import { chromium } from './explore.ts';
 import { serveWorld } from './play.ts';
 
-type Step = { use: string; verb?: string; with?: string } | { act: Action } | { wait: number };
+type Step = { use: string; verb?: string; with?: string; to?: string } | { act: Action } | { wait: number };
 
 /** A story action as what a player does on the page: click the thing, or pick an answer. */
 export function toStep(action: Action): Step {
   switch (action.kind) {
-    case 'go': return { use: action.via };
+    case 'go': return { use: action.via, ...(action.to && { to: action.to }) };
     case 'talk': return { use: action.npc };
     case 'do': return { use: action.thing, verb: action.verb, ...(action.with ? { with: action.with } : {}) };
     default: return { act: action };

package/app/src/commands/world.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { defineCommand, takeOption } from '../registry.ts';
 import { describePerson, describePhoto, framePhoto, normalisePhoto } from '../scene/photo.ts';
 import { designWorld, type Extra } from '../world/design.ts';
-import { drawingFiles, drawingsBrief, drawnIssues, fitPlaces, keepDrawings, KIDS_STYLE, oneHero, readDrawings, readKinds } from '../world/drawings.ts';
+import { drawingFiles, drawingsBrief, drawnIssues, fitPlaces, grownUpDrawings, keepDrawings, KIDS_STYLE, oneHero, readDrawings, readKinds, sketchStyle } from '../world/drawings.ts';
 import { WorldFiles } from '../world/files.ts';
 import { hearAll, Idea, ideaFromTold, keepTold } from '../world/told.ts';
 import { CreativeChoices } from '../world/idea-review.ts';
@@ -11,7 +11,7 @@ import { CreativeChoices } from '../world/idea-review.ts';
 defineCommand({
   name: 'world',
   usage: 'world <slug> "<idea>"   design a world (world.json) with Muse Spark [--places N] [--photo room.jpg: a real room is the first place] [--hero-photo me.jpg: a real person is the hero] '
-    + '[--drawings DIR: photos of children\'s drawings become the hero, NPCs, items and places] [--told DIR: recordings of them telling the story; without an idea, the idea is written from them] [--kids: a game for 5-7 year olds; on with drawings or recordings] [--language Polish: the game\'s text and voices; with recordings, the language spoken]',
+    + '[--drawings DIR: photos of drawings (children\'s, or a grown-up\'s sketches, which keep their own medium and make no kids\' game) become the hero, NPCs, items and places] [--told DIR: recordings of them telling the story; without an idea, the idea is written from them] [--kids: a game for 5-7 year olds; on with drawings or recordings] [--language Polish: the game\'s text and voices; with recordings, the language spoken]',
   async run(args) {
     const places = Number(takeOption(args, 'places', '4'));
     const photoFile = takeOption(args, 'photo', '');
@@ -41,7 +41,10 @@ export async function designInitialWorld(files: WorldFiles, { places, photoFile
   // A drawn place over the places asked for goes into a place as a prop: places are what makes a build long.
   const drawn = fitPlaces(await readDrawings(files.memo, files), places);
   for (const d of drawn) console.log(`drawing ${d.file}: ${d.kind} ${d.key}, ${d.looks}`);
-  const kids = kidsFlag || drawn.length > 0 || said.length > 0;
+  // A grown-up's sketches make a world in their own medium, not a kids' game.
+  const sketched = grownUpDrawings(drawn);
+  const drawnStyle = sketched ? sketchStyle(drawn) : KIDS_STYLE;
+  const kids = kidsFlag || (drawn.length > 0 && !sketched) || said.length > 0;
 
   let idea = given;
   // The story says who leads, unless the grown-up already picked a drawing as the hero.
@@ -83,11 +86,11 @@ export async function designInitialWorld(files: WorldFiles, { places, photoFile
   const characters = drawn.filter(d => d.kind === 'hero' || d.kind === 'npc').map(d => d.key);
   const chooseHero = !!(choices?.answers.length || choices?.note) && characters.length > 1 && !drawn.some(d => readKinds(files)[d.file] === 'hero');
   const asks = [
-    drawn.length ? drawingsBrief(drawn, chosenStyle ?? KIDS_STYLE, chooseHero) : '',
+    drawn.length ? drawingsBrief(drawn, chosenStyle ?? drawnStyle, chooseHero) : '',
     chosenStyle ? `The creator explicitly chose this visual style: ${chosenStyle}. Preserve recognizable shapes and identities from all source drawings.` : '',
     other ? `Write the title and pitch in ${other}, the language of the players; everything else (style, shows, mood, looks, keys) stays in English for the painters.` : '',
     // The game shows a name over each speaker: in the players' language, as they call them.
-    other || kids ? `Add "names": {"<key>": "name"} for the hero and every npc: a short name ${other ? `in ${other} ` : ''}the players would call them by (the name the children gave them, if they gave one; else a short friendly name a child would give).${drawn.length ? ` Name every drawn item and place too, as a child would say it${other ? ` in ${other}` : ''} ("the blue hat", "the mushroom forest").` : ''}` : '',
+    other || kids ? `Add "names": {"<key>": "name"} for the hero and every npc: a short name ${other ? `in ${other} ` : ''}the players would call them by (the name ${kids ? 'the children' : 'the creator'} gave them, if they gave one; else a short ${kids ? 'friendly name a child would give' : 'name that fits the world'}).${drawn.length ? ` Name every drawn item and place too, as ${kids ? 'a child' : 'a player'} would say it${other ? ` in ${other}` : ''} ("the blue hat", "the mushroom forest").` : ''}` : '',
   ].filter(Boolean);
   const extra: Extra | undefined = asks.length ? { brief: asks.join('\n\n'), issues: (w) => {
     if (!chooseHero) return drawnIssues(w, drawn);
@@ -96,7 +99,7 @@ export async function designInitialWorld(files: WorldFiles, { places, photoFile
   } } : undefined;
   const designed = await designWorld(files.memo, hero ? `${idea}\nThe hero is ${hero.looks}` : idea, places, room, extra);
   if (chooseHero) oneHero(drawn, designed.hero.key);
-  const world = { ...designed, ...(drawn.length && { style: KIDS_STYLE }), ...(chosenStyle && { style: chosenStyle }), ...(hero && { hero }), ...(other && { language: other }), ...(kids && { audience: 'kids' as const }) };
+  const world = { ...designed, ...(drawn.length && { style: drawnStyle }), ...(chosenStyle && { style: chosenStyle }), ...(hero && { hero }), ...(other && { language: other }), ...(kids && { audience: 'kids' as const }) };
   files.write(files.path('world.json'), world);
   if (drawingFiles(files).length) files.write(files.path('drawings.json'), drawn);
   console.log(`${world.title}: ${world.places.map((p) => p.key).join(' · ')}`);

package/app/src/play/car.ts

@@ -0,0 +1,2 @@
+/** What a drive place's car is called: the build clears the road under it and the page bobs it. */
+export const CAR = /\b(car|cars|convertible|cab|taxi|truck|van|jeep|pickup|bus|coupe|sedan|wagon|buggy)\b/i;

package/app/src/play/geometry.ts

@@ -122,11 +122,21 @@ export function hides(o: Occluder, x: number, feetY: number, support?: (key: str
   return feetY < floorYAt(o, x) - BEHIND_MARGIN;
 }
 
-/** Column runs [x0, x1) inside [left, right) where the occluder hides the person; a few runs per occluder. */
-export function hiddenRuns(o: Occluder, left: number, right: number, feetY: number, support?: (key: string) => Occluder | undefined): Array<[number, number]> {
+/**
+ * Column runs [x0, x1) inside [left, right) where the occluder hides the person; a few runs per occluder.
+ * With `feetX` the person is one body at one distance: the floor line where their feet are decides for their
+ * whole box, so a slanted desk whose near leg is nearer than the feet and far leg farther hides all of them or
+ * none, never cuts them in half down one column. Past the occluder's ends its nearest column decides.
+ */
+export function hiddenRuns(o: Occluder, left: number, right: number, feetY: number, support?: (key: string) => Occluder | undefined, feetX?: number): Array<[number, number]> {
   const runs: Array<[number, number]> = [];
   const x0 = Math.max(Math.floor(left), Math.floor(o.box[0]));
   const x1 = Math.min(Math.ceil(right), Math.ceil(o.box[2]));
+  if (feetX !== undefined) {
+    if (x1 <= x0) return runs;
+    const at = Math.min(o.box[2] - 0.5, Math.max(o.box[0] + 0.5, feetX));
+    return hides(o, at, feetY, support) ? [[x0, x1]] : runs;
+  }
   let start = -1;
   for (let x = x0; x < x1; x++) {
     const hid = hides(o, x + 0.5, feetY, support);

package/app/src/play/parallax.ts

@@ -164,6 +164,8 @@ export type Layers = {
   floats?: Array<{ file: string; box: [number, number, number, number] }>;
   /** Painted waterfalls to set pouring: each a feathered copy of the fall over `box`. */
   falls?: Array<{ file: string; box: [number, number, number, number] }>;
+  /** Small things painted falling (code rain, snow, petals): what stands out of the paint over `box`, to fall column by column inside `region` (a soft mask). */
+  streams?: Array<{ file: string; region: string; box: [number, number, number, number] }>;
   /** Painted animals as small cards to swim (in the water) or fly (in the air), and which way each faces (1 right). */
   critters?: Array<{ file: string; box: [number, number, number, number]; medium: 'water' | 'air'; facing: 1 | -1 }>;
   /** The painted clouds as bands (bottom first) to drift with the wind at their own speeds, cut to `clip` over `box`; `keep`: what stays put in the sky. */

package/app/src/qa/route.ts

@@ -1,7 +1,7 @@
 import type { Page } from 'playwright';
 import type { Action } from '../story/engine.ts';
 
-type Step = { use: string; verb?: string; with?: string } | { act: Action } | { wait: number };
+type Step = { use: string; verb?: string; with?: string; to?: string } | { act: Action } | { wait: number };
 
 /** Follow a route through the same pointer targets, inventory and answers as a person. */
 export async function playRoute(page: Page, steps: Step[]): Promise<{ ending: string | null; frames: number; time: number }> {
@@ -20,6 +20,14 @@ export async function playRoute(page: Page, steps: Step[]): Promise<{ ending: st
       await page.locator(`#talk button[data-action=${JSON.stringify(action)}]`).click();
     } else {
       if (step.with) await page.locator(`#inventory button[data-item=${JSON.stringify(step.with)}]`).click();
+      if (step.to) {
+        // One thing that leads to several places (a car): its destination is picked on the board the page shows.
+        const at = await page.evaluate(`window.diorama.destinationPoint(${JSON.stringify(step.to)})`) as { x: number; y: number } | null;
+        if (!at) throw new Error(`No destination ${step.to} on the board for ${step.use}`);
+        await page.mouse.click(at.x, at.y);
+        await settled();
+        continue;
+      }
       const point = await aimPoint(page, step);
       if (!point) throw new Error(`No clickable pixel for ${step.use}: its pointer target is hidden or covered`);
       await page.mouse.click(point.x, point.y, { button: step.verb === 'look' ? 'right' : 'left' });
@@ -83,7 +91,9 @@ export function aimPoint(page: Page, step: { use: string; verb?: string; with?:
     const rect = canvas.getBoundingClientRect();
     const box = game.pageRect(step.use) ?? rect;
     const hits = (x, y) => {
-      const at = game.unzoom((x - rect.left) / rect.width * canvas.width, (y - rect.top) / rect.height * canvas.height);
+      // In frame pixels: the canvas holds fewer when the page lowers its resolution on a slow machine.
+      const frame = game.place.g.frame;
+      const at = game.unzoom((x - rect.left) / rect.width * frame.width, (y - rect.top) / rect.height * frame.height);
       return game.thingAt(...at)?.thing.key === step.use && document.elementFromPoint(x, y) === canvas;
     };
     const cx = box.left + box.width / 2, cy = box.top + box.height / 2;

package/app/src/scene/cast.ts

@@ -1,4 +1,5 @@
 import { STYLE_REFERENCE_PROMPT } from '../world/style-reference.ts';
+import { drawers } from '../world/drawings.ts';
 // The hero and every NPC as one painted figure each: Muse paints them alone on a plain ground, SAM cuts them out.
 import sharp from 'sharp';
 import type { Mask } from '../image/mask.ts';
@@ -76,9 +77,10 @@ Style: ${world.style}
 Nothing they sat or lay on: no bed, headboard, pillow, chair or blanket. Plain flat light grey background, no floor, no shadow, no other people, no props around, no text.`;
 }
 
-/** For a child's drawing: the character they drew, as they drew it, made whole enough to walk. */
+/** For a drawing (a child's, or an artist's sketch): the character as drawn, made whole enough to walk. */
 export function drawingPrompt(world: World, who: Who): string {
-  return `This is a child's drawing on paper. Paint the character in it as a single full-body character for a 2D point-and-click adventure game, so the child who drew it knows it at once: the same colours, the same clothes and features, the same shapes and proportions (a big head stays big), only cleaner and whole: every part coloured in solidly, with clear outlines and no white paper showing through, a finished character, not a sketch. Standing in a relaxed walking-ready pose, seen from the side in three-quarter view, facing to the right, the whole figure visible from the top of the head down to both feet (or paws), centred, about two thirds of the image tall.
+  const drawn = drawers(world);
+  return `This is ${drawn.one} on paper. Paint the character in it as a single full-body character for a 2D point-and-click adventure game, so ${drawn.who} knows it at once: the same colours, the same clothes and features, the same shapes and proportions (a big head stays big), only cleaner and whole: every part coloured in solidly, with clear outlines and no white paper showing through, a finished character, not a sketch. Standing in a relaxed walking-ready pose, seen from the side in three-quarter view, facing to the right, the whole figure visible from the top of the head down to both feet (or paws), centred, about two thirds of the image tall.
 
 Character: ${who.looks}
 Style: ${world.style}

package/app/src/scene/critic.ts

@@ -32,7 +32,7 @@ List at most 4 problems a player would notice, worst first:
 - missing: a listed thing is not there, or a big part of the scene above is (a tall tower, a castle with two towers, a house on top): key "scene" for that
 - wrong: it is there but does not look like its description
 - flat: it is a plain block or smear instead of a painted object
-- unwanted: people (any person or figure at all${cast.length ? `, even one that looks like ${cast.join(' or ')}: they are added over the picture later, so a painted one would be a double` : ''}), ${paintedAnimals(brief).length ? 'animals other than the listed ones' : 'animals'}, text, letters or a border that should not be there
+- unwanted: people (any person or figure at all${place.kind === 'drive' ? ' other than the hero at the wheel of the car, who belongs there' : ''}${cast.length ? `, even one that looks like ${cast.join(' or ')}: they are added over the picture later, so a painted one would be a double` : ''}), ${paintedAnimals(brief).length ? 'animals other than the listed ones' : 'animals'}, text, letters or a border that should not be there
 For each give the region to repaint as [x0, y0, x1, y1] in pixels and one sentence on what to paint there. Never ask for text or letters. If the painting is fine, give no issues.
 
 Never ask to paint a person in: the game adds its people over the picture.
@@ -42,7 +42,8 @@ Reply with JSON only: {"issues": [{"key": "...", "problem": "missing | wrong | f
   const found = { issues: parsed.issues.filter((i) => !addsPerson(i)) };
   // The critic weighs the whole picture and lets a figure pass when the place's words name one ("a child floats
   // candle boats"); people are asked about on their own, as every one of them is a double or a stranger.
-  const people = await paintedPeople(memo, place.key, painting);
+  // A drive's hero is painted at the wheel on purpose: no one is looked for there.
+  const people = place.kind === 'drive' ? [] : await paintedPeople(memo, place.key, painting);
   const near = (a: number[], b: number[]) => Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]) < 120;
   const extra = people.filter((p) => !found.issues.some((i) => i.problem === 'unwanted' && near(i.region, p.box))).map((p) => ({
     key: 'person', problem: 'unwanted' as const, region: pad(p.box, 24),