FILL

This program implements a pixel-level flood-fill routine for the 256×176 pixel graphics area. A crosshair pointer is moved around the screen using the 5–8 cursor keys, and pressing F triggers a subroutine that fills the enclosed area containing the pointer’s location. The fill algorithm works by first walking outward along a vertical column to find the top and bottom boundary pixels, then scanning horizontally row by row to paint unset pixels, and separately handling four corner regions (top-right, top-left, bottom-right, bottom-left) that extend beyond the central column. Line 1010 pre-loads subroutine entry points into variables so that GO TO statements can target symbolic labels rather than hard-coded line numbers. A sample pattern is drawn using PLOT and DRAW with arc segments (lines 120–140) to create a web of intersecting curved lines that define closed regions suitable for filling.

---

Program Analysis

Program Structure

The program is divided into four logical sections:

1. Lines 10–80: Introduction screen — displays instructions and waits for a keypress.
2. Lines 100–140: Sample pattern generator — draws a series of intersecting arcs using PLOT/DRAW to create closed regions to fill.
3. Lines 500–630: Pointer movement and selection loop — moves a pixel cursor and waits for the F key to trigger the fill.
4. Lines 1000–1510: The fill subroutine itself, entered via GO SUB fill.

Pattern Generation

Lines 120–140 loop p from 0 to 255 in steps of 51, using DRAW with a third argument (the arc angle in radians) to produce curved lines. Each iteration plots two arcs from the same starting pixel, creating a symmetrical web of intersecting curves that enclose distinct regions suitable for flood-filling. Six iterations produce a visually rich pattern without any bitmap data.

Pointer Movement Loop

The pointer is represented by a single pixel toggled with PLOT OVER 1 — XOR-plotting — so the pixel can be shown and hidden without corrupting underlying graphics. Variables x and y track the pointer coordinates. Lines 570–600 use a compact Sinclair BASIC idiom where boolean expressions (INKEY$="8" etc.) evaluate to 1 or 0, allowing a single arithmetic expression to handle four-directional movement. Boundary wrapping at lines 580 and 600 uses the same trick to keep coordinates in range. Line 550 polls INKEY$ in a tight loop and line 560 erases the old pixel before movement — a standard PAUSE 0 / INKEY$ idiom adapted without PAUSE 0, instead looping on empty INKEY$.

Symbolic Line-Number Variables

Line 1010 pre-assigns a large set of variables whose names match subroutine labels (e.g., fillright, toppoint, loopbotleft) to the actual line numbers of corresponding REM statements. Line 1020 assigns select, fill, move, and wait near the top of the program (line 20). This allows GO TO toppoint, GO TO fillright, etc., to be written symbolically. The approach is a well-known memory and maintainability technique in Sinclair BASIC: VAL is not needed here because the variable itself holds the numeric line number directly.

Fill Algorithm

The fill subroutine uses a custom scanline-style approach rather than a recursive flood fill. It operates in several stages:

• Vertical scan (lines 1030–1060): Starting from the pointer’s Y coordinate, a walks upward and b walks downward using POINT to find the top and bottom boundary pixels of the enclosed area along column x.
• Corner extent detection (lines 1070–1140): Four variables (cmax, cmin, dmax, dmin) are walked outward from x to find how far the enclosed region extends horizontally at the top and bottom edges.
• Main horizontal fill (lines 1160–1230): For each row between b+2 and a-2, xmax and xmin walk right and left from x, plotting unset pixels until a boundary is hit.
• Corner fills (lines 1250–1510): Four separate loops handle the top-right, top-left, bottom-right, and bottom-left corner regions, each walking vertically outward from the boundary row.

Notable Techniques

• PLOT OVER 1 is used for the cursor pixel so it can be toggled without corrupting the underlying pattern.
• All inner loops use GO TO with symbolic variables rather than FOR/NEXT, which is faster for tight pixel-scanning loops in Sinclair BASIC.
• The POINT function is used extensively as a boundary detector — the fill stops when it encounters a set pixel, making the algorithm implicitly shape-agnostic.
• Early exit conditions (e.g., IF cmax=x+1 THEN GO TO filltopleft at line 1250) skip corner-fill phases when no corner extent exists, avoiding unnecessary work.

Bugs and Anomalies

• Lines 570–600 read INKEY$ multiple times in sequence. Because each read samples the keyboard independently, rapidly pressed or released keys may cause only some of the four direction checks to fire correctly in a single pass, though in practice this is rarely noticeable.
• The fill algorithm assumes the pointer is placed strictly inside a closed boundary. If the pointer is on or near a boundary pixel, or if the shape is not truly closed, the boundary-walking loops have no guard against running off-screen, which could cause erratic behavior or an infinite loop.
• Line 1220 has a comment “fill toleft” (missing space), a minor typographical error in the source.
• The variable name filleft at line 1010 appears to be a typo for fillleft (or fillleft), though it is consistent with its usage at line 1220 (GO TO filleft), so no actual bug results.

Variable Summary

Variable	Role
fill, wait, move, select	Line-number aliases for major GO TO targets
x, y	Current pointer pixel coordinates
a, b	Top and bottom boundary Y coordinates on column x
cmax, cmin	Rightmost/leftmost X extent at top boundary
dmax, dmin	Rightmost/leftmost X extent at bottom boundary
xmax, xmin	Horizontal fill extents for main body scanlines
ymax, ymin	Vertical fill extents for corner region scanlines
n	Loop counter for row/column iteration
p	Pattern generation loop counter