sci2-ts 0.11.0 → 0.13.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project. Versions follow [Semantic Versioning](https
 and the entries are generated from commit messages
 ([Conventional Commits](https://www.conventionalcommits.org/)) when a release is made.
 
+## [0.13.0](https://github.com/rlueder/sci-ts/compare/v0.12.0...v0.13.0) (2026-10-02)
+
+### Added
+
+* **content:** perspective measured across the floor, for rooms painted at an angle ([#15](https://github.com/rlueder/sci-ts/issues/15)) ([8020031](https://github.com/rlueder/sci-ts/commit/8020031785b75c966ba449c7bcbe159002868fec))
+
+## [0.12.0](https://github.com/rlueder/sci-ts/compare/v0.11.0...v0.12.0) (2026-10-02)
+
+### Added
+
+* **lib:** portraits that face the middle from their character's side, framed, and one for the hero ([#14](https://github.com/rlueder/sci-ts/issues/14)) ([e7be055](https://github.com/rlueder/sci-ts/commit/e7be0555af2c49743c539e7231cf979ac274617e))
+
 ## [0.11.0](https://github.com/rlueder/sci-ts/compare/v0.10.0...v0.11.0) (2026-10-02)
 
 ### Added

package/lib/996.sc

@@ -17,7 +17,10 @@
     back 255        ; paper
     border 0        ; a one-pixel border's colour; -1: none
     frame -1        ; a frame view, or -1
-    margin 4))      ; between the text and the border or frame
+    margin 4        ; between the text and the border or frame
+    portraitFrame -1 ; a view around portraits: loop 0 behind the face, loop 1 over its edges
+    portraitX 8     ; where a portrait's face goes on the left (mirrored on the right)
+    portraitY 8))
 
 ;; A box of text over the room: drawn by the interpreter into a bitmap, shown as a screen
 ;; item in the UI plane. Set text (and width, x, y), then init; it's as tall as the text
@@ -191,34 +194,80 @@
     (super say: line &rest whoCares)))
 
 ;; Someone with a portrait: a view whose loop 0 is the bust, loop 1 the mouth and loop 2 the
