Sprites: things that move without the screen moving

Everything drawn on this machine was in a cell. Something between two
cells meant rewriting both; something moving a pixel at a time meant
rewriting them sixty times a second, which is affordable for one thing
and not for twenty. A sprite is put at a pixel and the device draws it
over whatever is behind, so moving it costs two bytes.

MADE OF TILES, which is the decision the rest follows from: m by n taken
in reading order from one index, so there is no second pixel format, no
second kind of memory, and nothing a sprite can show that the map cannot.
A 16 by 16 character is four tiles and the background can name the same
four.

256 entries of 8 bytes at 0xC000 in the atlas - eight so the entry
address is a shift, the same no-multiply argument as the palette's four.
Position is signed and sixteen bits, because 640 by 400 does not fit in a
byte and a sprite has to be able to sit half off the left rather than
appearing whole at the edge.

A PIXEL OF ZERO IS NOT DRAWN, or every sprite is a rectangle. Tested
before the attribute is added, so a hole belongs to the art and not to
the colour scheme. The same rule the other way round is what "behind"
means: drawn only where the background pixel was zero, so a thing walks
behind a pillar and in front of the floor in one frame.

All of them draw, every frame, so they cannot flicker. Real machines
dropped them per scanline because they had a fixed number of shift
registers; this has a loop. The limit is the size of the table, which is
a constant rather than a property of what is on screen.

And the system takes them down at exit. The sprite table sits in the gap
the screen save walks around - to the end of the map, then the palette -
and that is right, because nothing the shell draws is a sprite: there is
nothing to give back, only something to take away. Otherwise a program
that put a ball up and left would leave it over the prompt, in front of
everything, with nothing able to type it away. Sprite.asm deliberately
leaves its own, because a program that faulted could not have cleared it.

Every check here was re-broken and failed: transparency, reading order,
draw order, priority, and size. Size needed breaking twice - the first
attempt did not compile, and a silent build failure had left the old
binary passing.

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

Tests/manifest

@@ -977,6 +977,19 @@ cosmosGrid           | CosmOS/Source/cosmos.asm           | run      | cosmosGri
 # osTakeScreen, which restores the screen as it was BEFORE the line was printed and so wiped
 # out the one thing it was pointing at. A program that damages nothing should not ask.
 cosmosFlip           | CosmOS/Source/cosmos.asm           | run      | cosmosFlip.in      | 60000000 | disks/cosmos.img
+# ---- A thing that moves without the screen moving ----
+#
+# Sprite draws a ball over the shell's own text and writes not one byte of the map to do it,
+# which is what a sprite is for. The picture is video.sh's business; what is checked here is
+# that the words either side of it are untouched - the line printed before it ran and the one
+# printed after are both still readable, because nothing underneath the ball was ever written.
+#
+# A KEYBOARD FIXTURE and not standard input, which is the difference between a test that
+# runs this program and one that only looks like it does. A null on standard input is a
+# character like any other, so the first of them satisfied the "has a key arrived" test and
+# the ball never moved at all - the whole 150 frames of it went past in the shell, reading a
+# line made of nulls. Through a keyboard a null is silence, which is what makes it a wait.
+cosmosSprite         | CosmOS/Source/cosmos.asm           | run      | -                  | 60000000 | disks/cosmos.img | cosmosSprite.keys
 # Which disk the registers mean. Several disks are one controller with a drive register
 # rather than several devices, because a port is an immediate byte inside the instruction
 # that names it and a program cannot compute one. Run with a single disk, so drive 1 is a