Let a program say what part of a sprite collides

`SPRHIT n, kind [,x1, y1, x2, y2]` gives a sprite a collision shape: a box, a
circle inscribed in it, or a capsule. `RSPHIT(n, f)` reads it back in SPRHIT's
own argument order, the way RSPRITE and RSPPOS already do, and needs no device
because it answers from interpreter state.

The rectangle is two corners measured from the sprite's top-left, in device
pixels -- the same `x1, y1, x2, y2` that `BOX` and `SSHAPE` take. A dialect with
two spellings for a rectangle is one nobody can write from memory. Omit it and
the shape fits whatever the picture turned out to be, which is what a sprite
loaded from a file needs: `SPRSAV "ship.png", 1` takes the image's own size and
the program never learns what that was.

**A sprite nobody has shaped collides with its whole frame, expansion bits
included, exactly as before.** That is a promise rather than a convenience, and
it has its own test: the same two sprites in the same two places, once with no
SPRHIT and once with a four-pixel box, reporting a collision and then not.

Named SPRHIT rather than SPRSHAPE because "shape" already means "a region SSHAPE
saved" in this dialect, in this very chapter -- `SPRSAV A$, 1` takes one -- and a
reader who typed `SPRSHAPE A$, 1` would have had every reason to. Both names, and
RSPHIT, were grepped against every label in docs/, examples/ and both corpora
first: a bare word is a label here, so a verb and a label share one namespace and
taking a name a checked-in listing already uses would break it silently.

`SPRHIT n, 0` takes a sprite out of collision while leaving it on the screen --
the ghost, the flashing invulnerable player, the pickup already taken. Hiding it
with `SPRITE n, 0` stops it colliding too, and is what you want when it should
not be seen either.

The circle answers the complaint chapter 8 already ships a figure of. That figure
shows two discs whose *boxes* touch at a corner while the artwork is nowhere
near, and `BUMP(1)` reporting a collision; two `SPRHIT n, 2` and it stops. The
test asserts both halves so the figure's caption stays true.

`tests/verbs_table.c` caught RSPHIT filed after RSPPOS rather than before it,
which is the sorted-table test doing exactly the job it exists for.

Docs: a new section in chapter 8, rows in the verb and function references in
alphabetical order, and chapter 13's "collision is by bounding box" becomes
"collision is by shape" with the addition named. 111 with akgl, 110 without, and
the artwork breakout still runs clean.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EwxGB6TdoVvZ11KQQME9cL

tests/akgl_backends.c

@@ -760,6 +760,90 @@ static akerr_ErrorContext AKERR_NOIGNORE *test_collision_cross_shape(void)
     SUCCEED_RETURN(errctx);
 }
 
+/** @brief The 24x21 pattern program the shape cases share, with @p tail appended. */
+static akerr_ErrorContext AKERR_NOIGNORE *two_sprites(const char *tail, uint16_t *dest)
+{
+    PREPARE_ERROR(errctx);
+    char source[2048];
+
+    snprintf(source, sizeof(source),
+	     "10 DIM P#(63)\n"
+	     "20 FOR I# = 0 TO 62\n"
+	     "30   P#(I#) = 255\n"
+	     "40 NEXT I#\n"
+	     "50 SPRSAV P#, 1\n"
+	     "60 SPRSAV P#, 2\n"
+	     "70 SPRITE 1, 1\n"
+	     "80 SPRITE 2, 1\n"
+	     "%s", tail);
+    PASS(errctx, mask_for(source, dest));
+    SUCCEED_RETURN(errctx);
+}
+
+/**
+ * @brief SPRHIT narrows what a sprite collides with, and the default is the frame.
+ *
+ * The first case is the one that matters most and the reason this whole change
+ * could be made at all: **a program that never says SPRHIT must behave exactly as
+ * it did.** Everything else here is new surface; that one is a promise.
+ */
+static akerr_ErrorContext AKERR_NOIGNORE *test_sprite_shapes(void)
+{
+    PREPARE_ERROR(errctx);
+    uint16_t mask = 0;
+
+    /* Two 24x21 frames, ten pixels apart: overlapping, as they always were. */
+    PASS(errctx, two_sprites("90 MOVSPR 1, 10, 10\n"
+			     "100 MOVSPR 2, 20, 20\n", &mask));
+    TEST_REQUIRE_INT(mask, 0x03);
+    stop_runtime();
+
+    /*
+     * A box in the top-left corner of sprite 1 only, four pixels square. Sprite
+     * 2's frame starts at 20 and the shape ends at 14, so they no longer meet --
+     * with both sprites in exactly the places the case above had them.
+     */
+    PASS(errctx, two_sprites("85 SPRHIT 1, 1, 0, 0, 4, 4\n"
+			     "90 MOVSPR 1, 10, 10\n"
+			     "100 MOVSPR 2, 20, 20\n", &mask));
+    TEST_REQUIRE_INT(mask, 0);
+    stop_runtime();
+
+    /* And the shape is offset from the sprite, so moving the sprite moves it. */
+    PASS(errctx, two_sprites("85 SPRHIT 1, 1, 0, 0, 4, 4\n"
+			     "90 MOVSPR 1, 18, 18\n"
+			     "100 MOVSPR 2, 20, 20\n", &mask));
+    TEST_REQUIRE_INT(mask, 0x03);
+    stop_runtime();
+
+    /* Kind 0 takes a sprite out of collision while leaving it on the screen. */
+    PASS(errctx, two_sprites("85 SPRHIT 1, 0\n"
+			     "90 MOVSPR 1, 10, 10\n"
+			     "100 MOVSPR 2, 10, 10\n", &mask));
+    TEST_REQUIRE_INT(mask, 0);
+    stop_runtime();
+
+    /*
+     * A circle is inscribed in the frame, so two frames touching at their
+     * corners -- which is the false positive docs/08-sprites.md ships a figure
+     * of -- stop colliding when both become circles. This is the case that
+     * figure exists to complain about.
+     */
+    PASS(errctx, two_sprites("90 MOVSPR 1, 0, 0\n"
+			     "100 MOVSPR 2, 23, 20\n", &mask));
+    TEST_REQUIRE_INT(mask, 0x03);
+    stop_runtime();
+
+    PASS(errctx, two_sprites("85 SPRHIT 1, 2\n"
+			     "86 SPRHIT 2, 2\n"
+			     "90 MOVSPR 1, 0, 0\n"
+			     "100 MOVSPR 2, 23, 20\n", &mask));
+    TEST_REQUIRE_INT(mask, 0);
+    stop_runtime();
+
+    SUCCEED_RETURN(errctx);
+}
+
 int main(void)
 {
     PREPARE_ERROR(errctx);
@@ -828,6 +912,7 @@ int main(void)
 	CATCH(errctx, test_sprite_from_shape());
 	CATCH(errctx, test_collision_pairs());
 	CATCH(errctx, test_collision_cross_shape());
+	CATCH(errctx, test_sprite_shapes());
     } CLEANUP {
 	if ( font != NULL ) {
 	    TTF_CloseFont(font);