@gtanczyk/diorama 0.3.0 → 0.4.0

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/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/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/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/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),

package/app/src/scene/layout.ts

@@ -154,6 +154,15 @@ export function closeUpIssues(layout: Layout): string[] {
     : [];
 }
 
+/** A drive place: a side view of a road that loops sideways, the car standing on it, the signs beside it. */
+const DRIVE_LAYOUT = `
+This place is the hero's car: it stands at the kerb with its engine running, the hero at the wheel, and from here the player picks where to drive. So:
+- the car is the main thing: in the middle of the frame, a little below the centre, seen from behind at three-quarters so the driver shows through the window, about half the frame wide, its wheels on the street
+- one floor, the street and pavement around the car, reaching the bottom edge
+- the street and the city behind it fill the rest; leave the top right quarter of the frame calm (sky, a dark wall), the game lays its destination board there
+
+`;
+
 function brief(world: World, place: Place): string {
   const { width: W, height: H } = FRAME;
   return `Lay out one place of a 2D point-and-click adventure as a block-in for a painter. The frame is ${W}x${H} px, x to the right, y down; the camera looks a little down at the place, like at a stage.
@@ -169,8 +178,7 @@ Give:
 - floors: 1 to 4 walkable areas below the horizon as outlines, nearest first; the first reaches the bottom edge; every other floor touches one listed before it (a bridge, steps or a path across water or a drop is a floor too), so the hero can walk everywhere; leave room to walk around things
 - things: every thing as a box standing on the floor: x (centre), footY (where it touches the floor), width, height in px, metres (real height), colour (main colour), shape (its silhouette: block = a box, stall, cupboard; low = bench, table, boat, cart, bed; post = lamp, pole, sign, column; tree; arch = door, gate, archway, window, tunnel; round = barrel, pot, rock, bush, well; steps = stairs or steps; flat = lies on the floor: rug, water, tracks); nearer things sit lower and are bigger; exits sit at the edge of a floor; every exit, item and person stands on a floor; leave a way round every big thing, and never stand one across the only way to a floor
 - lights: up to 6 visible sources (lamps, fires, windows) with x, y, colour
-
-Reply with JSON only:
+${place.kind === 'drive' ? DRIVE_LAYOUT : ''}Reply with JSON only:
 {"horizon": 0, "sky": "#rrggbb", "ground": "#rrggbb",
  "floors": [{"key": "...", "is": "what the floor is", "colour": "#rrggbb", "outline": [[x, y], ...]}],
  "things": [{"key": "...", "colour": "#rrggbb", "x": 0, "footY": 0, "width": 0, "height": 0, "metres": 1.0, "shape": "block"}],
@@ -185,9 +193,9 @@ export function repairSmallBoxes(layout: Layout): Layout {
   })) };
 }
 
-/** With a photo, measure existing positions without resizing them. */
-export async function layOut(memo: Memo, world: World, place: Place, photo?: Buffer, guidance?: string, concept?: Buffer): Promise<Layout> {
-  const ask = () => (photo ? `${brief(world, place)}\n\nThe place already exists: it is the attached photo, ${FRAME.width}x${FRAME.height} px. Do not place anything; measure where each thing, floor and light is in it.` : brief(world, place));
+/** With a photo (or a grown-up's sketch of the place), measure existing positions without resizing them. */
+export async function layOut(memo: Memo, world: World, place: Place, photo?: Buffer, guidance?: string, concept?: Buffer, picture: 'photo' | 'sketch' = 'photo'): Promise<Layout> {
+  const ask = () => (photo ? `${brief(world, place)}\n\nThe place already exists: it is the attached ${picture === 'sketch' ? "artist's sketch (ignore the sketchbook page, notes and colour swatches)" : 'photo'}, ${FRAME.width}x${FRAME.height} px. Do not place anything; measure where each thing, floor and light is in it.` : brief(world, place));
   const base = ask() + (!photo && concept ? '\n\nThe attached image is the creator-approved concept for this place. Start from its camera and relative arrangement of the listed things, scaled to the output frame. Preserve the recognizable composition where possible, but adapt positions, sizes and floor connections to satisfy every walkability rule above. This is a concept, not a fixed photograph; do not copy inaccessible areas or invent extra things.' : '') + (guidance ? `\n\nLayout repair guidance: ${guidance}` : '');
   // Keep paid replies. An exhausted batch becomes feedback for the next batch, never an identical replay.
   const stateFile = path.join(memo.dir, 'layout-retries', `${inputHash(base, photo ?? '', ...(!photo && concept ? [concept] : []))}.json`);

package/app/src/scene/paint-layout.ts

@@ -51,7 +51,8 @@ const saysBlocked = (why: string) => BLOCKED.test(why);
 /** Fail closed on incomplete observations: an omitted floor is not evidence that it is connected. */
 export function paintedLayoutIssues(place: Place, layout: Layout, seen: PaintedLayout): string[] {
   const issues: string[] = [];
-  if (seen.people) issues.push('unwanted people painted into the background; the game adds its cast separately');
+  // A drive's hero is painted at the wheel of the car: the car's card carries them.
+  if (seen.people && place.kind !== 'drive') issues.push('unwanted people painted into the background; the game adds its cast separately');
   if (Math.abs(seen.horizon - layout.horizon) > 70) issues.push(`camera horizon moved from ${layout.horizon} to ${Math.round(seen.horizon)}`);
   for (const t of place.things.filter((t) => t.role !== 'npc')) {
     const planned = layout.things.find((b) => b.key === t.key);

package/app/src/scene/paint.ts

@@ -1,6 +1,8 @@
 import { STYLE_REFERENCE_PROMPT } from '../world/style-reference.ts';
+import { drawers } from '../world/drawings.ts';
 // paint: blockin.png becomes painting.png through one Muse edit.
 import sharp from 'sharp';
+import { VEHICLE_PROMPT } from './vehicle.ts';
 import type { Memo } from '../meta/memo.ts';
 import { museEdit } from '../meta/muse.ts';
 import type { Place, World } from '../world/schema.ts';
@@ -31,6 +33,9 @@ export function whereIs(layout: Layout, box: Layout['things'][number]): string {
   return `${back < 0.3 ? 'at the back' : back < 0.65 ? 'halfway back' : 'at the front'}, ${across}`;
 }
 
+/** A drive place is seen from the side at car height, and its scenery loops sideways in the page. */
+const DRIVE_PAINT = (world: World) => `The hero's car stands at the kerb with its engine running, lights on, a wisp of exhaust, seen from behind at three-quarters, with the hero at the wheel visible through the window or over the open top: ${world.hero.looks}. Keep the top right quarter of the picture calm, nothing important there.`;
+
 export function paintPrompt(world: World, place: Place, layout: Layout, brief?: Brief): string {
   const look = (key: string, fallback: string) => brief?.looks[key] ?? fallback;
   const masses = place.things
@@ -51,7 +56,7 @@ ${[...masses, ...floors].join('\n')}
 
 ${layoutContract(place, layout)}
 
-Seen a little from above, like a stage. Keep the floor areas clear to walk on. No people, ${noAnimals(brief)}, no text or letters, no border.${castNote(place)}${fallsIn(`${place.shows} ${place.mood}`) ? '\nThe rain or snow itself is animated over the picture later: paint no falling streaks, drops or flakes in the air, only what the weather leaves (wet sheen, puddles, snow lying on the ground).' : ''}`;
+${place.kind === 'drive' ? DRIVE_PAINT(world) : 'Seen a little from above, like a stage. Keep the floor areas clear to walk on.'} No ${place.kind === 'drive' ? 'other ' : ''}people, ${noAnimals(brief)}, no text or letters, no border.${castNote(place)}${fallsIn(`${place.shows} ${place.mood}`) ? '\nThe rain or snow itself is animated over the picture later: paint no falling streaks, drops or flakes in the air, only what the weather leaves (wet sheen, puddles, snow lying on the ground).' : ''}`;
 }
 
 function whereFloor(layout: Layout, f: Layout['floors'][number]): string {
@@ -60,22 +65,24 @@ function whereFloor(layout: Layout, f: Layout['floors'][number]): string {
   return whereIs(layout, mid);
 }
 
-/** Children's drawings of the place or of things in it, as more images after the block-in. */
+/** Drawings of the place or of things in it (children's, or an artist's sketches), as more images after the block-in. */
 export type Drawing = { key: string; image: Buffer };
 
-export function drawingsPrompt(place: Place, drawings: Drawing[]): string {
+export function drawingsPrompt(place: Place, drawings: Drawing[], kids = true): string {
   if (drawings.length === 0) return '';
+  const drawn = drawers({ audience: kids ? 'kids' : undefined });
   const which = drawings.map((d, i) => `image ${i + 2} is ${d.key === place.key ? 'this place' : `the ${d.key}`}`);
   return `
 
-The other images are children's drawings on paper: ${which.join(', ')}. Paint what they drew so the children know it at once: their colours, shapes and ideas. A drawing fills its paper, but its thing does not fill the place: paint each at its real size beside the others (a hat is smaller than a log, a person comes up to a door's top). The composition still comes only from the first image; leave out the paper, the table and any written names.`;
+The other images are ${drawn.many} on paper: ${which.join(', ')}. ${kids ? 'Paint what they drew so the children know it at once: their colours, shapes and ideas.' : 'Paint what was drawn so the artist knows it at once: the same shapes, colours, ideas and the same hand and medium.'} A drawing fills its paper, but its thing does not fill the place: paint each at its real size beside the others (a hat is smaller than a log, a person comes up to a door's top). The composition still comes only from the first image; leave out the paper, the table and any written names.`;
 }
 
 /** One Muse edit, scaled back to the layout frame (Muse answers larger than asked). */
-export async function paintPlace(memo: Memo, world: World, place: Place, layout: Layout, blockin: Buffer, brief?: Brief, take = 0, drawings: Drawing[] = [], concept?: Buffer, styleReference?: Buffer): Promise<Buffer> {
-  const prompt = paintPrompt(world, place, layout, brief) + drawingsPrompt(place, drawings)
+export async function paintPlace(memo: Memo, world: World, place: Place, layout: Layout, blockin: Buffer, brief?: Brief, take = 0, drawings: Drawing[] = [], concept?: Buffer, styleReference?: Buffer, vehicle?: Buffer): Promise<Buffer> {
+  const prompt = paintPrompt(world, place, layout, brief) + drawingsPrompt(place, drawings, world.audience === 'kids')
     + (styleReference ? `\nImage ${drawings.length + 2}: ${STYLE_REFERENCE_PROMPT}` : '')
-    + (concept ? '\nThe LAST image is the creator-approved concept for this place. Preserve its distinctive architecture, palette, materials and visual identity. The FIRST image remains the authoritative layout: adapt the approved appearance to those positions and clear walking areas. Do not add characters or extra objects from the concept.' : '');
-  const painted = await museEdit(memo, { label: `paint:${place.key}`, prompt, images: [blockin, ...drawings.map((d) => d.image), ...(styleReference ? [styleReference] : []), ...(concept ? [concept] : [])], take });
+    + (concept ? `\nImage ${drawings.length + 2 + (styleReference ? 1 : 0)} is the creator-approved concept for this place. Preserve its distinctive architecture, palette, materials and visual identity. The FIRST image remains the authoritative layout: adapt the approved appearance to those positions and clear walking areas. Do not add characters or extra objects from the concept.` : '')
+    + (vehicle ? `\nThe LAST image ${VEHICLE_PROMPT}` : '');
+  const painted = await museEdit(memo, { label: `paint:${place.key}`, prompt, images: [blockin, ...drawings.map((d) => d.image), ...(styleReference ? [styleReference] : []), ...(concept ? [concept] : []), ...(vehicle ? [vehicle] : [])], take });
   return sharp(painted).resize(FRAME.width, FRAME.height, { fit: 'fill' }).png().toBuffer();
 }

package/app/src/scene/photo.ts

@@ -1,6 +1,8 @@
 import { STYLE_REFERENCE_PROMPT } from '../world/style-reference.ts';
 // A real photo as a place: crop it to the game frame, let Spark read the room into things,
 // and let Muse repaint it in the world's style without moving anything.
+import fs from 'node:fs';
+import path from 'node:path';
 import sharp from 'sharp';
 import { z } from 'zod';
 import type { Memo } from '../meta/memo.ts';
@@ -58,6 +60,27 @@ Reply with JSON only:
   throw new Error('Spark could not read the photo into a place in 3 tries');
 }
 
+/** The picture a place was made from, which stands in for its block-in: a real photo, or a grown-up's sketch of the place. */
+export function placePicture(dir: string): { file: string; kind: 'photo' | 'sketch' } | undefined {
+  for (const kind of ['photo', 'sketch'] as const) {
+    const file = path.join(dir, `${kind}.png`);
+    if (fs.existsSync(file)) return { file, kind };
+  }
+  return undefined;
+}
+
+export function sketchPaintPrompt(world: World, place: Place, brief?: Brief): string {
+  const looks = place.things.filter((t) => t.role !== 'npc').map((t) => `- ${t.key}: ${brief?.looks[t.key] ?? t.looks}`);
+  return `Finish this artist's sketchbook drawing as a background of a 2D point-and-click adventure game. Keep the camera and every object exactly where and as big as it is in the sketch: same buildings, same furniture, same floor, same perspective. Keep the artist's hand and medium; only finish it: clean confident lines, full colour, depth and light.
+
+Style: ${world.style}
+Mood: ${place.mood}
+Objects to keep recognisable:
+${looks.join('\n')}
+
+Leave out the sketchbook page itself: its edges and spine, the handwritten notes, colour swatches and any writing; continue the scene out to every edge of the frame. Remove every person; paint what is behind them. Keep the floor clear to walk on. No text or letters, no border.`;
+}
+
 export function photoPaintPrompt(world: World, place: Place, brief?: Brief): string {
   const looks = place.things.filter((t) => t.role !== 'npc').map((t) => `- ${t.key}: ${brief?.looks[t.key] ?? t.looks}`);
   return `Repaint this photo as a finished background of a 2D point-and-click adventure game. Keep the camera and every object exactly where and as big as it is in the photo: same walls, same furniture, same door, same floor. Only the medium changes.
@@ -70,8 +93,8 @@ ${looks.join('\n')}
 Remove every person; paint the furniture and floor behind them. Keep the floor clear to walk on. No text or letters, no border.`;
 }
 
-export async function paintPhoto(memo: Memo, world: World, place: Place, photo: Buffer, brief?: Brief, take = 0, concept?: Buffer, styleReference?: Buffer): Promise<Buffer> {
-  const prompt = photoPaintPrompt(world, place, brief) + (styleReference ? '\nThe LAST image: ' + STYLE_REFERENCE_PROMPT : '') + (concept ? '\nThe second image is the creator-approved visual concept: preserve its palette and treatment. The first photo is authoritative for the real room, furniture, perspective and layout.' : '');
+export async function paintPhoto(memo: Memo, world: World, place: Place, photo: Buffer, brief?: Brief, take = 0, concept?: Buffer, styleReference?: Buffer, picture: 'photo' | 'sketch' = 'photo'): Promise<Buffer> {
+  const prompt = (picture === 'sketch' ? sketchPaintPrompt : photoPaintPrompt)(world, place, brief) + (styleReference ? '\nThe LAST image: ' + STYLE_REFERENCE_PROMPT : '') + (concept ? '\nThe second image is the creator-approved visual concept: preserve its palette and treatment. The first photo is authoritative for the real room, furniture, perspective and layout.' : '');
   const painted = await museEdit(memo, { label: `paint:${place.key}`, prompt, images: [photo, ...(concept ? [concept] : []), ...(styleReference ? [styleReference] : [])], take });
   return sharp(painted).resize(FRAME.width, FRAME.height, { fit: 'fill' }).png().toBuffer();
 }

package/app/src/scene/status.ts

@@ -7,6 +7,7 @@ import { World, type Place } from '../world/schema.ts';
 import { verifyPlace, type BackdropNotes, type MaskNotes, type PlateNotes, type Verdict } from './verify.ts';
 import { Layout } from './layout.ts';
 import { paintingLayoutHash } from './paint-layout.ts';
+import { placePicture } from './photo.ts';
 
 export function currentVerdict(worldDir: string, key: string, place?: Place): Verdict | null {
   const dir = path.join(worldDir, 'places', key);
@@ -18,7 +19,7 @@ export function currentVerdict(worldDir: string, key: string, place?: Place): Ve
     if (!place) throw new Error(`no place ${key}`);
     const read = (file: string) => JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
     const optional = <T>(file: string) => (fs.existsSync(path.join(dir, file)) ? read(file) as T : {} as T);
-    if (!fs.existsSync(path.join(dir, 'photo.png')) && fs.existsSync(path.join(dir, 'painting-layout.json'))) {
+    if (!placePicture(dir) && fs.existsSync(path.join(dir, 'painting-layout.json'))) {
       const r = read('painting-layout.json') as { ok?: boolean; inputs?: string; attempts?: Array<{ issues: string[] }> };
       if (!r.ok || r.inputs !== paintingLayoutHash(place, Layout.parse(read('layout.json')), fs.readFileSync(path.join(dir, 'blockin.png')), fs.readFileSync(path.join(dir, 'painting.png')))) {
         return { ok: false, errors: [{ code: 'PAINT_LAYOUT_MISMATCH', detail: r.attempts?.at(-1)?.issues.join('; ') || 'Composition check is pending or stale: rebuild from paint.' }], flags: [] };

package/app/src/scene/vehicle.ts

@@ -0,0 +1,22 @@
+// The hero's car (a drive place, kind "drive") is parked in every place it drives to. Muse paints each place on its
+// own, so without a reference each parks a different car; the car as painted in the drive place, cut out by its
+// mask, goes to every such place's painting as how the car looks.
+import fs from 'node:fs';
+import sharp from 'sharp';
+import type { WorldFiles } from '../world/files.ts';
+import type { Place, World } from '../world/schema.ts';
+
+/** The drive place's car, cut out on white, for a place it is parked in; undefined before it is painted and masked. */
+export async function heroVehicle(files: WorldFiles, world: World, place: Place): Promise<Buffer | undefined> {
+  const drive = world.places.find((p) => p.kind === 'drive');
+  if (!drive || drive.key === place.key || !place.exits.some((e) => e.to === drive.key)) return undefined;
+  const car = drive.exits[0]?.via;
+  const [painting, mask] = [files.place(drive.key, 'painting.png'), files.place(drive.key, 'masks', `${car}.png`)];
+  if (!car || !fs.existsSync(painting) || !fs.existsSync(mask)) return undefined;
+  const { width, height } = await sharp(painting).metadata();
+  const alpha = await sharp(mask).resize(width, height, { fit: 'fill' }).greyscale().raw().toBuffer();
+  const cut = await sharp(painting).removeAlpha().joinChannel(alpha, { raw: { width: width!, height: height!, channels: 1 } }).png().toBuffer();
+  return sharp(cut).trim().flatten({ background: '#ffffff' }).png().toBuffer();
+}
+
+export const VEHICLE_PROMPT = 'shows the hero\'s car: wherever the car stands in this place, paint exactly this car (body shape, colour, trim, wheels), parked and seen from this place\'s camera; whoever sits in it is not part of it, and nothing else in that image belongs in the place.';