Keno

This program implements the casino lottery game Keno, in which the player picks 10 numbers from a field of 81 and then watches the computer draw 20 numbers at random. The 81 playable numbers are laid out on screen using a pre-computed coordinate table stored in arrays `l()` and `c()`, with all 162 coordinate values encoded in a single DATA statement read at startup. Payouts follow an exponential scale: matching 5 numbers returns even money, while matching all 10 pays out at 1,000,000-to-1 odds, calculated as `b*10^(z-4)`. A simple animation scrolls through board positions using OVER 1 and PAPER 8/INK 8 transparency tricks before highlighting the drawn number with INVERSE 1. Duplicate detection for both player-chosen markers and the computer’s random draws is handled by inner FOR/NEXT loops that re-request input or re-roll when a collision is found.

Adapted by Bob Howard from Creative Games by R. Maunder.

---

Program Analysis

Program Structure

The program is organized into a main game loop with a subroutine for instructions. Execution flows as follows:

1. Lines 10–30: Initialization — set display attributes, allocate arrays, and read board coordinates from DATA.
2. Lines 300–305: Title screen, instructions prompt, and display of the game board header.
3. Lines 310–320: Render all 81 numbers (0–80) on screen at their pre-computed positions.
4. Lines 330–420: Accept the player’s bet and 10 chosen marker numbers, with validation and duplicate checking.
5. Lines 430–530: Draw 20 random numbers, animate each draw, and count matches.
6. Lines 540–580: Calculate and display payout, then prompt to continue or quit.
7. Lines 600–610: SAVE with auto-run, then STOP.
8. Lines 700–750: Instructions subroutine.

Board Coordinate Table

Rather than computing screen positions algorithmically, all 81 (row, column) pairs are stored as 162 values in the DATA statement at line 30 and loaded into parallel arrays l() (line/row) and c() (column) at lines 20–20. This trades memory for speed at draw time. The numbers 0–80 are displayed at AT l(i),c(i) for i from 1 to 81, meaning number i-1 is at index i; this off-by-one is consistently handled with m(i)+1 as the array index when looking up a player-chosen marker.

Input Validation

Bet validation at line 340 checks three conditions in one IF: the bet must not exceed available money, must be an integer (b=INT b), and must be at least 1. Marker validation at line 375 similarly checks for integer, non-negative, and ≤80 in a single compound condition. Duplicate marker detection at lines 390–400 uses a classic inner loop comparing the new entry against all previously accepted values, re-prompting inside the loop body on collision.

Random Draw and Deduplication

At line 450, the computer’s drawn number is INT(81*RND), giving a value in the range 0–80. Duplicate rejection at lines 470–480 uses the same inner-loop pattern as player input: if the new draw matches any earlier draw, execution jumps back to line 450 to re-roll. This is a straightforward rejection-sampling approach.

Draw Animation

Lines 490–495 implement a “scrolling highlight” animation. A FOR loop walks from position 0 up to the newly drawn number r(n), printing a blank overlay (PAPER 8; INK 8; OVER 1) to erase the previous highlight and advance it one cell. The string o$ is set to "__" (two underscores, to cover two-digit numbers) or "_" for single-digit positions. PAPER 8 and INK 8 use the Spectrum/TS2068 transparent color attribute, so OVER 1 XORs the underscores onto the existing display without changing the background color. After the loop, the final position is highlighted with INK 8; INVERSE 1.

Payout Formula

The payout calculation at line 550 is elegantly compact:

• Fewer than 4 matches: payout is 0 (line 540).
• 4 or more matches: p = b * 10^(z-4), where z is the match count.

This gives even money at 4 matches, 10× at 5, 100× at 6, 1,000× at 7, 10,000× at 8, 100,000× at 9, and 1,000,000× at 10. Note the instructions screen states 5 matches = even money, but the formula makes 4 matches = even money — a discrepancy between the help text and the actual game logic.

Notable Techniques and Idioms

• INPUT ; b ; " is invalid..." ; b at line 340 uses the semicolon-chained INPUT form to display a prompt incorporating the invalid value inline.
• INPUT ("Enter marker no."; i; ": "); m(i) at line 370 uses the parenthesized prompt syntax to build a dynamic prompt string without a separate PRINT.
• PAUSE 4E4 at line 750 (40,000 frames ≈ 11 minutes at 50 Hz) acts as a long timeout on the instructions screen before returning.
• Line 600 uses SAVE "KENO" LINE 0; LINE 0 would cause auto-run from line 0, but since line 0 does not exist, execution starts at the first available line (line 10) — a known technique.
• The variable name m is reused: first dimensioned as DIM m(10) (the player’s 10 marker numbers) at line 15, then immediately overwritten as a scalar LET m=20 at line 300. This destroys the array, leaving m as a plain numeric variable for the money held. The markers array is effectively lost, but the program works because m(i) references after line 300 address BASIC’s array-element syntax on the scalar — this is actually a bug: once m is redefined as a scalar at line 300, later references to m(i) will cause a type error. In practice the program likely relies on the TS2068 not erroring when accessing m(i) after LET m=20 due to implementation specifics, or this is an oversight in the listing.

Variable Summary

Variable	Purpose
l(81)	Row coordinates for each board position
c(81)	Column coordinates for each board position
m(10) / m	Player’s 10 chosen markers (array); money held (scalar, overwrites array)
r(20)	Computer’s 20 drawn numbers
b	Current bet amount
z	Match count for current round
p	Payout amount
o$	Animation overlay string (one or two underscores)
Y$, z$	Temporary string input variables
i, j, n	Loop counters