-;; eyes, every cel the same size and anchored at its top-left corner. The room's talker hands
-;; its parts to init: mouth bust eyes frame, where frame is drawn first (the bust), placed
-;; where the portrait goes (the top left of the screen). The text goes to its right. While
-;; the line is said the mouth moves, then closes; the eyes blink.
+;; eyes, every cel the same size and anchored at its top-left corner; loops 3 to 5, if there
+;; are any, are the same facing left. A room's talker is handed its parts (init: mouth bust
+;; eyes frame, where frame is drawn as the bust); one with a view of its own (the hero's)
+;; makes them. While the line is said the mouth moves, then closes; the eyes blink.
+;;
+;; The portrait goes at the top left facing right, or the top right facing left, with the
+;; text beside it on the side towards the middle. A character takes the side of the hero
+;; it stands on (who: is its body in the room; without one, the right); the hero takes the
+;; side opposite whoever spoke last. The textStyle places it (portraitX, portraitY) and can
+;; frame it (portraitFrame).
 (class PortraitTalker of Talker
   (properties
     mouth 0 bust 0 eyes 0 frame 0
+    view -1         ; the portrait's view, for a talker that makes its own parts
+    who 0           ; the character's body in the room
+    side 0          ; where the portrait is: 0 the left, 1 the right
+    otherSide 1     ; the hero's: the side of whoever spoke last
+    back 0 front 0  ; the portraitFrame, behind the face and over its edges
     priority 150
     mouthFor 0)     ; cycles the mouth moves for
 
   (method (init theMouth theBust theEyes theFrame)
-    (= mouth theMouth)
-    (= bust theBust)
-    (= eyes theEyes)
-    (= frame theFrame))
-
-  (method (say txt whoCares &tmp portrait)
-    (self init:)
-    (= portrait (if frame frame else bust))
-    (if portrait
-      (= x (+ (portrait x?) (CelWide (portrait view?) (portrait loop?) (portrait cel?)) 6))
-      (= y (portrait y?))
-      (= width (- SCREEN_WIDTH (+ x 6))))
+    (if argc
+      (= mouth theMouth)
+      (= bust theBust)
+      (= eyes theEyes)
+      (= frame theFrame)))
+
+  (method (makeParts)
+    (if (and (!= view -1) (not bust) (not frame))
+      (= bust ((View new:) view: view yourself:))
+      (= mouth ((Prop new:) view: view yourself:))
+      (= eyes ((Prop new:) view: view yourself:))))
+
+  ;; This line's side: see above.
+  (method (pickSide &tmp s)
+    (if (== self heroTalker) (return (- 1 otherSide)))
+    (= s (if (and who ego (< (who x?) (ego x?))) 0 else 1))
+    (if (and heroTalker (!= heroTalker self) (heroTalker respondsTo: #otherSide)) (heroTalker otherSide: s))
+    (return s))
+
+  (method (say txt whoCares &tmp face l pw f fx fy over)
+    (self init: makeParts:)
+    (= face (if frame frame else bust))
+    (if face
+      (= side (self pickSide:))
+      (= l (if (and side (>= (NumLoops face) 6)) 3 else 0))
+      (= pw (CelWide (face view?) l 0))
+      (= f (textStyle portraitFrame?))
+      (= over (if (!= f -1) (/ (- (CelWide f 0 0) pw) 2) else 0))
+      (= fx (if side (- SCREEN_WIDTH (+ (textStyle portraitX?) pw)) else (textStyle portraitX?)))
+      (= fy (textStyle portraitY?))
+      (face x: fx y: fy loop: l cel: 0)
+      (if mouth (mouth x: fx y: fy loop: (+ l 1) cel: 0))
+      (if eyes (eyes x: fx y: fy loop: (+ l 2) cel: 0))
+      (if (!= f -1)
+        (if (not back) (= back ((View new:) view: f loop: 0 cel: 0 yourself:)))
+        (back x: fx y: fy)
+        (if (and (not front) (>= (NumLoops back) 2)) (= front ((View new:) view: f loop: 1 cel: 0 yourself:)))
+        (if front (front x: fx y: fy)))
+      ;; The text beside it, towards the middle.
+      (= y fy)
+      (if side
+        (= x 6)
+        (= width (- fx (+ over 12)))
+       else
+        (= x (+ fx pw over 6))
+        (= width (- SCREEN_WIDTH (+ x 6)))))
     (super say: txt &rest whoCares)
-    (self showPart: frame priority)
-    (self showPart: bust priority)
-    (self showPart: eyes (+ priority 1))
+    (self showPart: back (- priority 1))
+    (self showPart: face priority)
     (self showPart: mouth (+ priority 1))
+    (self showPart: eyes (+ priority 1))
+    (self showPart: front (+ priority 2))
     (if eyes (eyes setCycle: Blink))
     (if mouth
       (mouth setCycle: Forward)
@@ -236,11 +285,19 @@
       (part init:)
       (part plane: uiPlane setPri: pri)))
 
+  ;; Off the screen, kept for the next line.
+  (method (hidePart part)
+    (if part
+      (DeleteScreenItem part)
+      (cast delete: part)))
+
   (method (clear)
-    (if frame (frame dispose:))
-    (if bust (bust dispose:))
-    (if eyes (eyes dispose:))
-    (if mouth (mouth dispose:))
+    (self hidePart: front)
+    (self hidePart: back)
+    (self hidePart: frame)
+    (self hidePart: bust)
+    (self hidePart: eyes)
+    (self hidePart: mouth)
     (super clear:)))
 
 ;; Says the lines of a message file for a noun, verb and condition, in sequence:

package/lib/997.sc

@@ -224,3 +224,43 @@
       scaleX: (/ (* pct 128) 100)
       scaleY: (/ (* pct 128) 100)
       scaleSignal: (| (client scaleSignal?) SCALE_ON))))
+
+;; Sizes its client on a floor seen at an angle, where one line across the screen isn't the
+;; same depth all the way along. Sizes are measured at the back and front of the floor at
+;; three places across it (left, middle, right): at each of those, size changes in a straight
+;; line with y, as perspective does; between them, in a straight line with x.
+;;   (actor setScaler: FloorScaler x1 backY1 back1 frontY1 front1  x2 ...  x3 ...)
+(class FloorScaler of Scaler
+  (properties
+    x1 0 yb1 0 sb1 100 yf1 1 sf1 100
+    x2 1 yb2 0 sb2 100 yf2 1 sf2 100
+    x3 2 yb3 0 sb3 100 yf3 1 sf3 100)
+
+  (method (init who a1 b1 c1 d1 e1 a2 b2 c2 d2 e2 a3 b3 c3 d3 e3)
+    (= client who)
+    (= x1 a1) (= yb1 b1) (= sb1 c1) (= yf1 d1) (= sf1 e1)
+    (= x2 a2) (= yb2 b2) (= sb2 c2) (= yf2 d2) (= sf2 e2)
+    (= x3 a3) (= yb3 b3) (= sb3 c3) (= yf3 d3) (= sf3 e3)
+    (self doit:))
+
+  ;; The size at y where one place was measured: the straight line through its back and front.
+  (method (along y yb sb yf sf)
+    (return (+ sb (/ (* (- sf sb) (- y yb)) (- yf yb)))))
+
+  (method (doit &tmp x y a b c pct)
+    (= x (client x?))
+    (= y (client y?))
+    (= a (self along: y yb1 sb1 yf1 sf1))
+    (= b (self along: y yb2 sb2 yf2 sf2))
+    (= c (self along: y yb3 sb3 yf3 sf3))
+    (= pct
+      (cond
+        ((<= x x1) a)
+        ((< x x2) (+ a (/ (* (- b a) (- x x1)) (- x2 x1))))
+        ((< x x3) (+ b (/ (* (- c b) (- x x2)) (- x3 x2))))
+        (else c)))
+    (if (< pct 1) (= pct 1))
+    (client
+      scaleX: (/ (* pct 128) 100)
+      scaleY: (/ (* pct 128) 100)
+      scaleSignal: (| (client scaleSignal?) SCALE_ON))))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sci2-ts",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "An SCI2 adventure game engine in TypeScript, and the tools to make games with it",
   "license": "MIT",
   "type": "module",

package/packages/content/room.schema.json

@@ -123,23 +123,74 @@
       }
     },
     "perspective": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "horizon",
