Give the Voyager a screen

A tile engine on ports 0x30 to 0x3F, bringing one bank of video memory registered the way
the disk's buffer is. The CPU writes cell indices and the device turns them into pixels,
which is the whole reason a screen is affordable at a megahertz: a frame is 16,667 cycles,
a full 320 by 200 picture is 64,000 bytes, and a 40 by 25 map is 2,000. A program that
changes two cells writes four bytes. The cost of a screen becomes the number of cells that
changed rather than the number of pixels on it.

Which makes colour depth free, so the tiles are eight bits: an 8 by 8 cell is 64 pixels and
each picks independently out of 256 colours, with no per-cell limit of the kind that made a
Spectrum two and C64 multicolour four. The low nibble of a cell's attribute is ADDED to
every index in its tile, sixteen at a time, so a tile drawn in 0 to 15 appears in any of
sixteen schemes without a second copy in tile memory - and a tile wanting all 256 leaves the
nibble at zero and gets them. Neither use costs the other anything.

Two decisions are arithmetic rather than taste, and both come from the machine having no
multiply. A map row is a page whether the mode fills it or not, so a cell address is the row
number as the high byte and the doubled column as the low byte with no arithmetic at all;
otherwise every cursor move on a 40 column screen would cost a row-times-40 in software. And
a palette entry is four bytes rather than three, so entry n is at n times four, a shift.

THE MAP IS A RING and the Scroll register says which of its 128 rows is on top. Scrolling
moves a register and no memory: blitting a 40 by 25 screen up one line is 1,920 bytes inside
one bank, which is twelve percent of a frame even with the controller widened, and a program
printing one page would spend six frames shuffling memory. It is now one port write - and
the rows that scrolled off are still there, which is where a terminal gets scrollback it
never had.

The device is part of the machine rather than part of the window. It renders into a buffer
that is a pure function of video memory, so the same program draws the same picture with
nobody watching; Voyager puts that buffer on the glass and decides nothing. Both binaries
take --screen, which saves a PPM when the machine stops, and that is what makes a screen
checkable on a host with no display at all.

Tests/video.sh checks fourteen named behaviours rather than comparing a recorded image,
because a recorded image would say "something changed" and leave which of the palette, the
tile, the attribute, the map or the scroll register broke to be found by hand. Verified by
breaking three things in turn: the additive nibble failed exactly one check, the scroll
origin exactly two, and moving every cell one pixel sideways exactly the four about
placement.

Tests/docs.sh could not count past nine, which is how a suite of ten scripts reported
itself as wrong for the wrong reason.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01E2JrLzFvuFX9fgi1LDRjrW

Source/Emulator/utility.c

@@ -27,6 +27,9 @@ void printHelp(const char *programName) {
     printf("                       default, finishes before the next instruction starts.\n");
     printf("  -W, --write-protect  Attach the disk read only. A disk the host will not let\n");
     printf("                    you write is read only whether you ask for this or not.\n");
+    printf("  -S, --screen FILE Save a picture of the screen, as a PPM, when the machine\n");
+    printf("                    stops. Works with or without a window, which is how the\n");
+    printf("                    tests look at a screen on a host that has no display.\n");
     printf("  -h, --help        Display this help message.\n");
 }
 
@@ -38,6 +41,7 @@ uint8_t parseOptions(int argc, char *argv[], EmulatorOptions *options) {
         {"disk",   required_argument, 0, 'D'},
         {"write-protect", no_argument, 0, 'W'},
         {"disk-cycles", required_argument, 0, 'L'},
+        {"screen", required_argument, 0, 'S'},
         {"help",   no_argument,       0, 'h'},
         {0,        0,                 0,  0 }
         };
@@ -50,9 +54,10 @@ uint8_t parseOptions(int argc, char *argv[], EmulatorOptions *options) {
     options->disk = NULL;
     options->writeProtect = 0;
     options->diskCycles = 0;
+    options->screen = NULL;
 
     // Parse options
-    while ((opt = getopt_long(argc, argv, "dc:fhD:WL:", long_options, &option_index)) != -1) {
+    while ((opt = getopt_long(argc, argv, "dc:fhD:WL:S:", long_options, &option_index)) != -1) {
         switch (opt) {
             case 'd':
                 options->debug = 1;
@@ -82,6 +87,9 @@ uint8_t parseOptions(int argc, char *argv[], EmulatorOptions *options) {
             case 'L':
                 options->diskCycles = strtoul(optarg, NULL, 0);
             break;
+            case 'S':
+                options->screen = optarg;
+            break;
             case 'h':
                 printHelp(argv[0]);
                 return OPTIONS_HELP;