sci2-ts 0.12.0 → 0.14.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.14.0](https://github.com/rlueder/sci-ts/compare/v0.13.0...v0.14.0) (2026-10-02)
+
+### Added
+
+* **lib:** figures drawn smaller walk and step slower, and change size in steps ([#16](https://github.com/rlueder/sci-ts/issues/16)) ([06f2b1d](https://github.com/rlueder/sci-ts/commit/06f2b1d91fd95d5b648104b435eb58e3355ba808))
+
+## [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

package/lib/997.sc

@@ -6,6 +6,8 @@
 ;; Walks its client in a straight line to (x, y), a step (xStep, yStep) every
 ;; moveSpeed cycles. The interpreter does the stepping (InitBresen, DoBresen) and sends
 ;; moveDone on arrival; the client then calls motionCue:, which cues the caller.
+;; A client drawn smaller than full size (farther off) steps less often, in proportion,
+;; so it doesn't slide across the floor.
 (class Motion of Obj
   (properties
     client 0
@@ -13,6 +15,7 @@
     x 0 y 0
     dx 0 dy 0
     b-moveCnt 0 b-i1 0 b-i2 0 b-di 0 b-xAxis 0 b-incr 0
+    progress 0      ; towards the next step, in 128ths of a cycle at full size
     completed 0)
 
   (method (init who toX toY whoCares)
@@ -25,12 +28,21 @@
     (= x toX)
     (= y toY)
     (= b-moveCnt gameTime)
+    (= progress 0)
     (client setHeading: (GetAngle (client x?) (client y?) x y))
     (InitBresen self))
 
-  (method (doit)
-    (if (>= (- gameTime b-moveCnt) (client moveSpeed?))
-      (= b-moveCnt gameTime)
+  ;; Each cycle counts for the client's size (128 at full size); a step takes moveSpeed
+  ;; cycles' worth.
+  (method (doit &tmp t e)
+    (= t (* (client moveSpeed?) 128))
+    ;; (After a long pause, at most 16 cycles count, so the sum stays in 16 bits.)
+    (if (> (= e (- gameTime b-moveCnt)) 16) (= e 16))
+    (+= progress (* e (if (& (client scaleSignal?) SCALE_ON) (client scaleX?) else 128)))
+    (= b-moveCnt gameTime)
+    (if (> progress t) (= progress t))
+    (if (>= progress t)
+      (-= progress t)
       (DoBresen self)))
 
   (method (moveDone)
@@ -139,8 +151,22 @@
     (if (> c (self lastCel:)) (= c 0))
     (client cel: c)))
 
-;; Round and round while the client moves; cel 0 when it stands.
+;; Round and round while the client moves; cel 0 when it stands. Its legs keep pace with
+;; its steps: drawn smaller, it turns its cels less often, in proportion.
 (class Walk of Forward
+  (properties
+    progress 0)
+
+  (method (nextCel &tmp t e)
+    (= t (* (client cycleSpeed?) 128))
+    (if (> (= e (- gameTime cycleCnt)) 16) (= e 16))
+    (+= progress (* e (if (& (client scaleSignal?) SCALE_ON) (client scaleX?) else 128)))
+    (= cycleCnt gameTime)
+    (if (> progress t) (= progress t))
+    (if (< progress t) (return (client cel?)))
+    (-= progress t)
+    (return (+ (client cel?) cycleDir)))
+
   (method (doit)
     (if (client mover?)
       (super doit:)
@@ -198,12 +224,15 @@
         (client cel: c)))))
 
 ;; Sizes its client by how far up the screen it stands: frontSize percent at frontY,
-;; backSize at backY, in between in proportion.
+;; backSize at backY, in between in proportion. The size changes in steps of at least `step`
+;; percent: a figure redrawn at a new size for every line it moves shimmers.
 (class Scaler of Obj
   (properties
     client 0
     frontSize 100 backSize 100
-    frontY 190 backY 0)
+    frontY 190 backY 0
+    step 2
+    shown -1)       ; the size the client is drawn at
 
   (method (init who fs bs fy by)
     (= client who)
@@ -220,7 +249,52 @@
         ((>= y frontY) frontSize)
         ((<= y backY) backSize)
         (else (+ backSize (/ (* (- frontSize backSize) (- y backY)) (- frontY backY))))))
-    (client
-      scaleX: (/ (* pct 128) 100)
-      scaleY: (/ (* pct 128) 100)
-      scaleSignal: (| (client scaleSignal?) SCALE_ON))))
+    (self show: pct))
+
+  ;; Draws the client at pct percent, if that's a step away from its size now.
+  (method (show pct &tmp d)
+    (= d (- pct shown))
+    (if (< d 0) (= d (- d)))
+    (if (or (== shown -1) (>= d step))
+      (= shown pct)
+      (client
+        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))
+    (self show: pct)))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sci2-ts",
-  "version": "0.12.0",
+  "version": "0.14.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"] }]]] : []),
@@ -891,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[]]] : []),
@@ -1041,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",
       {