-        "fullSize"
-      ],
-      "description": "The picture's camera: people are sized by how far below the horizon they stand. The hero and props that move are sized as they go.",
-      "properties": {
-        "horizon": {
-          "type": "integer",
-          "description": "The y the floor's lines meet at"
+      "description": "How people are sized by where they stand: a level camera's horizon and full-size line, or sizes measured at up to three places across the floor (for a picture painted at an angle)",
+      "oneOf": [
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "horizon",
+            "fullSize"
+          ],
+          "properties": {
+            "horizon": {
+              "type": "integer",
+              "description": "The y the floor's lines meet at"
+            },
+            "fullSize": {
+              "type": "integer",
+              "description": "The y of a figure's feet where it's drawn at full size"
+            }
+          }
         },
-        "fullSize": {
-          "type": "integer",
-          "description": "The y of a figure's feet where it's drawn at full size"
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "columns"
+          ],
+          "properties": {
+            "columns": {
+              "type": "array",
+              "minItems": 1,
+              "maxItems": 3,
+              "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "required": [
+                  "x",
+                  "back",
+                  "front"
+                ],
+                "properties": {
+                  "x": {
+                    "type": "integer",
+                    "description": "Where across the floor it was measured"
+                  },
+                  "back": {
+                    "type": "array",
+                    "items": {
+                      "type": "integer"
+                    },
+                    "minItems": 2,
+                    "maxItems": 2,
+                    "description": "[y, size in percent] at the back of the floor"
+                  },
+                  "front": {
+                    "type": "array",
+                    "items": {
+                      "type": "integer"
+                    },
+                    "minItems": 2,
+                    "maxItems": 2,
+                    "description": "[y, size in percent] at the front of the floor"
+                  }
+                }
+              }
+            }
+          }
         }
