--- title: "Killer Robots" id: 57413 type: "computer_media" slug: "killer-robots" url: "http://localhost/computer_media/killer-robots/" markdown_url: "http://localhost/computer_media/killer-robots.md" published_at: "2024-10-05T12:48:36+00:00" modified_at: "2026-04-03T07:58:31+00:00" author: "David Anderson" featured_image: url: "http://localhost/wp-content/uploads/2024/10/214_Robo.png" excerpt: "Navigate a lethal maze while killer robots close in — one wrong step into an electric wall ends the game for you or, ideally, for them." category: - name: "Archived Media" slug: "archived-media" taxonomy: "category" url: "http://localhost/category/archived-media/" post_tag: - name: "Downloadable" slug: "downloadable" taxonomy: "post_tag" url: "http://localhost/tag/downloadable/" - name: "TS 1000" slug: "ts1000" taxonomy: "post_tag" url: "http://localhost/tag/ts1000/" model: - name: "Timex/Sinclair 1000" slug: "ts-1000" taxonomy: "model" url: "http://localhost/model/ts-1000/" indiv: - name: "David Ahl" slug: "ahl-david" taxonomy: "indiv" url: "http://localhost/indiv/ahl-david/" - name: "Tony Willing" slug: "tony-willing" taxonomy: "indiv" url: "http://localhost/indiv/tony-willing/" genre: - name: "Game" slug: "game" taxonomy: "genre" url: "http://localhost/type/game/" media_contents: - id: 56736 title: "Timex Sinclair Public Domain Library Tape 1005" type: "computer_media" url: "http://localhost/computer_media/timex-sinclair-public-domain-library-tape-1005/" media_type: "Program" programmers: - name: "David Ahl" slug: "ahl-david" taxonomy: "indiv" url: "http://localhost/indiv/ahl-david/" - name: "Tony Willing" slug: "tony-willing" taxonomy: "indiv" url: "http://localhost/indiv/tony-willing/" mediadate: "198x" images: - url: "http://localhost/wp-content/uploads/2024/10/214_Robo.png" media_type_tags: "Game" --- # Killer Robots Killer Robots is a text-based strategy game in which the player navigates a 10×20 grid maze, using numeric keypad-style movement (1–9) to lure pursuing robots into electrified walls marked with “X”. The maze is stored as two parallel 2D integer arrays — A() for the live game state and B() for a saved copy — allowing the same board layout to be replayed without regenerating it. Robot positions are tracked in arrays L() and M(), and each robot uses a sign-function intercept algorithm (SGN) to home in on the player one step at a time. The special moves include a random teleport (0), a no-move declaration (10), and suicide (-1); the computed GOTO at line 940 dispatches movement directions using a chain of Boolean-multiplied line numbers, a classic ZX81 idiom. An anomaly exists at lines 290–320 where N() is DIMensioned twice (first as N(12), then as N(Z)), with the second declaration silently replacing the first. *** ## Program Analysis ### Program Structure The program is divided into a clear sequence of phases: 1. **Title and instructions** (lines 0–230): Displays game rules and movement keys, waits for ENTER. 2. **Initialisation** (lines 260–760): Dimensions arrays, populates the maze with walls and characters, saves a snapshot of the initial state. 3. **Display loop** (lines 780–840): Prints the current 10×20 grid from array `A()`. 4. **Player input and movement** (lines 850–1210): Reads the move code, dispatches to the appropriate coordinate update. 5. **Robot intercept loop** (lines 1220–1470): Moves each robot one step toward the player. 6. **Win/lose detection and replay** (lines 1480–1800): Checks whether all robots have been destroyed; offers replay with the same or a new layout. ### Array Layout and State Management The maze is a 10-row by 20-column grid. Two parallel arrays store state: - `A(10,20)` — the live game array, holding character codes for space, `X`, `*`, or `+`. - `B(10,20)` — a snapshot of the initial maze and robot positions, used to restore the same layout on replay. Robot positions are also stored redundantly in `L(Z)` (row) and `M(Z)` (column), allowing the intercept subroutine to update coordinates without scanning the full grid. A further snapshot of only the first five robots’ positions is saved in `N()` and `O()` for replay purposes — though this only covers robots 1–5 regardless of `Z`. ### Notable Technique: Computed GOTO Line 940 implements direction dispatch using a chain of Boolean arithmetic expressions: `GOTO (1100 AND Y9=1)+(1080 AND Y9=2)+...+(1000 AND Y9=9)` On the ZX81/TS1000, a true Boolean comparison evaluates to 1 and false to 0, so exactly one term is non-zero and the sum gives the target line number directly. This avoids a cascade of `IF … THEN GOTO` statements and is a well-known space-saving idiom on this platform. ### Robot Movement Algorithm The intercept subroutine at lines 1230–1380 uses `SGN(J-X)` and `SGN(K-Y)` to compute a unit-step vector from each robot’s current position toward the player. This is a simple but effective Manhattan-direction chase: the robot moves diagonally, horizontally, or vertically by exactly one cell each turn. If the destination cell is occupied by a wall (`X`), the robot is destroyed in place (its source cell is cleared, and no `+` is written). If the destination holds the player (`*`), flag `G9` is set to 99 and the player is killed. ### Bugs and Anomalies | Location | Issue | | --- | --- | | Lines 290–320 | `DIM N(12)` is immediately superseded by `DIM N(Z)` three lines later. The first declaration is wasted; only `N(Z)` takes effect. This is likely a copy/paste remnant from the original BASIC. | | Lines 710–730 | The replay snapshot loop runs `FOR C=1 TO 5`, saving only the first five robot positions into `N()` and `O()` regardless of how many robots `Z` specifies. Replaying with more than five robots will restore only a partial set of positions. | | Lines 1740–1760 | The restore loop on replay also runs `FOR C=1 TO 5`, consistent with the snapshot but still silently ignoring robots 6 through `Z`. | | Line 1170 | The random leap places the player at any interior coordinate but does not check whether the destination cell is a wall or a robot; landing on a wall triggers the death message at line 1600 correctly, but landing on a robot cell is not explicitly handled before the move is committed. | | Lines 240–250 | The ENTER-to-begin wait loop polls `INKEY$` for a non-empty key rather than specifically checking for ENTER, so any key press advances past the instruction screen. | ### Key BASIC Idioms - `CODE (" ")`, `CODE ("X")`, `CODE ("*")`, `CODE ("+")` are used throughout instead of numeric literals, making the cell-content comparisons self-documenting and portable. - `SLOW` / `FAST` (lines 5 and 265) bracket the setup phase to improve display readability during the instruction screens. - The subroutine at lines 520–550 (`GOSUB 520`) finds a random empty interior cell by rejection sampling, retrying if the chosen cell is not a space. - Line 940 uses leading zeros in `0950` and `0980` — syntactically valid but unusual, likely preserved from the original David Ahl listing. ### Replay Mechanism When “SAME SET-UP?” is answered Y, the program restores `A()` from `B()`, restores the first five robot coordinates from `N()`/`O()`, and restores the player start position `J1`/`K1`, then jumps to line 770 to reset the no-move flag and redraw. A N answer triggers `RUN` at line 1685 which reinitialises everything from scratch including prompting for a new robot count. ## Source Code ``` 0 REM ROBO (KILLER ROBOTS) FROM DAVID AHL, BASIC COMPUTER GAMES CONVERTED TO SINCLAIR BASIC BY ANTHONY WILLING, WITH INSTRUCTIONS ADDED 3 CLS 5 SLOW 10 PRINT TAB 8;"%K%I%L%L%E%R% %R%O%B%O%T%S" 15 PRINT 20 PRINT 30 PRINT 40 PRINT "YOU ARE WITHIN A MAZE. THE WALLS ARE ELECTRICALLY CHARGED, AND THERE ARE MANY ROBOTS TRYINGTO DESTROY YOU." 50 PRINT 60 PRINT "THE ONLY CHANCE TO SURVIVE IS TOMANEUVER THE ROBOTS INTO THE WALLS." 70 PRINT 80 PRINT "YOU ARE THE ""*""" 90 PRINT "ROBOTS ARE THE ""+""S" 100 PRINT "THE WALLS ARE THE ""X""S" 110 PRINT AT 21,3;"(PRESS ENTER TO CONTINUE)" 120 PAUSE 4E4 130 CLS 140 PRINT "MOVES ARE 7.8.9" 150 PRINT " 4.%5.6" 160 PRINT " 1.2.3" 170 PRINT 180 PRINT "ENTER:" 190 PRINT "10 = NO MOVE FOR REST OF GAME" 200 PRINT "-1 = COMMIT SUICIDE--HOPELESS" 210 PRINT " 0 = A HUGE RANDOM LEAP" 213 PRINT 215 PRINT "HOW MANY ROBOTS (5-30)?" 217 INPUT Z 220 PRINT AT 21,4;"(PRESS ENTER TO BEGIN)" 230 PRINT AT 21,4;"(%P%R%E%S%S% %E%N%T%E%R% %T%O% %B%E%G%I%N)" 240 IF INKEY$<>"" THEN GOTO 260 250 GOTO 220 260 CLS 265 FAST 270 DIM A(10,20) 280 DIM B(10,20) 290 DIM N(12) 300 DIM L(Z) 310 DIM M(Z) 320 DIM N(Z) 330 DIM O(Z) 340 FOR B=1 TO 10 350 FOR C=1 TO 20 360 LET X=INT (1+10*RND) 370 IF X=5 THEN GOTO 400 380 LET A(B,C)=CODE (" ") 390 GOTO 410 400 LET A(B,C)=CODE ("X") 410 NEXT C 420 NEXT B 430 FOR D=1 TO 10 440 LET A(D,1)=CODE ("X") 450 LET A(D,20)=CODE ("X") 460 NEXT D 470 FOR F=1 TO 20 480 LET A(1,F)=CODE ("X") 490 LET A(10,F)=CODE ("X") 500 NEXT F 510 GOTO 560 520 LET H=INT (1+8*RND)+2 530 LET I=INT (1+18*RND)+2 540 IF A(H,I)<>CODE (" ") THEN GOTO 520 550 RETURN 560 GOSUB 520 570 LET A(H,I)=CODE ("*") 580 LET J=H 590 LET K=I 600 FOR N=1 TO Z 610 GOSUB 520 620 LET A(H,I)=CODE ("+") 630 LET L(N)=H 640 LET M(N)=I 650 NEXT N 660 FOR C=1 TO 10 670 FOR D=1 TO 20 680 LET B(C,D)=A(C,D) 690 NEXT D 700 NEXT C 710 FOR C=1 TO 5 720 LET N(C)=L(C) 730 LET O(C)=M(C) 740 NEXT C 750 LET J1=J 760 LET K1=K 770 LET Y9=0 780 CLS 781 FOR E=1 TO 10 790 FOR D=1 TO 20 800 LET N$=CHR$ (A(E,D)) 810 PRINT N$; 820 NEXT D 830 PRINT 840 NEXT E 850 IF Y9<>10 THEN GOTO 880 860 PRINT 870 GOTO 1180 880 INPUT Y9 890 LET J2=J 900 LET K2=K 910 IF Y9=0 THEN GOTO 1150 920 IF Y9<0 THEN GOTO 1570 930 IF Y9=10 THEN GOTO 1390 940 GOTO (1100 AND Y9=1)+(1080 AND Y9=2)+(1050 AND Y9=3)+(1130 AND Y9=4)+(1180 AND Y9=5)+(1030 AND Y9=6)+(0950 AND Y9=7)+(0980 AND Y9=8)+(1000 AND Y9=9) 950 LET J=J-1 960 LET K=K-1 970 GOTO 1180 980 LET J=J-1 990 GOTO 1180 1000 LET J=J-1 1010 LET K=K+1 1020 GOTO 1180 1030 LET K=K+1 1040 GOTO 1180 1050 LET J=J+1 1060 LET K=K+1 1070 GOTO 1180 1080 LET J=J+1 1090 GOTO 1180 1100 LET J=J+1 1110 LET K=K-1 1120 GOTO 1180 1130 LET K=K-1 1140 GOTO 1180 1150 PRINT "YOU JUMP..." 1160 LET J=INT (1+8*RND)+2 1170 LET K=INT (1+18*RND)+2 1180 IF A(J,K)=CODE ("X") THEN GOTO 1600 1190 LET A(J2,K2)=CODE (" ") 1200 LET A(J,K)=CODE ("*") 1210 GOTO 1390 1220 REM %I%N%T%E%R%C%E%P%T%O%R% %M%O%V%E%S 1230 IF A(X,Y)=CODE ("X") THEN GOTO 1360 1240 LET X2=X 1250 LET Y2=Y 1260 LET X=SGN (J-X) 1270 LET Y=SGN (K-Y) 1280 LET X=X+X2 1290 LET Y=Y+Y2 1300 IF A(X,Y)=CODE ("*") THEN GOTO 1370 1310 IF A(X,Y)=CODE (" ") THEN GOTO 1340 1320 LET A(X2,Y2)=CODE (" ") 1330 RETURN 1340 LET A(X,Y)=CODE ("+") 1350 LET A(X2,Y2)=CODE (" ") 1360 RETURN 1370 LET G9=99 1380 RETURN 1390 FOR N=1 TO Z 1400 LET X=L(N) 1410 LET Y=M(N) 1420 LET G9=0 1430 GOSUB 1230 1440 IF G9<>0 THEN GOTO 1580 1450 LET L(N)=X 1460 LET M(N)=Y 1470 NEXT N 1480 FOR N=1 TO Z 1490 IF A(L(N),M(N))<>CODE (" ") THEN GOTO 1510 1500 LET A(L(N),M(N))=CODE ("+") 1510 NEXT N 1520 FOR N=1 TO Z 1530 IF A(L(N),M(N))<>CODE ("X") THEN GOTO 780 1540 NEXT N 1550 PRINT "YOU DESTROYED ALL ROBOTS-YOU WIN" 1555 PRINT 1560 GOTO 1630 1570 PRINT "GIVE UP, EH??" 1580 PRINT "*****YOU HAVE BEEN KILLED*****" 1585 PRINT 1590 GOTO 1630 1600 PRINT "%H%I%G%H% %V%O%L%T%A%G%E" 1610 PRINT "ZAP...SIZZLE..YOU ARE DEAD" 1620 PRINT 1630 PRINT "ANOTHER GAME? (Y/N)" 1640 INPUT V$ 1650 IF V$<>"Y" THEN GOTO 5000 1660 PRINT "SAME SET-UP? (Y/N)" 1670 INPUT V$ 1680 IF V$<>"Y" THEN CLS 1685 IF V$<>"Y" THEN RUN 1690 FOR C=1 TO 10 1700 FOR D=1 TO 20 1710 LET A(C,D)=B(C,D) 1720 NEXT D 1730 NEXT C 1740 FOR C=1 TO 5 1750 LET L(C)=N(C) 1760 LET M(C)=O(C) 1770 NEXT C 1780 LET J=J1 1790 LET K=K1 1800 GOTO 770 5000 STOP 5020 SAVE "1021%4" 5030 RUN ```