Try these

“Try these” is a collection of seven independent graphical and utility demonstrations, each separated by STOP statements and REM labels. The first routine defines a UDG character “t” as a vertical line (DATA 24,24,24,24,24,24,24,24) using POKE into USR “t”. The drawing demo (lines 60–220) uses symmetrical PLOT and DRAW calls with random starting positions and bouncing velocity increments to produce a kaleidoscopic line pattern. Other segments include a growing circle using the CIRCLE command, a software clock displaying hours, minutes, seconds, and tenths, a polar coordinate plotter that converts angle and radius inputs to pixel coordinates via COS and SIN, and a “mish mash” routine that draws a hollow 4×4 block-character rectangle at random screen positions with random BORDER and INVERSE settings.

---

Program Structure

The listing is organized as a collection of seven independent routines, each terminated by a STOP statement followed by a REM comment naming the next section. To run any individual demo, the user must either delete the preceding STOP or GO TO the appropriate line number. The SAVE at line 1000 uses LINE 10 so the program auto-runs from the UDG initialization section on load.

Lines	Section
10–40	UDG “t” initialization (vertical bar sprite)
60–220	Bouncing symmetrical line art (“draw”)
240–300	Flashing “X” with increasing PAUSE
320–340	Misplaced UDG-U printer using TAB CODE INKEY$
360–390	Growing circle
400–510	Software clock (hours/minutes/seconds/tenths)
530–850	Polar coordinate axis and ray plotter
870–990	“Mish mash” random bordered rectangle display

UDG Initialization

Lines 10–40 define UDG character “t” by poking eight bytes (all 24, binary 00011000) into USR "t" through USR "t"+7. This produces a solid two-pixel-wide vertical stripe centered in the 8×8 cell. The UDG is later referenced as █[UDG-U] in the misplaced-character demo at line 330, though note the listing uses UDG-U rather than UDG-t, suggesting either a typo or a separate UDG slot.

Bouncing Symmetrical Line Art (Lines 60–220)

This section generates a symmetrical pattern by issuing two PLOT calls and two DRAW calls per iteration with swapped x/y arguments, creating four-way reflective symmetry around the screen center. Random velocity components e and m are initialized each pass through the outer loop (which has no explicit outer loop — positions are simply re-randomized at line 60 and the whole pattern runs from GO TO 100, meaning e and m persist between iterations after the first).

• Lines 160–190 clamp x and y to [0, 42].
• Lines 200–210 reverse the velocity when a boundary is reached, creating a bouncing effect.
• The DRAW targets 52-x, 42-y and 52-y, 42-x — these are relative, not absolute, so the symmetry is approximate rather than geometrically exact.

A subtle issue: lines 60–90 re-randomize e, m, x, and y only on the very first execution (before GO TO 100). Since GO TO 100 skips back past lines 60–90, the velocities and positions accumulate continuously — this is intentional, producing the bouncing trajectory.

Flashing “X” Demo (Lines 240–300)

A FOR loop from 1 to 100 prints “X” twice per iteration using alternating INK 0 (invisible) and default ink, with PAUSE a between each print. As a increases, the flash rate slows progressively, demonstrating a simple animation timing technique using the loop variable directly as the pause duration.

Misplaced Character Demo (Lines 320–340)

This section exploits TAB CODE INKEY$: the ASCII/character code of any pressed key is used as the TAB column position, so the UDG character is printed at a column determined by which key is held. Line 320 first executes POKE 23692,22 to suppress the “scroll?” prompt by resetting the line counter. The loop at line 340 uses GO TO 320, so the POKE is refreshed on every iteration. The conditional at line 330 prevents a print when no key is pressed.

Growing Circle (Lines 360–390)

A straightforward loop calling CIRCLE a,a,a for a from 0 to 88. Each iteration draws a circle whose center and radius all equal a, so the circles grow and shift diagonally across the screen simultaneously, producing a spiral-like accumulation of arcs.

Software Clock (Lines 400–510)

Four nested FOR loops simulate a clock: hours (0–24), minutes (0–59), seconds (0–59), and tenths (0–9). The display is updated each tenth-second tick via PRINT AT. Line 470 attempts to print a zero for tenths when t>9, but since the inner loop runs t from 0 to 9, t will equal 10 after NEXT t exits — this is correct BASIC behavior, so the zero-reset fires reliably. The “delay” loop at line 480 (FOR d=1 TO 7:NEXT d) is a minimal busy-wait intended to approximate a tenth of a second, though its actual duration depends on processor speed and display overhead. The label spells “MINITS” rather than “MINUTES” — a minor typo in the display string.

Polar Coordinate Plotter (Lines 530–850)

This is the most complex section, implementing an interactive polar-to-Cartesian ray plotter. The user inputs a starting coordinate (sx, sy), a radius r, and an angle theta in degrees. Line 740 converts theta to radians. The loop at lines 750–800 steps from 0 to INT(r+.4), computing pixel coordinates with offsets (32, 22) to center the origin on screen.

• Line 780 performs a bounds check: if y>175 or x>255, the input prompts are reset. Note the condition x>255 AND y>175 is redundant given the preceding OR clauses — it can never add new cases.
• Lines 630 and 660 use INT(sx+.4) and INT(sy+.4) for rounding input to the nearest integer.
• After plotting, lines 810–820 update sx and sy to the endpoint of the last ray, allowing chained ray drawing from successive inputs.
• The coordinate axis display at lines 530–600 uses dots printed at each column and row to indicate the x and y axes, with labeled endpoints.

“Mish Mash” Demo (Lines 870–990)

This routine uses a DIM a$(4,4) string array to store a 4×4 hollow rectangle pattern made of block graphic characters. Each iteration picks a random screen position (s column 0–28, t row 0–16), sets a random BORDER color, and prints each row with random INVERSE (0 or 1). Pressing “a” triggers STOP. A counter d is incremented each cycle but never displayed — it may be a leftover debugging variable.

Notable Techniques and Anomalies

• The use of STOP as a section delimiter rather than structuring demos as subroutines is unconventional but functional for a demo collection intended to be run in parts.
• The rounding idiom INT(x+.4) consistently approximates “round to nearest integer” throughout the polar plotter, though the standard rounding threshold would be +.5 — using +.4 biases slightly toward the floor.
• The flashing demo uses INK 0 to make text invisible rather than erasing it, which is a neat way to toggle visibility without clearing the screen position.
• The clock’s tenths loop produces values 0–9 then exits with t=10; the check IF t>9 at line 470 correctly catches this to display a zero, but the printed value is hardcoded as 0 rather than t MOD 10, which happens to be correct only because t always exits at exactly 10.