-      }
+      ]
     },
     "walkable": {
       "$ref": "#/$defs/polygon",

package/packages/content/src/room.d.ts

@@ -43,10 +43,16 @@ export interface RoomSpec {
      * size. A figure's height is in proportion to how far below the horizon it stands, so it
      * shrinks towards the back and grows past fullSize at the front. The hero and props that
      * move are sized as they go; a still prop only with scale: true.
+     *
+     * A picture painted at an angle, where a line across the screen isn't one depth all the
+     * way along, gives sizes measured instead: `columns`, up to three places across the floor
+     * (left, middle, right), each with a size at the back and at the front of the floor.
      */
     perspective?: {
         horizon: number;
         fullSize: number;
+    } | {
+        columns: FloorColumn[];
     };
     /** The floor: a polygon the hero stays inside. */
     walkable?: Point[];
@@ -70,6 +76,12 @@ interface CharacterSpec {
     portrait?: number;
 }
 type Point = [number, number];
+/** A place across the floor where sizes were measured: x, and [y, percent] at the back and front. */
+export interface FloorColumn {
+    x: number;
+    back: [number, number];
+    front: [number, number];
+}
 type Rect = [number, number, number, number];
 interface FeatureSpec {
     /** left, top, right, bottom (room coordinates). */

package/packages/content/src/room.js

@@ -64,11 +64,37 @@ class SpecChecker {
         }
         if (s.perspective !== undefined) {
             const pv = this.map(s.perspective, ["perspective"]);
-            this.known(pv, ["perspective"], ["horizon", "fullSize"]);
-            this.int(pv.horizon, ["perspective", "horizon"], -1000, 199);
-            this.int(pv.fullSize, ["perspective", "fullSize"], 0, 1000);
-            if (pv.fullSize <= pv.horizon)
-                this.fail(["perspective", "fullSize"], "must be below the horizon (a bigger y)");
+            if (pv.columns !== undefined) {
+                this.known(pv, ["perspective"], ["columns"]);
+                if (!Array.isArray(pv.columns) || pv.columns.length < 1 || pv.columns.length > 3)
+                    this.fail(["perspective", "columns"], "expected one to three places across the floor");
+                let lastX = -Infinity;
+                pv.columns.forEach((value, i) => {
+                    const path = ["perspective", "columns", i];
+                    const c = this.map(value, path);
+                    this.known(c, path, ["x", "back", "front"]);
+                    this.int(c.x, [...path, "x"], 0, 319);
+                    if (c.x <= lastX)
+                        this.fail([...path, "x"], "places go left to right");
+                    lastX = c.x;
+                    for (const end of ["back", "front"]) {
+                        const v = c[end];
+                        if (!Array.isArray(v) || v.length !== 2)
+                            this.fail([...path, end], "expected [y, size in percent]");
+                        this.int(v[0], [...path, end, 0], 0, 199);
+                        this.int(v[1], [...path, end, 1], 1, 400);
+                    }
+                    if (c.back[0] >= c.front[0])
+                        this.fail([...path, "front"], "the front is lower on the screen than the back (a bigger y)");
+                });
+            }
+            else {
+                this.known(pv, ["perspective"], ["horizon", "fullSize", "columns"]);
+                this.int(pv.horizon, ["perspective", "horizon"], -1000, 199);
+                this.int(pv.fullSize, ["perspective", "fullSize"], 0, 1000);
+                if (pv.fullSize <= pv.horizon)
+                    this.fail(["perspective", "fullSize"], "must be below the horizon (a bigger y)");
+            }
         }
         if (s.walkable !== undefined)
             this.polygon(s.walkable, ["walkable"]);
@@ -188,6 +214,30 @@ class SpecChecker {
     }
 }
 const SCREEN_BOTTOM = 200;
+/** A column's size at y: the straight line through its back and front. */
+const along = (c, y) => c.back[1] + ((c.front[1] - c.back[1]) * (y - c.back[0])) / (c.front[0] - c.back[0]);
+/** Three columns for the FloorScaler: one is used for all three, two get one between them. */
+function floorColumns(cols) {
+    if (cols.length === 3)
+        return cols;
+    const [a, b] = [cols[0], cols.at(-1)];
+    if (cols.length === 1)
+        return [a, { ...a, x: a.x + 1 }, { ...a, x: a.x + 2 }];
+    const mid = (y) => Math.round((along(a, y) + along(b, y)) / 2);
+    return [a, { x: Math.round((a.x + b.x) / 2), back: [a.back[0], mid(a.back[0])], front: [a.front[0], mid(a.front[0])] }, b];
+}
+/** A figure's size at x, y among three columns: straight lines in y at each, then in x between them. */
+function floorSize(cols, x, y) {
+    const [a, b, c] = cols.map((col) => along(col, y));
+    const [c1, c2, c3] = cols;
+    if (x <= c1.x)
+        return a;
+    if (x < c2.x)
+        return a + ((b - a) * (x - c1.x)) / (c2.x - c1.x);
+    if (x < c3.x)
+        return b + ((c - b) * (x - c2.x)) / (c3.x - c2.x);
+    return c;
+}
 const num = (n) => (n < 0 ? `-$${(-n).toString(16)}` : String(n));
 function pushVal(v) {
     if (typeof v === "number")
@@ -761,7 +811,7 @@ class RoomCompiler {
         if (hero?.scale)
             egoCalls.push(["setScaler", [{ cls: "Scaler" }, hero.scale.front, hero.scale.back, hero.scale.frontY, hero.scale.backY]]);
         else if (perspective)
-            egoCalls.push(["setScaler", [{ cls: "Scaler" }, ...perspective]]);
+            egoCalls.push(["setScaler", [{ cls: perspective.cls }, ...perspective.args]]);
         else
             egoCalls.push(["setScaler", [0]]);
         c.push(...send({ global: target.globals.ego }, egoCalls));
@@ -772,7 +822,7 @@ class RoomCompiler {
         for (const [name, p] of Object.entries(spec.props ?? {})) {
             c.push(...send({ obj: name }, [
                 ["init", []],
-                ...(perspective && p.moves && p.scale !== false ? [["setScaler", [{ cls: "Scaler" }, ...perspective]]] : []),
+                ...(perspective && p.moves && p.scale !== false ? [["setScaler", [{ cls: perspective.cls }, ...perspective.args]]] : []),
                 ...(p.cycle === "forward" ? [["setCycle", [{ cls: this.target.forwardCycle }]]] : []),
                 // A new instance of the game's Script class, running on the prop.
                 ...(p.script ? [["setScript", [{ code: ["pushi #new", "push0", `class ${p.script}`, "send 4"] }]]] : []),
@@ -837,6 +887,8 @@ class RoomCompiler {
             "&rest 1", `super ${p.class} 12`,
             "pushi #setPri", "push1", "pTos priority", "ldi 1", "add", "push", `lofsa @${key}Mouth`, "send 6",
             "pushi #setPri", "push1", "pTos priority", "ldi 1", "add", "push", `lofsa @${key}Eyes`, "send 6",
+            // Its body in the room, if a prop has its name: where it stands picks the portrait's side.
+            ...(p.who && this.spec.props?.[key] ? send("self", [["who", [{ obj: key }]]]) : []),
             "ret",
         ], "");
     }
@@ -889,34 +941,65 @@ class RoomCompiler {
         if (cases.length)
             this.doVerb(name, "Feature", cases);
     }
+    /** The y range people stand in: the floor, and where the hero and props that move start. */
+    standingYs() {
+        return [
+            ...(this.spec.walkable ?? []).map((p) => p[1]),
+            ...Object.values(this.spec.props ?? {}).filter((p) => p.moves).map((p) => p.at[1]),
+            ...[this.spec.hero?.at, this.spec.hero?.enterTo].flatMap((p) => (p ? [p[1]] : [])),
+        ];
+    }
     /**
-     * The room's perspective as Scaler arguments (front, back, frontY, backY): sizes at the
-     * nearest and farthest places anyone stands (the floor, and where the hero and props that
-     * move start). Size is a straight line in y, so the Scaler's in-between is exact; keeping
-     * to that range keeps its 16-bit arithmetic from overflowing.
+     * The room's perspective as a scaler class and its arguments.
+     *
+     * With a horizon, a Scaler (front, back, frontY, backY): sizes at the nearest and farthest
+     * places anyone stands. Size is a straight line in y, so the Scaler's in-between is exact;
+     * keeping to that range keeps its 16-bit arithmetic from overflowing.
+     *
+     * With measured columns, a FloorScaler with three of them (left, middle, right): one is
+     * used for all three, two get one halfway between them.
      */
     perspective() {
         const pv = this.spec.perspective;
         if (!pv)
             return undefined;
-        const ys = [
-            ...(this.spec.walkable ?? []).map((p) => p[1]),
-            ...Object.values(this.spec.props ?? {}).filter((p) => p.moves).map((p) => p.at[1]),
-            ...[this.spec.hero?.at, this.spec.hero?.enterTo].flatMap((p) => (p ? [p[1]] : [])),
-        ].filter((y) => y > pv.horizon);
+        const fail = (why) => { throw new ContentError(`room ${this.spec.room}: perspective: ${why}`); };
+        if ("columns" in pv) {
+            const cols = floorColumns(pv.columns);
+            const ys = this.standingYs();
+            const [lo, hi] = [Math.min(...ys, ...cols.map((c) => c.back[0])), Math.max(...ys, ...cols.map((c) => c.front[0]))];
+            // FloorScaler works out (front - back) * (y - backY), then (b - a) * (x - x1), in 16 bits.
+            for (const c of cols) {
+                for (const y of [lo, hi]) {
+                    if (Math.abs((c.front[1] - c.back[1]) * (y - c.back[0])) > 32767)
+                        fail(`sizes from ${c.back[1]}% to ${c.front[1]}% at x ${c.x} are too much for the scaler at y ${y}`);
+                    const size = along(c, y);
+                    if (size < 1 || size > 255)
+                        fail(`at x ${c.x} a figure standing at y ${y} would be ${Math.round(size)}%`);
+                }
+            }
+            return { cls: "FloorScaler", args: cols.flatMap((c) => [c.x, c.back[0], c.back[1], c.front[0], c.front[1]]) };
+        }
+        const ys = this.standingYs().filter((y) => y > pv.horizon);
         const backY = ys.length ? Math.min(...ys) : pv.horizon + 1, frontY = ys.length ? Math.max(...ys) : SCREEN_BOTTOM - 1;
         const size = (y) => Math.round(((y - pv.horizon) / (pv.fullSize - pv.horizon)) * 100);
         const [front, back] = [size(frontY), size(backY)];
         // Scaler works out (front - back) * (y - backY) on the way.
         if ((front - back) * (frontY - backY) > 32767)
-            throw new ContentError(`room ${this.spec.room}: perspective: sizes from ${back}% to ${front}% over ${frontY - backY} lines are too much for the Scaler`);
-        return [front, back, Math.max(frontY, backY + 1), backY];
+            fail(`sizes from ${back}% to ${front}% over ${frontY - backY} lines are too much for the Scaler`);
+        return { cls: "Scaler", args: [front, back, Math.max(frontY, backY + 1), backY] };
+    }
+    /** The size, in percent, of a figure standing at x, y. */
+    sizeAt(x, y) {
+        const pv = this.spec.perspective;
+        if ("columns" in pv)
+            return floorSize(floorColumns(pv.columns), x, y);
+        return ((y - pv.horizon) / (pv.fullSize - pv.horizon)) * 100;
     }
     prop(name, p) {
         const cases = this.scriptedVerbs.get(name) ?? [];
         // A still prop is sized once, for where it is.
-        const pv = this.spec.perspective;
-        const fixed = pv && p.scale === true && !p.moves ? Math.round(((p.at[1] - pv.horizon) / (pv.fullSize - pv.horizon)) * 128) : undefined;
+        const fixed = this.spec.perspective && p.scale === true && !p.moves ? Math.round((this.sizeAt(p.at[0], p.at[1]) / 100) * 128) : undefined;
         this.instance(name, p.moves ? "Actor" : "Prop", {
             noun: this.nouns.get(name), modNum: -1, sightAngle: p.sightAngle ?? 180, x: p.at[0], y: p.at[1], view: p.view, loop: p.loop ?? 0, cel: p.cel ?? 0,
             ...(fixed === undefined ? {} : { scaleSignal: 1, scaleX: fixed, scaleY: fixed }),

package/packages/content/src/room.ts

@@ -41,8 +41,12 @@ export interface RoomSpec {
    * size. A figure's height is in proportion to how far below the horizon it stands, so it
    * shrinks towards the back and grows past fullSize at the front. The hero and props that
    * move are sized as they go; a still prop only with scale: true.
+   *
+   * A picture painted at an angle, where a line across the screen isn't one depth all the
+   * way along, gives sizes measured instead: `columns`, up to three places across the floor
+   * (left, middle, right), each with a size at the back and at the front of the floor.
    */
-  perspective?: { horizon: number; fullSize: number };
+  perspective?: { horizon: number; fullSize: number } | { columns: FloorColumn[] };
   /** The floor: a polygon the hero stays inside. */
   walkable?: Point[];
   /** Polygons the hero walks around. */
@@ -67,6 +71,13 @@ interface CharacterSpec {
 }
 
 type Point = [number, number];
+
+/** A place across the floor where sizes were measured: x, and [y, percent] at the back and front. */
+export interface FloorColumn {
+  x: number;
+  back: [number, number];
+  front: [number, number];
+}
 type Rect = [number, number, number, number];
 
 interface FeatureSpec {
@@ -212,10 +223,31 @@ class SpecChecker {
     }
     if (s.perspective !== undefined) {
       const pv = this.map(s.perspective, ["perspective"]);
-      this.known(pv, ["perspective"], ["horizon", "fullSize"]);
-      this.int(pv.horizon, ["perspective", "horizon"], -1000, 199);
-      this.int(pv.fullSize, ["perspective", "fullSize"], 0, 1000);
-      if ((pv.fullSize as number) <= (pv.horizon as number)) this.fail(["perspective", "fullSize"], "must be below the horizon (a bigger y)");
+      if (pv.columns !== undefined) {
+        this.known(pv, ["perspective"], ["columns"]);
+        if (!Array.isArray(pv.columns) || pv.columns.length < 1 || pv.columns.length > 3) this.fail(["perspective", "columns"], "expected one to three places across the floor");
+        let lastX = -Infinity;
+        (pv.columns as unknown[]).forEach((value, i) => {
+          const path = ["perspective", "columns", i];
+          const c = this.map(value, path);
+          this.known(c, path, ["x", "back", "front"]);
+          this.int(c.x, [...path, "x"], 0, 319);
+          if ((c.x as number) <= lastX) this.fail([...path, "x"], "places go left to right");
+          lastX = c.x as number;
+          for (const end of ["back", "front"] as const) {
+            const v = c[end];
+            if (!Array.isArray(v) || v.length !== 2) this.fail([...path, end], "expected [y, size in percent]");
+            this.int((v as unknown[])[0], [...path, end, 0], 0, 199);
+            this.int((v as unknown[])[1], [...path, end, 1], 1, 400);
+          }
+          if ((c.back as number[])[0]! >= (c.front as number[])[0]!) this.fail([...path, "front"], "the front is lower on the screen than the back (a bigger y)");
+        });
+      } else {
+        this.known(pv, ["perspective"], ["horizon", "fullSize", "columns"]);
+        this.int(pv.horizon, ["perspective", "horizon"], -1000, 199);
+        this.int(pv.fullSize, ["perspective", "fullSize"], 0, 1000);
+        if ((pv.fullSize as number) <= (pv.horizon as number)) this.fail(["perspective", "fullSize"], "must be below the horizon (a bigger y)");
+      }
     }
     if (s.walkable !== undefined) this.polygon(s.walkable, ["walkable"]);
     if (s.obstacles !== undefined) {
@@ -313,6 +345,28 @@ type Val = number | { obj: string } | { cls: string } | "self" | { code: string[
 type To = { global: number } | { obj: string } | { cls: string } | "self" | { superOf: string };
 
 const SCREEN_BOTTOM = 200;
+
+/** A column's size at y: the straight line through its back and front. */
+const along = (c: FloorColumn, y: number) => c.back[1] + ((c.front[1] - c.back[1]) * (y - c.back[0])) / (c.front[0] - c.back[0]);
+
+/** Three columns for the FloorScaler: one is used for all three, two get one between them. */
+function floorColumns(cols: FloorColumn[]): [FloorColumn, FloorColumn, FloorColumn] {
+  if (cols.length === 3) return cols as [FloorColumn, FloorColumn, FloorColumn];
+  const [a, b] = [cols[0]!, cols.at(-1)!];
+  if (cols.length === 1) return [a, { ...a, x: a.x + 1 }, { ...a, x: a.x + 2 }];
+  const mid = (y: number) => Math.round((along(a, y) + along(b, y)) / 2);
+  return [a, { x: Math.round((a.x + b.x) / 2), back: [a.back[0], mid(a.back[0])], front: [a.front[0], mid(a.front[0])] }, b];
+}
+
+/** A figure's size at x, y among three columns: straight lines in y at each, then in x between them. */
+function floorSize(cols: [FloorColumn, FloorColumn, FloorColumn], x: number, y: number): number {
+  const [a, b, c] = cols.map((col) => along(col, y)) as [number, number, number];
+  const [c1, c2, c3] = cols;
+  if (x <= c1.x) return a;
+  if (x < c2.x) return a + ((b - a) * (x - c1.x)) / (c2.x - c1.x);
+  if (x < c3.x) return b + ((c - b) * (x - c2.x)) / (c3.x - c2.x);
+  return c;
+}
 const num = (n: number) => (n < 0 ? `-$${(-n).toString(16)}` : String(n));
 
 function pushVal(v: Val): string[] {
@@ -899,7 +953,7 @@ class RoomCompiler {
     // Each room sizes the hero its own way, or not at all.
     const perspective = this.perspective();
     if (hero?.scale) egoCalls.push(["setScaler", [{ cls: "Scaler" }, hero.scale.front, hero.scale.back, hero.scale.frontY, hero.scale.backY]]);
-    else if (perspective) egoCalls.push(["setScaler", [{ cls: "Scaler" }, ...perspective]]);
+    else if (perspective) egoCalls.push(["setScaler", [{ cls: perspective.cls }, ...perspective.args]]);
     else egoCalls.push(["setScaler", [0]]);
     c.push(...send({ global: target.globals.ego }, egoCalls));
     if (spec.music !== undefined) c.push(...this.playMusic(spec.music));
@@ -907,7 +961,7 @@ class RoomCompiler {
     for (const [name, p] of Object.entries(spec.props ?? {})) {
       c.push(...send({ obj: name }, [
         ["init", []],
-        ...(perspective && p.moves && p.scale !== false ? [["setScaler", [{ cls: "Scaler" }, ...perspective]] as [string, Val[]]] : []),
+        ...(perspective && p.moves && p.scale !== false ? [["setScaler", [{ cls: perspective.cls }, ...perspective.args]] as [string, Val[]]] : []),
         ...(p.cycle === "forward" ? [["setCycle", [{ cls: this.target.forwardCycle }]] as [string, Val[]]] : []),
         // A new instance of the game's Script class, running on the prop.
         ...(p.script ? [["setScript", [{ code: ["pushi #new", "push0", `class ${p.script}`, "send 4"] }]] as [string, Val[]]] : []),
@@ -975,6 +1029,8 @@ class RoomCompiler {
         "&rest 1", `super ${p.class} 12`,
         "pushi #setPri", "push1", "pTos priority", "ldi 1", "add", "push", `lofsa @${key}Mouth`, "send 6",
         "pushi #setPri", "push1", "pTos priority", "ldi 1", "add", "push", `lofsa @${key}Eyes`, "send 6",
+        // Its body in the room, if a prop has its name: where it stands picks the portrait's side.
+        ...(p.who && this.spec.props?.[key] ? send("self", [["who", [{ obj: key }]]]) : []),
         "ret",
       ],
       "",
@@ -1039,33 +1095,63 @@ class RoomCompiler {
     if (cases.length) this.doVerb(name, "Feature", cases);
   }
 
+  /** The y range people stand in: the floor, and where the hero and props that move start. */
+  private standingYs(): number[] {
+    return [
+      ...(this.spec.walkable ?? []).map((p) => p[1]),
+      ...Object.values(this.spec.props ?? {}).filter((p) => p.moves).map((p) => p.at[1]),
+      ...[this.spec.hero?.at, this.spec.hero?.enterTo].flatMap((p) => (p ? [p[1]] : [])),
+    ];
+  }
+
   /**
-   * The room's perspective as Scaler arguments (front, back, frontY, backY): sizes at the
-   * nearest and farthest places anyone stands (the floor, and where the hero and props that
-   * move start). Size is a straight line in y, so the Scaler's in-between is exact; keeping
-   * to that range keeps its 16-bit arithmetic from overflowing.
+   * The room's perspective as a scaler class and its arguments.
+   *
+   * With a horizon, a Scaler (front, back, frontY, backY): sizes at the nearest and farthest
+   * places anyone stands. Size is a straight line in y, so the Scaler's in-between is exact;
+   * keeping to that range keeps its 16-bit arithmetic from overflowing.
+   *
+   * With measured columns, a FloorScaler with three of them (left, middle, right): one is
+   * used for all three, two get one halfway between them.
    */
-  private perspective(): [number, number, number, number] | undefined {
+  private perspective(): { cls: string; args: number[] } | undefined {
     const pv = this.spec.perspective;
     if (!pv) return undefined;
-    const ys = [
-      ...(this.spec.walkable ?? []).map((p) => p[1]),
-      ...Object.values(this.spec.props ?? {}).filter((p) => p.moves).map((p) => p.at[1]),
-      ...[this.spec.hero?.at, this.spec.hero?.enterTo].flatMap((p) => (p ? [p[1]] : [])),
-    ].filter((y) => y > pv.horizon);
+    const fail = (why: string): never => { throw new ContentError(`room ${this.spec.room}: perspective: ${why}`); };
+    if ("columns" in pv) {
+      const cols = floorColumns(pv.columns);
+      const ys = this.standingYs();
+      const [lo, hi] = [Math.min(...ys, ...cols.map((c) => c.back[0])), Math.max(...ys, ...cols.map((c) => c.front[0]))];
+      // FloorScaler works out (front - back) * (y - backY), then (b - a) * (x - x1), in 16 bits.
+      for (const c of cols) {
+        for (const y of [lo, hi]) {
+          if (Math.abs((c.front[1] - c.back[1]) * (y - c.back[0])) > 32767) fail(`sizes from ${c.back[1]}% to ${c.front[1]}% at x ${c.x} are too much for the scaler at y ${y}`);
+          const size = along(c, y);
+          if (size < 1 || size > 255) fail(`at x ${c.x} a figure standing at y ${y} would be ${Math.round(size)}%`);
+        }
+      }
+      return { cls: "FloorScaler", args: cols.flatMap((c) => [c.x, c.back[0], c.back[1], c.front[0], c.front[1]]) };
+    }
+    const ys = this.standingYs().filter((y) => y > pv.horizon);
     const backY = ys.length ? Math.min(...ys) : pv.horizon + 1, frontY = ys.length ? Math.max(...ys) : SCREEN_BOTTOM - 1;
     const size = (y: number) => Math.round(((y - pv.horizon) / (pv.fullSize - pv.horizon)) * 100);
     const [front, back] = [size(frontY), size(backY)];
     // Scaler works out (front - back) * (y - backY) on the way.
-    if ((front - back) * (frontY - backY) > 32767) throw new ContentError(`room ${this.spec.room}: perspective: sizes from ${back}% to ${front}% over ${frontY - backY} lines are too much for the Scaler`);
-    return [front, back, Math.max(frontY, backY + 1), backY];
+    if ((front - back) * (frontY - backY) > 32767) fail(`sizes from ${back}% to ${front}% over ${frontY - backY} lines are too much for the Scaler`);
+    return { cls: "Scaler", args: [front, back, Math.max(frontY, backY + 1), backY] };
+  }
+
+  /** The size, in percent, of a figure standing at x, y. */
+  private sizeAt(x: number, y: number): number {
+    const pv = this.spec.perspective!;
+    if ("columns" in pv) return floorSize(floorColumns(pv.columns), x, y);
+    return ((y - pv.horizon) / (pv.fullSize - pv.horizon)) * 100;
   }
 
   private prop(name: string, p: PropSpec): void {
     const cases = this.scriptedVerbs.get(name) ?? [];
     // A still prop is sized once, for where it is.
-    const pv = this.spec.perspective;
-    const fixed = pv && p.scale === true && !p.moves ? Math.round(((p.at[1] - pv.horizon) / (pv.fullSize - pv.horizon)) * 128) : undefined;
+    const fixed = this.spec.perspective && p.scale === true && !p.moves ? Math.round((this.sizeAt(p.at[0], p.at[1]) / 100) * 128) : undefined;
     this.instance(
       name, p.moves ? "Actor" : "Prop",
       {

package/packages/content/src/target.d.ts

@@ -40,7 +40,8 @@ export interface Target {
     /**
      * A character with a portrait view: loop 0 the bust, loop 1 mouth shapes, loop 2 eyes
      * (cel 0 open), all cels the same size so the parts line up. The talker class gets
-     * `init: mouth bust eyes frame`; parts are a View (bust) and Props at `at`.
+     * `init: mouth bust eyes frame`; parts are a View (bust) and Props at `at`. With `who`,
+     * the talker is also told the character's prop in the room, if it has one (`who:`).
      */
     portrait: {
         class: string;
@@ -48,6 +49,7 @@ export interface Target {
         at: [number, number];
         frameSignal: number;
         partSignal: number;
+        who?: boolean;
     };
     /**
      * Conversations: an instance of this class runs a menu of topics for a thing (e.g. a

package/packages/content/src/target.ts

@@ -37,9 +37,10 @@ export interface Target {
   /**
    * A character with a portrait view: loop 0 the bust, loop 1 mouth shapes, loop 2 eyes
    * (cel 0 open), all cels the same size so the parts line up. The talker class gets
-   * `init: mouth bust eyes frame`; parts are a View (bust) and Props at `at`.
+   * `init: mouth bust eyes frame`; parts are a View (bust) and Props at `at`. With `who`,
+   * the talker is also told the character's prop in the room, if it has one (`who:`).
    */
-  portrait: { class: string; props: Record<string, number>; at: [number, number]; frameSignal: number; partSignal: number };
+  portrait: { class: string; props: Record<string, number>; at: [number, number]; frameSignal: number; partSignal: number; who?: boolean };
   /**
    * Conversations: an instance of this class runs a menu of topics for a thing (e.g. a
    * Teller with `init: client modNum sayNoun verb rootNoun`; topic labels are messages at

package/tools/game/target.js

@@ -31,8 +31,8 @@ export function libraryTarget(globals, items = {}) {
         heroTalker: 98,
         firstRoomTalker: 200,
         voice: { class: "Talker", props: {} },
-        // Portraits stand at the top left, the text beside them.
-        portrait: { class: "PortraitTalker", props: {}, at: [8, 8], frameSignal: 0, partSignal: 0 },
+        // Portraits stand at the top, left or right by where the character is (who:).
+        portrait: { class: "PortraitTalker", props: {}, at: [8, 8], frameSignal: 0, partSignal: 0, who: true },
         teller: { class: "Teller", props: {}, verb: 2 },
         forwardCycle: "Forward",
         closeUp: "CloseUp",

package/tools/game/target.ts

@@ -33,8 +33,8 @@ export function libraryTarget(globals: readonly string[], items: Record<string,
     heroTalker: 98,
     firstRoomTalker: 200,
     voice: { class: "Talker", props: {} },
-    // Portraits stand at the top left, the text beside them.
-    portrait: { class: "PortraitTalker", props: {}, at: [8, 8], frameSignal: 0, partSignal: 0 },
+    // Portraits stand at the top, left or right by where the character is (who:).
+    portrait: { class: "PortraitTalker", props: {}, at: [8, 8], frameSignal: 0, partSignal: 0, who: true },
     teller: { class: "Teller", props: {}, verb: 2 },
     forwardCycle: "Forward",
     closeUp: "CloseUp",