sci2-ts 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,8 +1,29 @@
 # Changelog
 
-All notable changes to this project. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
-versions follow [Semantic Versioning](https://semver.org/), and the entries are generated
-from commit messages ([Conventional Commits](https://www.conventionalcommits.org/)).
+All notable changes to this project. Versions follow [Semantic Versioning](https://semver.org/),
+and the entries are generated from commit messages
+([Conventional Commits](https://www.conventionalcommits.org/)) when a release is made.
+
+## [0.3.0](https://github.com/rlueder/sci-ts/compare/v0.2.2...v0.3.0) (2026-10-01)
+
+### Added
+
+* **content:** close-ups from Yarn ([0546752](https://github.com/rlueder/sci-ts/commit/054675216342747bc5565301aff3d39d27a900c2))
+* **lib:** a text style for every box and menu ([0350a4e](https://github.com/rlueder/sci-ts/commit/0350a4e28a57d951277372ff6144bd8e9e534bee))
+* **lib:** an inventory and close-ups ([6d401d8](https://github.com/rlueder/sci-ts/commit/6d401d8f92d33a4b694dcc617adbb1d5878da246))
+* **lib:** cursors a game can replace, and a wait cursor ([aa55d11](https://github.com/rlueder/sci-ts/commit/aa55d1142568aeb4b14681e44881a4223192d5d2))
+* **lib:** portraits at the top left, with blinking eyes ([8fd6aa1](https://github.com/rlueder/sci-ts/commit/8fd6aa16e83f9608666f67fd998ac852be1a5a99))
+* **tools:** fonts from sheets of glyphs drawn in a paint program ([cb13669](https://github.com/rlueder/sci-ts/commit/cb13669363fb419425b0a54f0a5afb9ca1576dcf))
+
+### Maintenance
+
+* release from CI with semantic-release ([1757412](https://github.com/rlueder/sci-ts/commit/17574126c257961dd1058f596c6174445f3d9f16))
+
+## [0.2.2] - 2026-10-01
+
+### Fixed
+
+- **tools:** Republish as 0.2.2: 0.2.1 is stuck in npm's staging
 
 ## [0.2.1] - 2026-10-01
 
@@ -68,5 +89,3 @@ from commit messages ([Conventional Commits](https://www.conventionalcommits.org
 
 - Workspace, typecheck, tests and CI
 - Build every game, and publish the site to GitHub Pages by hand
-
-

package/lib/993.sc

@@ -0,0 +1,129 @@
+;;; Things: what the hero carries and the window to choose one from, and close looks at
+;;; things.
+(script 993)
+(include "system.sh")
+
+;; Something the hero can carry. Its view's loop 0 is its icon in the inventory window and
+;; loop 1 the cursor while it's being used (the cel's anchor is the hotspot); both anchored
+;; at the top-left corner. Using it on something sends that thing doVerb: with the item's
+;; own verb, 10 and up, so the room answers with noun and that verb (in Yarn, a node like
+;; filings.lens: the game names its items' verbs in items.yaml).
+(class InvItem of Obj
+  (properties
+    view -1
+    verb 0
+    description 0)  ; what looking at it in the window says
+
+  ;; Looked at in the inventory window.
+  (method (doVerb v)
+    (if (and (== v V_LOOK) description) (narrator say: description))))
+
+;; What the hero carries (the `inventory` global): (inventory add: lens), (inventory
+;; contains: lens). showSelf opens the window: the items in a row, one click picks one to
+;; use (it becomes the cursor), a right-click on one looks at it, a click elsewhere closes.
+(class Inventory of Set
+  (properties
+    window 0
+    icons 0
+    y 24)
+
+  (method (showSelf &tmp node item icon x)
+    (if (not size)
+      (narrator say: "You aren't carrying anything.")
+      (return))
+    (= window
+      ((TextItem new:)
+        text: ""
+        width: (+ (* size (+ INV_ICON INV_GAP)) INV_GAP (* 2 (textStyle margin?)))
+        height: (+ INV_ICON (* 2 INV_GAP) (* 2 (textStyle margin?)))
+        yourself:))
+    (if (!= (textStyle frame?) -1)
+      (window
+        width: (+ (window width?) (CelWide (textStyle frame?) 0 6) (CelWide (textStyle frame?) 0 7))
+        height: (+ (window height?) (CelHigh (textStyle frame?) 0 4) (CelHigh (textStyle frame?) 0 5))))
+    (window x: (/ (- SCREEN_WIDTH (window width?)) 2) y: y init:)
+    (= icons (List new:))
+    (= x (+ (window x?) (window textLeft?) INV_GAP))
+    (for ((= node (FirstNode elements))) node ((= node (NextNode node)))
+      (= item (NodeValue node))
+      ;; The icon keeps its item in `actions`.
+      (= icon ((View new:) view: (item view?) loop: 0 cel: 0 actions: item x: x y: (+ (window y?) (window textTop?) INV_GAP) yourself:))
+      (icon init:)
+      (icon plane: uiPlane setPri: (+ (window priority?) 1))
+      (icons add: icon)
+      (+= x (+ INV_ICON INV_GAP)))
+    (= dialog self))
+
+  ;; The item whose icon is at (x, y), or 0.
+  (method (itemAt ex ey &tmp icon)
+    (= icon (icons firstTrue: #onMe ex ey))
+    (return (if icon (icon actions?) else 0)))
+
+  (method (handleEvent event &tmp item)
+    (event claimed: TRUE)
+    (if (!= (event type?) EV_MOUSE_DOWN) (return TRUE))
+    (= item (self itemAt: (event x?) (event y?)))
+    (cond
+      ((not item) (self hide:))
+      ((& (event modifiers?) MOD_RIGHT) (item doVerb: V_LOOK))
+      (else
+        (self hide:)
+        (user useItem: item)))
+    (return TRUE))
+
+  (method (hide)
+    (if (== dialog self) (= dialog 0))
+    (if icons
+      (icons eachElementDo: #dispose)
+      (icons dispose:)
+      (= icons 0))
+    (if window (window dispose:) (= window 0)))
+
+  (method (delete item)
+    (if (== theItem item) (user useItem: 0))
+    (super delete: item &rest)))
+
+;; A close look at something: a view shown in the middle of the screen with the room dimmed
+;; behind it, until a click; then it goes, and whoever asked is cued.
+;;   ((CloseUp new:) show: view [loop [cel [whoCares]]])
+;; Its cels are anchored at their top-left corner. The dimming is the library's view 996,
+;; drawn in remap colour 253 (which the art palette keeps free) at `dim` percent.
+(class CloseUp of Obj
+  (properties
+    shade 0
+    picture 0
+    caller 0
+    dim 50)
+
+  (method (show v l c whoCares &tmp lp cl)
+    (= lp (if (> argc 1) l else 0))
+    (= cl (if (> argc 2) c else 0))
+    (= caller (if (> argc 3) whoCares else 0))
+    (RemapColors REMAP_BY_PERCENT 253 dim)
+    (= shade ((View new:) view: CLOSE_UP_SHADE x: 0 y: 0 yourself:))
+    (shade init:)
+    (shade plane: uiPlane setPri: 10)
+    (= picture
+      ((View new:)
+        view: v loop: lp cel: cl
+        x: (/ (- SCREEN_WIDTH (CelWide v lp cl)) 2)
+        y: (/ (- SCREEN_HEIGHT (CelHigh v lp cl)) 2)
+        yourself:))
+    (picture init:)
+    (picture plane: uiPlane setPri: 20)
+    (= dialog self))
+
+  (method (handleEvent event)
+    (event claimed: TRUE)
+    (if (== (event type?) EV_MOUSE_DOWN)
+      (self close:))
+    (return TRUE))
+
+  (method (close &tmp c)
+    (if (== dialog self) (= dialog 0))
+    (if picture (picture dispose:) (= picture 0))
+    (if shade (shade dispose:) (= shade 0))
+    (RemapColors REMAP_OFF 253)
+    (= c caller)
+    (self dispose:)
+    (if c (c cue:))))

package/lib/995.sc

@@ -15,22 +15,69 @@
 ;; a click walks the hero there, or does the verb to what's under the cursor: an actor or
 ;; prop, a feature, or else the room. A click while a line is shown dismisses it; while a
 ;; menu is open, it goes to the menu.
+;;
+;; The cursor is a view for each verb, and another while the player can't act (handsOff).
+;; A game with its own sets them in its init: (user walkCursor: 261 waitCursor: 265 ...).
+;; I or Tab opens the inventory; an item picked there is used like a verb (V_ITEM), with
+;; its own cursor, until right-click goes back to walking.
 (class User of Obj
   (properties
     verb V_WALK
-    canInput TRUE)
+    canInput TRUE
+    lookCursor 991  ; the library's: CURSOR_BASE + verb
+    talkCursor 992
+    walkCursor 993
+    doCursor 994
+    waitCursor 995  ; CURSOR_WAIT
+    cursor -1       ; the view and loop showing now
+    cursorLoop 0)
 
   (method (init)
     (self setVerb: verb))
 
   (method (setVerb v)
     (= verb v)
-    (SetCursor (+ CURSOR_BASE v) 0 0))
+    (self showCursor:))
+
+  ;; Picks an item to use (0: none).
+  (method (useItem item)
+    (= theItem item)
+    (cond
+      (item (self setVerb: V_ITEM))
+      ((== verb V_ITEM) (self setVerb: V_WALK))))
+
+  ;; The cursor for a verb (0: waiting).
+  (method (cursorFor v)
+    (switch v
+      (V_LOOK (return lookCursor))
+      (V_TALK (return talkCursor))
+      (V_WALK (return walkCursor))
+      (V_DO (return doCursor))
+      (else (return waitCursor))))
+
+  (method (showCursor &tmp v l)
+    (= l 0)
+    (cond
+      ((not canInput) (= v waitCursor))
+      ((and (== verb V_ITEM) theItem) (= v (theItem view?)) (= l 1))
+      (else (= v (self cursorFor: verb))))
+    (if (or (!= v cursor) (!= l cursorLoop))
+      (= cursor v)
+      (= cursorLoop l)
+      (SetCursor v l 0)))
 
   (method (doit)
+    (self showCursor:)
     (while (GetEvent EV_ALL theEvent)
       (self handleEvent: theEvent)))
 
+  ;; The verb right-click goes to: walk, do, look, talk, the item picked (if any), walk.
+  (method (nextVerb)
+    (cond
+      ((== verb V_ITEM) (return V_WALK))
+      ((and (== verb V_TALK) theItem) (return V_ITEM))
+      (else (return (+ (mod verb VERB_COUNT) 1)))))
+
   (method (handleEvent event &tmp obj ex ey)
     (event claimed: FALSE)
     ;; A line being shown, then an open menu, get clicks first.
@@ -38,9 +85,15 @@
     (if dialog
       (dialog handleEvent: event)
       (return))
-    (if (or (not canInput) (!= (event type?) EV_MOUSE_DOWN)) (return))
+    (if (not canInput) (return))
+    (if (and (== (event type?) EV_KEY_DOWN)
+          (or (== (event message?) KEY_TAB) (== (event message?) KEY_i) (== (event message?) KEY_I)))
+      (event claimed: TRUE)
+      (inventory showSelf:)
+      (return))
+    (if (!= (event type?) EV_MOUSE_DOWN) (return))
     (if (& (event modifiers?) MOD_RIGHT)
-      (self setVerb: (+ (mod verb VERB_COUNT) 1))
+      (self setVerb: (self nextVerb:))
       (return))
     (= ex (event x?))
     (= ey (event y?))
@@ -50,4 +103,4 @@
     (= obj (cast firstTrue: #onMe ex ey))
     (if (not obj) (= obj (features firstTrue: #onMe ex ey)))
     (if (not obj) (= obj curRoom))
-    (if obj (obj doVerb: verb))))
+    (if obj (obj doVerb: (if (== verb V_ITEM) (theItem verb?) else verb)))))

package/lib/996.sc

@@ -3,8 +3,25 @@
 (script 996)
 (include "system.sh")
 
+;; How text boxes and menus look, for the whole game (the `textStyle` global): the font, the
+;; ink, paper and border colours, and a frame drawn around each box instead of the border.
+;; The game sets it in its init, after (super init:):
+;;   (textStyle font: 1 fore: 3 back: 12 frame: 260)
+;; A frame is a view whose loop 0 has eight cels, each anchored at its top-left corner: the
+;; corners (top-left, top-right, bottom-left, bottom-right), then the edges (top, bottom, left,
+;; right). The edges are tiled between the corners; transparent pixels show the paper.
+(class TextStyle of Obj
+  (properties
+    font 0
+    fore 0          ; ink
+    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
+
 ;; 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 font, colours, width, x, y), then init.
+;; item in the UI plane. Set text (and width, x, y), then init; it's as tall as the text
+;; unless height is set. Font, colours and frame come from the textStyle unless set here.
 (class TextItem of Obj
   (properties
     x 0 y 0 z 0
@@ -14,36 +31,66 @@
     bitmap 0
     scaleSignal 0 scaleX 128 scaleY 128
     text 0
-    font 0
-    fore 0
-    back 255
+    font -1         ; -1 here and below: the textStyle's
+    fore -1
+    back -1
     skip 254
     mode 0          ; 0 left, 1 centred
-    borderColor 0
+    borderColor -2  ; -1: none
+    frame -2        ; -1: none
     textLeft 0 textTop 0 textRight -1 textBottom -1
     width 200
     height 0)
 
-  (method (init &tmp r)
-    ;; As tall as the text needs, with a 4-pixel margin inside the border.
-    (= r (Array ARRAY_NEW 4 0))
-    (TextSize r text font (- width 8))
-    (= height (+ (Array ARRAY_AT r 3) 9))
-    (Array ARRAY_FREE r)
-    (= textLeft 4)
-    (= textTop 4)
-    (= textRight (- width 5))
-    (= textBottom (- height 5))
+  (method (init &tmp r m padL padT padR padB)
+    (if (== font -1) (= font (textStyle font?)))
+    (if (== fore -1) (= fore (textStyle fore?)))
+    (if (== back -1) (= back (textStyle back?)))
+    (if (== frame -2) (= frame (textStyle frame?)))
+    (if (== borderColor -2) (= borderColor (if (!= frame -1) -1 else (textStyle border?))))
+    ;; As tall as the text needs, inside the margin and the frame.
+    (= m (textStyle margin?))
+    (= padL m) (= padT m) (= padR m) (= padB m)
+    (if (!= frame -1)
+      (+= padL (CelWide frame 0 6))
+      (+= padR (CelWide frame 0 7))
+      (+= padT (CelHigh frame 0 4))
+      (+= padB (CelHigh frame 0 5)))
+    (if (not height)
+      (= r (Array ARRAY_NEW 4 0))
+      (TextSize r text font (- width (+ padL padR)))
+      (= height (+ (Array ARRAY_AT r 3) 1 padT padB))
+      (Array ARRAY_FREE r))
+    (= textLeft padL)
+    (= textTop padT)
+    (= textRight (- width (+ padR 1)))
+    (= textBottom (- height (+ padB 1)))
     (= plane uiPlane)
     (= bitmap (CreateTextBitmap 0 width height self))
+    (if (!= frame -1) (self drawFrame:))
     (AddScreenItem self))
 
+  ;; The edges, tiled, then the corners over their ends.
+  (method (drawFrame &tmp i step)
+    (if (< (= step (CelWide frame 0 4)) 1) (= step 1))
+    (for ((= i (CelWide frame 0 0))) (< i width) ((+= i step))
+      (Bitmap BITMAP_DRAW_VIEW bitmap frame 0 4 i 0)
+      (Bitmap BITMAP_DRAW_VIEW bitmap frame 0 5 i (- height (CelHigh frame 0 5))))
+    (if (< (= step (CelHigh frame 0 6)) 1) (= step 1))
+    (for ((= i (CelHigh frame 0 0))) (< i height) ((+= i step))
+      (Bitmap BITMAP_DRAW_VIEW bitmap frame 0 6 0 i)
+      (Bitmap BITMAP_DRAW_VIEW bitmap frame 0 7 (- width (CelWide frame 0 7)) i))
+    (Bitmap BITMAP_DRAW_VIEW bitmap frame 0 0 0 0)
+    (Bitmap BITMAP_DRAW_VIEW bitmap frame 0 1 (- width (CelWide frame 0 1)) 0)
+    (Bitmap BITMAP_DRAW_VIEW bitmap frame 0 2 0 (- height (CelHigh frame 0 2)))
+    (Bitmap BITMAP_DRAW_VIEW bitmap frame 0 3 (- width (CelWide frame 0 3)) (- height (CelHigh frame 0 3))))
+
   (method (onMe theX theY)
     (return (and (>= theX x) (< theX (+ x width)) (>= theY y) (< theY (+ y height)))))
 
   (method (dispose)
     (DeleteScreenItem self)
-    (if bitmap (Bitmap 1 bitmap) (= bitmap 0))
+    (if bitmap (Bitmap BITMAP_DISPOSE bitmap) (= bitmap 0))
     (super dispose:)))
 
 ;; Shows a line until it's been there long enough to read, or the player clicks; then
@@ -53,7 +100,7 @@
     caller 0
     box 0
     until 0         ; the game time it goes
-    font 0
+    font -1         ; -1: the textStyle's
     x -1            ; -1: centred
     y 16
     width 220)
@@ -106,14 +153,16 @@
     (= line (String 11 "%s: %s" name txt))
     (super say: line &rest whoCares)))
 
-;; Someone with a portrait: a view whose loop 0 is the bust, loop 1 the mouth (moving while
-;; they talk) and loop 2 the eyes, every cel the same size and placed at one point (the
-;; bottom middle). The room's talker hands its parts to init: mouth bust eyes frame, where
-;; frame is drawn first (the bust). The text goes beside the portrait.
+;; 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.
 (class PortraitTalker of Talker
   (properties
     mouth 0 bust 0 eyes 0 frame 0
-    priority 150)
+    priority 150
+    mouthUntil 0)   ; the game time the mouth stops
 
   (method (init theMouth theBust theEyes theFrame)
     (= mouth theMouth)
@@ -125,15 +174,24 @@
     (self init:)
     (= portrait (if frame frame else bust))
     (if portrait
-      (= x (+ (portrait x?) (/ (CelWide (portrait view?) 0 0) 2) 6))
-      (= y (+ (- (portrait y?) (CelHigh (portrait view?) 0 0)) 1))
-      (= width (- (- SCREEN_WIDTH x) 8)))
+      (= x (+ (portrait x?) (CelWide (portrait view?) (portrait loop?) (portrait cel?)) 6))
+      (= y (portrait y?))
+      (= 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: mouth (+ priority 1))
-    (if mouth (mouth setCycle: Forward)))
+    (if eyes (eyes setCycle: Blink))
+    (if mouth
+      (mouth setCycle: Forward)
+      ;; About as long as it takes to say: half a second, and two cycles a letter.
+      (= mouthUntil (+ gameTime 30 (* 2 (String STRING_LENGTH txt))))))
+
+  (method (doit)
+    (if (and mouth (mouth cycler?) (>= gameTime mouthUntil))
+      (mouth setCycle: 0 setCel: 0))
+    (super doit:))
 
   (method (showPart part pri)
     (if part

package/lib/997.sc

@@ -169,6 +169,32 @@
      else
       (client cel: c))))
 
+;; Eyes: cel 0 (open) most of the time; every two or three seconds, the other cels in turn
+;; (shut) and back to 0.
+(class Blink of Cycle
+  (properties
+    nextBlink 0)
+
+  (method (init who)
+    (super init: who)
+    (self rest:))
+
+  (method (rest)
+    (= nextBlink (+ gameTime 90 (Random 0 90))))
+
+  (method (doit &tmp c)
+    (if (== (client cel?) 0)
+      (if (and (>= gameTime nextBlink) (> (self lastCel:) 0))
+        (= cycleCnt gameTime)
+        (client cel: 1))
+     else
+      (= c (self nextCel:))
+      (if (> c (self lastCel:))
+        (client cel: 0)
+        (self rest:)
+       else
+        (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.
 (class Scaler of Obj

package/lib/998.sc

@@ -30,6 +30,8 @@
     (= theEvent (Event new:))
     (= messager (Messager new:))
     (= narrator (Narrator new:))
+    (= textStyle (TextStyle new:))
+    (= inventory (Inventory new:))
     (= music (Sound new:))
     (= sfx (Sound new:))
     (= uiPlane ((Plane new:) priority: 200 picture: -2 yourself:))
@@ -77,10 +79,10 @@
 
   ;; Clicks do nothing (but dismiss text) until handsOn: for cutscenes.
   (method (handsOff)
-    (user canInput: FALSE))
+    (user canInput: FALSE showCursor:))
 
   (method (handsOn)
-    (user canInput: TRUE)))
+    (user canInput: TRUE showCursor:)))
 
 ;; A room: its picture, where you can walk, its exits, and what's said about it.
 (class Room of Obj

package/lib/999.sc

@@ -27,7 +27,10 @@
   uiPlane       ; the plane over the room, for text
   gameTime      ; cycles since the game started
   quit          ; set to end the game
-  [gameFlags 64]) ; story flags, a bit each
+  [gameFlags 64]  ; story flags, a bit each
+  textStyle       ; how text boxes and menus look (a TextStyle)
+  inventory       ; what the hero carries (an Inventory)
+  theItem)        ; the item picked to use, or 0
 
 (procedure (SetFlag n)
   (|= [gameFlags (/ n 16)] (<< 1 (mod n 16))))

package/lib/resources.js

@@ -1,9 +1,10 @@
 import { Colour, ResourceType, writeView } from "../tools/game/kit.js";
 /**
- * The class library's own resources: a cursor for each verb, view CURSOR_BASE + verb
- * (system.sh). X is black, W white, . transparent.
+ * The class library's own resources: a cursor for each verb, view CURSOR_BASE + verb, and
+ * one while the player waits, CURSOR_WAIT (system.sh). X is black, W white, . transparent.
  */
 const CURSOR_BASE = 990;
+const CURSOR_WAIT = 995;
 const CURSORS = {
     // V_LOOK: an eye.
     1: {
@@ -70,6 +71,22 @@ const CURSORS = {
             "...XXXXXX..",
         ],
     },
+    // Waiting: an hourglass.
+    [CURSOR_WAIT - CURSOR_BASE]: {
+        hotspot: "centre",
+        art: [
+            "XXXXXXXXX",
+            "XWWWWWWWX",
+            ".XWWWWWX.",
+            "..XWWWX..",
+            "...XWX...",
+            "...XWX...",
+            "..XWWWX..",
+            ".XWWWWWX.",
+            "XWWWWWWWX",
+            "XXXXXXXXX",
+        ],
+    },
 };
 function cursor(art, hotspot) {
     const width = art[0].length, height = art.length;
@@ -79,6 +96,19 @@ function cursor(art, hotspot) {
     const cel = { width, height, displaceX: (width >> 1) - hx, displaceY: height - 1 - hy, skipColor: Colour.Transparent, pixels };
     return writeView({ flags: 1, loops: [{ link: -1, mirror: false, cels: [cel] }], palette: undefined });
 }
+/**
+ * What a close-up dims the room with (CLOSE_UP_SHADE): the whole screen in colour 253, which
+ * CloseUp makes a remap colour that darkens what's under it.
+ */
+const CLOSE_UP_SHADE = 996;
+function shade() {
+    const [width, height] = [320, 200];
+    const cel = { width, height, displaceX: width >> 1, displaceY: height - 1, skipColor: Colour.Transparent, pixels: new Uint8Array(width * height).fill(253) };
+    return writeView({ flags: 1, loops: [{ link: -1, mirror: false, cels: [cel] }], palette: undefined });
+}
 export default function resources() {
-    return Object.entries(CURSORS).map(([verb, c]) => ({ type: ResourceType.View, number: CURSOR_BASE + Number(verb), data: cursor(c.art, c.hotspot) }));
+    return [
+        ...Object.entries(CURSORS).map(([verb, c]) => ({ type: ResourceType.View, number: CURSOR_BASE + Number(verb), data: cursor(c.art, c.hotspot) })),
+        { type: ResourceType.View, number: CLOSE_UP_SHADE, data: shade() },
+    ];
 }

package/lib/resources.ts

@@ -1,10 +1,11 @@
 import { Colour, ResourceType, writeView, type ResourceData } from "../tools/game/kit.ts";
 
 /**
- * The class library's own resources: a cursor for each verb, view CURSOR_BASE + verb
- * (system.sh). X is black, W white, . transparent.
+ * The class library's own resources: a cursor for each verb, view CURSOR_BASE + verb, and
+ * one while the player waits, CURSOR_WAIT (system.sh). X is black, W white, . transparent.
  */
 const CURSOR_BASE = 990;
+const CURSOR_WAIT = 995;
 
 const CURSORS: Record<number, { art: string[]; hotspot: "tip" | "centre" }> = {
   // V_LOOK: an eye.
@@ -72,6 +73,22 @@ const CURSORS: Record<number, { art: string[]; hotspot: "tip" | "centre" }> = {
       "...XXXXXX..",
     ],
   },
+  // Waiting: an hourglass.
+  [CURSOR_WAIT - CURSOR_BASE]: {
+    hotspot: "centre",
+    art: [
+      "XXXXXXXXX",
+      "XWWWWWWWX",
+      ".XWWWWWX.",
+      "..XWWWX..",
+      "...XWX...",
+      "...XWX...",
+      "..XWWWX..",
+      ".XWWWWWX.",
+      "XWWWWWWWX",
+      "XXXXXXXXX",
+    ],
+  },
 };
 
 function cursor(art: string[], hotspot: "tip" | "centre") {
@@ -83,6 +100,20 @@ function cursor(art: string[], hotspot: "tip" | "centre") {
   return writeView({ flags: 1, loops: [{ link: -1, mirror: false, cels: [cel] }], palette: undefined });
 }
 
+/**
+ * What a close-up dims the room with (CLOSE_UP_SHADE): the whole screen in colour 253, which
+ * CloseUp makes a remap colour that darkens what's under it.
+ */
+const CLOSE_UP_SHADE = 996;
+function shade() {
+  const [width, height] = [320, 200];
+  const cel = { width, height, displaceX: width >> 1, displaceY: height - 1, skipColor: Colour.Transparent, pixels: new Uint8Array(width * height).fill(253) };
+  return writeView({ flags: 1, loops: [{ link: -1, mirror: false, cels: [cel] }], palette: undefined });
+}
+
 export default function resources(): ResourceData[] {
-  return Object.entries(CURSORS).map(([verb, c]) => ({ type: ResourceType.View, number: CURSOR_BASE + Number(verb), data: cursor(c.art, c.hotspot) }));
+  return [
+    ...Object.entries(CURSORS).map(([verb, c]) => ({ type: ResourceType.View, number: CURSOR_BASE + Number(verb), data: cursor(c.art, c.hotspot) })),
+    { type: ResourceType.View, number: CLOSE_UP_SHADE, data: shade() },
+  ];
 }

package/lib/system.sh

@@ -8,15 +8,32 @@
   V_WALK
   V_DO)
 (define VERB_COUNT 4)
+(define V_ITEM 5)                   ; using the item picked in the inventory (theItem)
 
-;; Cursors: one view per verb, CURSOR_BASE + verb.
+;; Cursors: the library's are views CURSOR_BASE + verb, and CURSOR_WAIT while the player
+;; can't act (a game can bring its own: User).
 (define CURSOR_BASE 990)
+(define CURSOR_WAIT 995)
+
+;; The inventory window: icons are INV_ICON pixels square, INV_GAP apart.
+(define INV_ICON 24)
+(define INV_GAP 4)
+
+;; Close-ups: the room is dimmed by this view, drawn in a remap colour.
+(define CLOSE_UP_SHADE 996)
+(define REMAP_OFF 0)
+(define REMAP_BY_PERCENT 2)
 
 ;; Event types, as GetEvent reports them.
 (define EV_NULL 0)
 (define EV_MOUSE_DOWN 1)
 (define EV_MOUSE_UP 2)
 (define EV_KEY_DOWN 4)
+
+;; Keys (an event's message).
+(define KEY_TAB 9)
+(define KEY_I 73)
+(define KEY_i 105)
 (define EV_ALL $7fff)
 ;; The right button arrives as a click with shift held.
 (define MOD_RIGHT 3)
@@ -37,6 +54,10 @@
 (define ARRAY_FREE 4)
 (define STRING_LENGTH 10)
 
+;; Bitmap subfunctions.
+(define BITMAP_DISPOSE 1)
+(define BITMAP_DRAW_VIEW 3)
+
 ;; DoSound kernel calls.
 (define SND_INIT 6)
 (define SND_DISPOSE 7)

package/package.json

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

package/packages/content/src/room.js

@@ -537,11 +537,23 @@ class RoomCompiler {
                     ? [{ op: "async", code: send({ global: g.sound }, [["number", [n]], ["loop", [1]], ["play", ["self"]]]) }]
                     : [{ op: "code", code: send({ global: g.sound }, [["number", [n]], ["loop", [1]], ["play", []]]) }];
             }
+            case "closeup": {
+                if (args.length < 1 || args.length > 3)
+                    fail("expected <<closeup view [loop [cel]]>>");
+                if (!this.target.closeUp)
+                    fail("this game has no close-ups");
+                const [view, loop = "0", cel = "0"] = args;
+                // A new close-up, shown until the player clicks; then it cues the script.
+                return [{ op: "async", code: [
+                            ...send({ cls: this.target.closeUp }, [["new", []]]),
+                            "pushi #show", "pushi 4", ...pushVal(int(view, "view", 0, 65535)), ...pushVal(int(loop, "loop", 0, 255)), ...pushVal(int(cel, "cel", 0, 255)), "pushSelf", "send 12",
+                        ] }];
+            }
             case "room":
                 arity(1, "number");
                 return [{ op: "code", code: send({ global: g.curRoom }, [["newRoom", [int(args[0], "room", 0, 65535)]]]) }];
             default:
-                return fail("unknown command (known: walk, face, wait, hide, show, loop, cel, animate, stop, music, sound, room; and set, if)");
+                return fail("unknown command (known: walk, face, wait, hide, show, loop, cel, animate, stop, music, sound, closeup, room; and set, if)");
         }
     }
     /** Loop music n, unless it's what's playing already. */

package/packages/content/src/room.ts

@@ -636,11 +636,21 @@ class RoomCompiler {
           ? [{ op: "async", code: send({ global: g.sound }, [["number", [n]], ["loop", [1]], ["play", ["self"]]]) }]
           : [{ op: "code", code: send({ global: g.sound }, [["number", [n]], ["loop", [1]], ["play", []]]) }];
       }
+      case "closeup": {
+        if (args.length < 1 || args.length > 3) fail("expected <<closeup view [loop [cel]]>>");
+        if (!this.target.closeUp) fail("this game has no close-ups");
+        const [view, loop = "0", cel = "0"] = args;
+        // A new close-up, shown until the player clicks; then it cues the script.
+        return [{ op: "async", code: [
+          ...send({ cls: this.target.closeUp! }, [["new", []]]),
+          "pushi #show", "pushi 4", ...pushVal(int(view, "view", 0, 65535)), ...pushVal(int(loop, "loop", 0, 255)), ...pushVal(int(cel, "cel", 0, 255)), "pushSelf", "send 12",
+        ] }];
+      }
       case "room":
         arity(1, "number");
         return [{ op: "code", code: send({ global: g.curRoom }, [["newRoom", [int(args[0], "room", 0, 65535)]]]) }];
       default:
-        return fail("unknown command (known: walk, face, wait, hide, show, loop, cel, animate, stop, music, sound, room; and set, if)");
+        return fail("unknown command (known: walk, face, wait, hide, show, loop, cel, animate, stop, music, sound, closeup, room; and set, if)");
     }
   }
 

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

@@ -59,6 +59,11 @@ export interface Target {
     };
     /** The class that cycles a prop's cels forever (<<animate x forever>>, cycle: forward). */
     forwardCycle: string;
+    /**
+     * Close-ups (<<closeup view [loop [cel]]>>), if the target has them: a class whose new
+     * instance takes `show: view loop cel caller` and cues the caller when it's dismissed.
+     */
+    closeUp?: string;
     /** Verb number for "said on arrival" messages. */
     narrationVerb: number;
     /** Verb names as used in Yarn node titles (lower case) -> verb numbers. */

package/packages/content/src/target.ts

@@ -46,6 +46,11 @@ export interface Target {
   teller: { class: string; props: Record<string, number>; verb: number };
   /** The class that cycles a prop's cels forever (<<animate x forever>>, cycle: forward). */
   forwardCycle: string;
+  /**
+   * Close-ups (<<closeup view [loop [cel]]>>), if the target has them: a class whose new
+   * instance takes `show: view loop cel caller` and cues the caller when it's dismissed.
+   */
+  closeUp?: string;
   /** Verb number for "said on arrival" messages. */
   narrationVerb: number;
   /** Verb names as used in Yarn node titles (lower case) -> verb numbers. */

package/packages/sci/src/vm/kernels/text.js

@@ -330,9 +330,34 @@ export const textKernels = {
         g.items.delete(obj);
         return text !== original ? 1 : 0;
     },
-    Bitmap: (vm, [subop = 0, ref = 0]) => {
-        if (subop === 1 && vm.memory.bitmap(ref))
+    // Bitmap(1, bitmap): dispose. Bitmap(3, bitmap, view, loop, cel, x, y): draw a view's cel
+    // into the bitmap with its origin at (x, y), skipping its transparent pixels (SCI2.1's
+    // kBitmapDrawView; the class library frames text boxes with it).
+    Bitmap: (vm, [subop = 0, ref = 0, ...args]) => {
+        const bmp = vm.memory.bitmap(ref);
+        if (subop === 1 && bmp)
             vm.memory.free(segmentOf(ref));
+        if (subop === 3 && bmp) {
+            const [view = 0, loop = 0, celNo = 0, x = 0, y = 0] = args.map(toSigned);
+            const found = graphics(vm).cel(view, loop, celNo);
+            if (!found)
+                return 0;
+            const { cel, mirror } = found;
+            const left = x - ((cel.width >> 1) - cel.displaceX), top = y - (cel.height - 1 - cel.displaceY);
+            for (let cy = 0; cy < cel.height; cy++) {
+                const by = top + cy;
+                if (by < 0 || by >= bmp.height)
+                    continue;
+                for (let cx = 0; cx < cel.width; cx++) {
+                    const bx = left + cx;
+                    if (bx < 0 || bx >= bmp.width)
+                        continue;
+                    const c = cel.pixels[cy * cel.width + (mirror ? cel.width - 1 - cx : cx)];
+                    if (c !== cel.skipColor)
+                        bmp.pixels[by * bmp.width + bx] = c;
+                }
+            }
+        }
         return 0;
     },
 };

package/packages/sci/src/vm/kernels/text.ts

@@ -321,8 +321,29 @@ export const textKernels: Record<string, KernelFn> = {
     return text !== original ? 1 : 0;
   },
 
-  Bitmap: (vm, [subop = 0, ref = 0]) => {
-    if (subop === 1 && vm.memory.bitmap(ref)) vm.memory.free(segmentOf(ref));
+  // Bitmap(1, bitmap): dispose. Bitmap(3, bitmap, view, loop, cel, x, y): draw a view's cel
+  // into the bitmap with its origin at (x, y), skipping its transparent pixels (SCI2.1's
+  // kBitmapDrawView; the class library frames text boxes with it).
+  Bitmap: (vm, [subop = 0, ref = 0, ...args]) => {
+    const bmp = vm.memory.bitmap(ref);
+    if (subop === 1 && bmp) vm.memory.free(segmentOf(ref));
+    if (subop === 3 && bmp) {
+      const [view = 0, loop = 0, celNo = 0, x = 0, y = 0] = args.map(toSigned);
+      const found = graphics(vm).cel(view, loop, celNo);
+      if (!found) return 0;
+      const { cel, mirror } = found;
+      const left = x - ((cel.width >> 1) - cel.displaceX), top = y - (cel.height - 1 - cel.displaceY);
+      for (let cy = 0; cy < cel.height; cy++) {
+        const by = top + cy;
+        if (by < 0 || by >= bmp.height) continue;
+        for (let cx = 0; cx < cel.width; cx++) {
+          const bx = left + cx;
+          if (bx < 0 || bx >= bmp.width) continue;
+          const c = cel.pixels[cy * cel.width + (mirror ? cel.width - 1 - cx : cx)]!;
+          if (c !== cel.skipColor) bmp.pixels[by * bmp.width + bx] = c;
+        }
+      }
+    }
     return 0;
   },
 };

package/tools/art/build.d.ts

@@ -24,6 +24,16 @@ export interface ArtManifest {
             mirror: boolean;
         })[];
     }[];
+    /** Fonts drawn as sheets of glyphs (tools/art/font.ts). */
+    fonts?: {
+        number: number;
+        png: string;
+        cell: [number, number];
+        first?: number;
+        spacing?: number;
+        space?: number;
+        lineHeight?: number;
+    }[];
 }
 export declare class ArtError extends Error {
 }

package/tools/art/build.js

@@ -1,8 +1,9 @@
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { ResourceType, writeHunkPalette, writePic, writeView } from "../../packages/sci/src/index.js";
+import { ResourceType, writeFont, writeHunkPalette, writePic, writeView } from "../../packages/sci/src/index.js";
 import { basePalette } from "../game/defaults.js";
 import { decodePng } from "../png.js";
+import { FontSheetError, fontFromSheet } from "./font.js";
 export class ArtError extends Error {
 }
 export function buildArt(file) {
@@ -38,7 +39,7 @@ export function buildArt(file) {
             return fail(where, "expected a file path");
         return resolve(dirname(file), value);
     };
-    const m = object(json(file), "manifest", ["version", "palette", "maxColours", "pictures", "views"]);
+    const m = object(json(file), "manifest", ["version", "palette", "maxColours", "pictures", "views", "fonts"]);
     if (m.version !== 1)
         fail("version", "expected 1");
     const maxColours = m.maxColours === undefined ? 254 : int(m.maxColours, "maxColours", 2, 254);
@@ -170,6 +171,35 @@ export function buildArt(file) {
             fail(where, "a view supports at most 255 stored cels");
         resources.push({ type: ResourceType.View, number: n, data: writeView({ flags: 1, loops, palette }) });
     });
+    list(m.fonts ?? [], "fonts", 0, 65536).forEach((value, i) => {
+        const where = `fonts[${i}]`;
+        const f = object(value, where, ["number", "png", "cell", "first", "spacing", "space", "lineHeight"]);
+        const n = number(f.number, "font", `${where}.number`);
+        const filename = path(f.png, `${where}.png`);
+        let img;
+        try {
+            img = decodePng(readFileSync(filename));
+        }
+        catch (e) {
+            return fail(`${where}.png`, `${filename}: ${e.message}`);
+        }
+        const cell = list(f.cell, `${where}.cell`, 2, 2);
+        const optional = (key, min, max) => (f[key] === undefined ? undefined : int(f[key], `${where}.${key}`, min, max));
+        try {
+            const font = fontFromSheet(img, {
+                cell: [int(cell[0], `${where}.cell[0]`, 1, 128), int(cell[1], `${where}.cell[1]`, 1, 128)],
+                first: optional("first", 0, 255), spacing: optional("spacing", 0, 16),
+                space: optional("space", 1, 128), lineHeight: optional("lineHeight", 1, 255),
+            });
+            resources.push({ type: ResourceType.Font, number: n, data: writeFont(font) });
+            images++;
+        }
+        catch (e) {
+            if (!(e instanceof FontSheetError))
+                throw e;
+            fail(`${where}.png`, e.message);
+        }
+    });
     resources.sort((a, b) => a.type - b.type || a.number - b.number);
     return { resources, colours, images };
 }

package/tools/art/build.ts

@@ -1,8 +1,9 @@
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { ResourceType, writeHunkPalette, writePic, writeView, type ResourceData, type ViewLoop } from "../../packages/sci/src/index.ts";
+import { ResourceType, writeFont, writeHunkPalette, writePic, writeView, type ResourceData, type ViewLoop } from "../../packages/sci/src/index.ts";
 import { basePalette } from "../game/defaults.ts";
 import { decodePng } from "../png.ts";
+import { FontSheetError, fontFromSheet } from "./font.ts";
 
 /** Editor-neutral, exact-colour art for standalone games. See docs/art-workflow.md. */
 export interface ArtManifest {
@@ -12,6 +13,8 @@ export interface ArtManifest {
   maxColours?: number;
   pictures: { number: number; layers: { png: string; priority: number }[] }[];
   views: { number: number; loops: ({ cels: { png: string; anchor: [number, number] }[] } | { link: number; mirror: boolean })[] }[];
+  /** Fonts drawn as sheets of glyphs (tools/art/font.ts). */
+  fonts?: { number: number; png: string; cell: [number, number]; first?: number; spacing?: number; space?: number; lineHeight?: number }[];
 }
 
 export class ArtError extends Error {}
@@ -39,7 +42,7 @@ export function buildArt(file: string): { resources: ResourceData[]; colours: st
     if (typeof value !== "string" || !value.length) return fail(where, "expected a file path");
     return resolve(dirname(file), value);
   };
-  const m = object(json(file), "manifest", ["version", "palette", "maxColours", "pictures", "views"]);
+  const m = object(json(file), "manifest", ["version", "palette", "maxColours", "pictures", "views", "fonts"]);
   if (m.version !== 1) fail("version", "expected 1");
   const maxColours = m.maxColours === undefined ? 254 : int(m.maxColours, "maxColours", 2, 254);
   const paletteInput = json(path(m.palette, "palette"));
@@ -148,6 +151,29 @@ export function buildArt(file: string): { resources: ResourceData[]; colours: st
     if (total > 255) fail(where, "a view supports at most 255 stored cels");
     resources.push({ type: ResourceType.View, number: n, data: writeView({ flags: 1, loops, palette }) });
   });
+  list(m.fonts ?? [], "fonts", 0, 65536).forEach((value, i) => {
+    const where = `fonts[${i}]`;
+    const f = object(value, where, ["number", "png", "cell", "first", "spacing", "space", "lineHeight"]);
+    const n = number(f.number, "font", `${where}.number`);
+    const filename = path(f.png, `${where}.png`);
+    let img: ReturnType<typeof decodePng>;
+    try { img = decodePng(readFileSync(filename)); }
+    catch (e) { return fail(`${where}.png`, `${filename}: ${(e as Error).message}`); }
+    const cell = list(f.cell, `${where}.cell`, 2, 2);
+    const optional = (key: string, min: number, max: number) => (f[key] === undefined ? undefined : int(f[key], `${where}.${key}`, min, max));
+    try {
+      const font = fontFromSheet(img, {
+        cell: [int(cell[0], `${where}.cell[0]`, 1, 128), int(cell[1], `${where}.cell[1]`, 1, 128)],
+        first: optional("first", 0, 255), spacing: optional("spacing", 0, 16),
+        space: optional("space", 1, 128), lineHeight: optional("lineHeight", 1, 255),
+      });
+      resources.push({ type: ResourceType.Font, number: n, data: writeFont(font) });
+      images++;
+    } catch (e) {
+      if (!(e instanceof FontSheetError)) throw e;
+      fail(`${where}.png`, e.message);
+    }
+  });
   resources.sort((a, b) => a.type - b.type || a.number - b.number);
   return { resources, colours, images };
 }

package/tools/art/font.d.ts

@@ -0,0 +1,24 @@
+import type { Font } from "../../packages/sci/src/index.ts";
+import type { Rgba } from "../png.ts";
+/**
+ * A font from a sheet of glyphs drawn in a paint program: a grid of same-size cells, one
+ * character per cell, left to right and top to bottom from `first`. A glyph is drawn from
+ * its cell's left edge; any opaque pixel is ink (its colour doesn't matter: text takes its
+ * colour when it's drawn), and its width is up to its rightmost ink. A cell with no ink is
+ * a character the font doesn't have, except the space, which is `space` pixels wide.
+ */
+export interface FontSheet {
+    /** Cell size in pixels: [width, height]. */
+    cell: [number, number];
+    /** The character in the first cell (default 32, the space). */
+    first?: number;
+    /** Pixels between one glyph and the next (default 1). */
+    spacing?: number;
+    /** Width of the space (default half a cell). */
+    space?: number;
+    /** Line height (default the cell height). */
+    lineHeight?: number;
+}
+export declare class FontSheetError extends Error {
+}
+export declare function fontFromSheet(img: Rgba, sheet: FontSheet): Font;

package/tools/art/font.js

@@ -0,0 +1,40 @@
+export class FontSheetError extends Error {
+}
+export function fontFromSheet(img, sheet) {
+    const [cw, ch] = sheet.cell;
+    const first = sheet.first ?? 32, spacing = sheet.spacing ?? 1;
+    const space = sheet.space ?? Math.max(1, cw >> 1), lineHeight = sheet.lineHeight ?? ch;
+    const fail = (message) => { throw new FontSheetError(message); };
+    if (img.width % cw || img.height % ch)
+        fail(`${img.width}x${img.height} is not a whole number of ${cw}x${ch} cells`);
+    const columns = img.width / cw, cells = columns * (img.height / ch);
+    if (first + cells > 256)
+        fail(`${cells} cells from character ${first} go past 255`);
+    if (lineHeight < 1 || lineHeight > 255)
+        fail(`line height ${lineHeight} is outside 1..255`);
+    const glyphs = Array.from({ length: Math.max(128, first + cells) }, () => ({ width: 0, height: 0, pixels: new Uint8Array(0) }));
+    for (let i = 0; i < cells; i++) {
+        const left = (i % columns) * cw, top = Math.floor(i / columns) * ch;
+        const ink = new Uint8Array(cw * ch);
+        let right = -1;
+        for (let y = 0; y < ch; y++) {
+            for (let x = 0; x < cw; x++) {
+                const a = img.data[((top + y) * img.width + left + x) * 4 + 3];
+                if (a !== 0 && a !== 255)
+                    fail(`character ${first + i} (${left + x},${top + y}): alpha ${a}; export without antialiasing`);
+                if (a)
+                    (ink[y * cw + x] = 1), (right = Math.max(right, x));
+            }
+        }
+        const code = first + i;
+        if (right < 0 && code !== 32)
+            continue;
+        const inked = right + 1, width = (code === 32 && right < 0 ? space : inked + spacing);
+        const pixels = new Uint8Array(width * ch);
+        for (let y = 0; y < ch; y++)
+            for (let x = 0; x < inked; x++)
+                pixels[y * width + x] = ink[y * cw + x];
+        glyphs[code] = { width, height: ch, pixels };
+    }
+    return { height: lineHeight, glyphs };
+}

package/tools/art/font.ts

@@ -0,0 +1,56 @@
+import type { Font, Glyph } from "../../packages/sci/src/index.ts";
+import type { Rgba } from "../png.ts";
+
+/**
+ * A font from a sheet of glyphs drawn in a paint program: a grid of same-size cells, one
+ * character per cell, left to right and top to bottom from `first`. A glyph is drawn from
+ * its cell's left edge; any opaque pixel is ink (its colour doesn't matter: text takes its
+ * colour when it's drawn), and its width is up to its rightmost ink. A cell with no ink is
+ * a character the font doesn't have, except the space, which is `space` pixels wide.
+ */
+export interface FontSheet {
+  /** Cell size in pixels: [width, height]. */
+  cell: [number, number];
+  /** The character in the first cell (default 32, the space). */
+  first?: number;
+  /** Pixels between one glyph and the next (default 1). */
+  spacing?: number;
+  /** Width of the space (default half a cell). */
+  space?: number;
+  /** Line height (default the cell height). */
+  lineHeight?: number;
+}
+
+export class FontSheetError extends Error {}
+
+export function fontFromSheet(img: Rgba, sheet: FontSheet): Font {
+  const [cw, ch] = sheet.cell;
+  const first = sheet.first ?? 32, spacing = sheet.spacing ?? 1;
+  const space = sheet.space ?? Math.max(1, cw >> 1), lineHeight = sheet.lineHeight ?? ch;
+  const fail = (message: string): never => { throw new FontSheetError(message); };
+  if (img.width % cw || img.height % ch) fail(`${img.width}x${img.height} is not a whole number of ${cw}x${ch} cells`);
+  const columns = img.width / cw, cells = columns * (img.height / ch);
+  if (first + cells > 256) fail(`${cells} cells from character ${first} go past 255`);
+  if (lineHeight < 1 || lineHeight > 255) fail(`line height ${lineHeight} is outside 1..255`);
+
+  const glyphs: Glyph[] = Array.from({ length: Math.max(128, first + cells) }, () => ({ width: 0, height: 0, pixels: new Uint8Array(0) }));
+  for (let i = 0; i < cells; i++) {
+    const left = (i % columns) * cw, top = Math.floor(i / columns) * ch;
+    const ink = new Uint8Array(cw * ch);
+    let right = -1;
+    for (let y = 0; y < ch; y++) {
+      for (let x = 0; x < cw; x++) {
+        const a = img.data[((top + y) * img.width + left + x) * 4 + 3]!;
+        if (a !== 0 && a !== 255) fail(`character ${first + i} (${left + x},${top + y}): alpha ${a}; export without antialiasing`);
+        if (a) (ink[y * cw + x] = 1), (right = Math.max(right, x));
+      }
+    }
+    const code = first + i;
+    if (right < 0 && code !== 32) continue;
+    const inked = right + 1, width = (code === 32 && right < 0 ? space : inked + spacing);
+    const pixels = new Uint8Array(width * ch);
+    for (let y = 0; y < ch; y++) for (let x = 0; x < inked; x++) pixels[y * width + x] = ink[y * cw + x]!;
+    glyphs[code] = { width, height: ch, pixels };
+  }
+  return { height: lineHeight, glyphs };
+}

package/tools/game/build.d.ts

@@ -9,6 +9,8 @@ import { type ResourceData } from "../../packages/sci/src/index.ts";
  *   games/<name>/rooms/<n>.room.yaml (+ <n>.yarn)  rooms as data (packages/content), compiled
  *                                  for the class library; their Yarn variables are flags
  *                                  numbered in flags.yaml
+ *   games/<name>/items.yaml        optional: the verbs of the things the hero can carry
+ *                                  (`lens: 10`), so rooms' Yarn can answer them (filings.lens)
  *   games/<name>/music/<n>.mid     music: sound n, from a Standard MIDI File (General MIDI)
  *   games/<name>/sounds/<n>.wav    digital effects: sound n plays this instead of music
  *   games/<name>/resources.ts      optional: `export default () => ResourceData[]` for art,
@@ -44,3 +46,5 @@ export declare const LIBRARY_DIR: string;
 export declare function buildGame(dir: string, options?: {
     library?: boolean;
 }): Promise<BuiltGame>;
+/** items.yaml: `name: verb` lines, each item's verb from 10 to 255 (1 to 4 are the player's). */
+export declare function itemVerbs(dir: string): Record<string, number>;

package/tools/game/build.js

@@ -108,7 +108,7 @@ export async function buildGame(dir, options = {}) {
         const roomsDir = join(dir, "rooms");
         if (!existsSync(roomsDir))
             return [];
-        const target = libraryTarget(globals);
+        const target = libraryTarget(globals, itemVerbs(dir));
         const flags = modFlags(dir, { content: target });
         const out = [];
         for (const { file, text } of load(roomsDir, /^\d+\.room\.yaml$/)) {
@@ -257,3 +257,29 @@ export async function buildGame(dir, options = {}) {
         warnings: [...new Set(warnings)],
     };
 }
+/** items.yaml: `name: verb` lines, each item's verb from 10 to 255 (1 to 4 are the player's). */
+export function itemVerbs(dir) {
+    const file = join(dir, "items.yaml");
+    if (!existsSync(file))
+        return {};
+    const where = relative(process.cwd(), file);
+    const verbs = {};
+    readFileSync(file, "utf8").split("\n").forEach((raw, i) => {
+        const line = raw.replace(/#.*/, "").trim();
+        if (!line)
+            return;
+        const at = `${where}:${i + 1}`;
+        const m = /^([A-Za-z]\w*)\s*:\s*(\d+)$/.exec(line);
+        if (!m)
+            throw new GameBuildError(`${at}: expected item: verb`);
+        const [, name, n] = m, verb = Number(n);
+        if (!/^[a-z][A-Za-z0-9]*$/.test(name) || ["look", "talk", "walk", "do", "enter"].includes(name))
+            throw new GameBuildError(`${at}: "${name}" can't name an item (lower camelCase, and not a verb)`);
+        if (verb < 10 || verb > 255)
+            throw new GameBuildError(`${at}: ${name}: the verb is a number from 10 to 255`);
+        if (Object.values(verbs).includes(verb))
+            throw new GameBuildError(`${at}: ${name}: verb ${verb} is used twice`);
+        verbs[name] = verb;
+    });
+    return verbs;
+}

package/tools/game/build.ts

@@ -22,6 +22,8 @@ import { libraryTarget } from "./target.ts";
  *   games/<name>/rooms/<n>.room.yaml (+ <n>.yarn)  rooms as data (packages/content), compiled
  *                                  for the class library; their Yarn variables are flags
  *                                  numbered in flags.yaml
+ *   games/<name>/items.yaml        optional: the verbs of the things the hero can carry
+ *                                  (`lens: 10`), so rooms' Yarn can answer them (filings.lens)
  *   games/<name>/music/<n>.mid     music: sound n, from a Standard MIDI File (General MIDI)
  *   games/<name>/sounds/<n>.wav    digital effects: sound n plays this instead of music
  *   games/<name>/resources.ts      optional: `export default () => ResourceData[]` for art,
@@ -140,7 +142,7 @@ export async function buildGame(dir: string, options: { library?: boolean } = {}
   const compileRooms = (): { file: string; text: string }[] => {
     const roomsDir = join(dir, "rooms");
     if (!existsSync(roomsDir)) return [];
-    const target = libraryTarget(globals);
+    const target = libraryTarget(globals, itemVerbs(dir));
     const flags = modFlags(dir, { content: target });
     const out: { file: string; text: string }[] = [];
     for (const { file, text } of load(roomsDir, /^\d+\.room\.yaml$/)) {
@@ -281,3 +283,24 @@ export async function buildGame(dir: string, options: { library?: boolean } = {}
     warnings: [...new Set(warnings)],
   };
 }
+
+/** items.yaml: `name: verb` lines, each item's verb from 10 to 255 (1 to 4 are the player's). */
+export function itemVerbs(dir: string): Record<string, number> {
+  const file = join(dir, "items.yaml");
+  if (!existsSync(file)) return {};
+  const where = relative(process.cwd(), file);
+  const verbs: Record<string, number> = {};
+  readFileSync(file, "utf8").split("\n").forEach((raw, i) => {
+    const line = raw.replace(/#.*/, "").trim();
+    if (!line) return;
+    const at = `${where}:${i + 1}`;
+    const m = /^([A-Za-z]\w*)\s*:\s*(\d+)$/.exec(line);
+    if (!m) throw new GameBuildError(`${at}: expected item: verb`);
+    const [, name, n] = m, verb = Number(n);
+    if (!/^[a-z][A-Za-z0-9]*$/.test(name!) || ["look", "talk", "walk", "do", "enter"].includes(name!)) throw new GameBuildError(`${at}: "${name}" can't name an item (lower camelCase, and not a verb)`);
+    if (verb < 10 || verb > 255) throw new GameBuildError(`${at}: ${name}: the verb is a number from 10 to 255`);
+    if (Object.values(verbs).includes(verb)) throw new GameBuildError(`${at}: ${name}: verb ${verb} is used twice`);
+    verbs[name!] = verb;
+  });
+  return verbs;
+}

package/tools/game/kit.d.ts

@@ -5,3 +5,4 @@
 export { ResourceType, SoundDevice, writeFont, writeHunkPalette, writePic, writeSound, writeView, type Cel, type Font, type HunkPaletteFile, type MidiEvent, type PicFile, type ResourceData, type SoundSpec, type ViewFile, } from "../../packages/sci/src/index.ts";
 export { BASE_PALETTE, CURSOR_VIEW, Colour, DEFAULT_FONT, basePalette, cube } from "./defaults.ts";
 export { pixelFont } from "./font.ts";
+export { fontFromSheet, type FontSheet } from "../art/font.ts";

package/tools/game/kit.js

@@ -5,3 +5,4 @@
 export { ResourceType, SoundDevice, writeFont, writeHunkPalette, writePic, writeSound, writeView, } from "../../packages/sci/src/index.js";
 export { BASE_PALETTE, CURSOR_VIEW, Colour, DEFAULT_FONT, basePalette, cube } from "./defaults.js";
 export { pixelFont } from "./font.js";
+export { fontFromSheet } from "../art/font.js";

package/tools/game/kit.ts

@@ -8,3 +8,4 @@ export {
 } from "../../packages/sci/src/index.ts";
 export { BASE_PALETTE, CURSOR_VIEW, Colour, DEFAULT_FONT, basePalette, cube } from "./defaults.ts";
 export { pixelFont } from "./font.ts";
+export { fontFromSheet, type FontSheet } from "../art/font.ts";

package/tools/game/target.d.ts

@@ -4,4 +4,4 @@ import type { Target } from "../../packages/content/src/index.ts";
  * (packages/content). Global numbers depend on the game's script 0, so the target is made
  * for each build from the compiled globals' names.
  */
-export declare function libraryTarget(globals: readonly string[]): Target;
+export declare function libraryTarget(globals: readonly string[], items?: Record<string, number>): Target;

package/tools/game/target.js

@@ -3,7 +3,7 @@
  * (packages/content). Global numbers depend on the game's script 0, so the target is made
  * for each build from the compiled globals' names.
  */
-export function libraryTarget(globals) {
+export function libraryTarget(globals, items = {}) {
     const g = (name) => {
         const n = globals.indexOf(name);
         if (n < 0)
@@ -28,12 +28,14 @@ export function libraryTarget(globals) {
         firstRoomTalker: 200,
         voice: { class: "Talker", props: {} },
         // Portraits stand at the top left, the text beside them.
-        portrait: { class: "PortraitTalker", props: {}, at: [36, 70], frameSignal: 0, partSignal: 0 },
+        portrait: { class: "PortraitTalker", props: {}, at: [8, 8], frameSignal: 0, partSignal: 0 },
         teller: { class: "Teller", props: {}, verb: 2 },
         forwardCycle: "Forward",
+        closeUp: "CloseUp",
         // room.enter lines: a verb the player can't use.
         narrationVerb: 0,
-        verbs: { look: 1, talk: 2, walk: 3, do: 4 },
+        // And the game's items (items.yaml): using one is its own verb.
+        verbs: { look: 1, talk: 2, walk: 3, do: 4, ...items },
         messageVersion: 4321,
         // SetFlag, ClearFlag and IsFlag: script 999's exports 0, 1 and 2.
         flags: { script: 999, set: 0, clear: 1, test: 2, first: 0, last: 1023 },

package/tools/game/target.ts

@@ -5,7 +5,7 @@ import type { Target } from "../../packages/content/src/index.ts";
  * (packages/content). Global numbers depend on the game's script 0, so the target is made
  * for each build from the compiled globals' names.
  */
-export function libraryTarget(globals: readonly string[]): Target {
+export function libraryTarget(globals: readonly string[], items: Record<string, number> = {}): Target {
   const g = (name: string) => {
     const n = globals.indexOf(name);
     if (n < 0) throw new Error(`the library's global ${name} isn't there: is script 0 compiled with the library?`);
@@ -29,12 +29,14 @@ export function libraryTarget(globals: readonly string[]): Target {
     firstRoomTalker: 200,
     voice: { class: "Talker", props: {} },
     // Portraits stand at the top left, the text beside them.
-    portrait: { class: "PortraitTalker", props: {}, at: [36, 70], frameSignal: 0, partSignal: 0 },
+    portrait: { class: "PortraitTalker", props: {}, at: [8, 8], frameSignal: 0, partSignal: 0 },
     teller: { class: "Teller", props: {}, verb: 2 },
     forwardCycle: "Forward",
+    closeUp: "CloseUp",
     // room.enter lines: a verb the player can't use.
     narrationVerb: 0,
-    verbs: { look: 1, talk: 2, walk: 3, do: 4 },
+    // And the game's items (items.yaml): using one is its own verb.
+    verbs: { look: 1, talk: 2, walk: 3, do: 4, ...items },
     messageVersion: 4321,
     // SetFlag, ClearFlag and IsFlag: script 999's exports 0, 1 and 2.
     flags: { script: 999, set: 0, clear: 1, test: 2, first: 0, last: 1023 },