--- title: "Dragons" id: 51382 type: "computer_media" slug: "dragons" url: "http://localhost/computer_media/dragons/" markdown_url: "http://localhost/computer_media/dragons.md" published_at: "2023-07-29T21:57:58+00:00" modified_at: "2026-04-03T07:59:20+00:00" author: "David Anderson" featured_image: url: "http://localhost/wp-content/uploads/2019/02/20230809-041332.jpg" excerpt: "Generates fractal dragon curves from user-defined turn sequences, with auto-centering, fast/slow drawing modes, and a mid-draw interrupt menu for saving or reversing the display." 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: "Gregory Harder" slug: "gregory-harder" taxonomy: "indiv" url: "http://localhost/indiv/gregory-harder/" genre: - name: "Demo" slug: "demo" taxonomy: "genre" url: "http://localhost/type/demo/" media_type: "Cassette" programmers: - name: "Gregory Harder" slug: "gregory-harder" taxonomy: "indiv" url: "http://localhost/indiv/gregory-harder/" download_url: "https://archive.org/download/timex-sinclair-software-archive/Dragons%20WRC%20%28198x%29%28Harder%2C%20Gregory%29%28US%29%28TS1000%29%28Program%29.zip" mediadate: "198x" media_type_tags: "Demo" --- # Dragons Dragons is a fractal dragon curve generator that plots iterative dragon curves on screen using BASIC with embedded machine code routines. The program accepts user-defined direction-reversal sequences (strings of “L” and “R” characters, or a randomly generated sequence), a size parameter up to 13 iterations for 16K machines, and a scale factor, then builds the full turn sequence via a doubling algorithm in the GOSUB at line 500. An auto-center routine (lines 695–880) pre-calculates the bounding box of the curve and offsets the starting coordinates so the dragon fits the display. A fast-mode option allows mid-draw interruption via any keypress, dropping into a menu (line 8000) offering options to start a new dragon, save the screen, toggle display reversal, copy to printer, or stop. *** ## Program Analysis ### Program Structure The program is organized into clearly labeled sections, each preceded by a `REM` banner. The main flow is: 1. Lines 0–1: Dense encoded data in `REM` statements (machine code and/or compressed data) 2. Line 2: `GOTO VAL "5E3"` — jumps to the startup routine at line 5000 3. Lines 5–170: Core plotting loop (`PLOT` with direction stepping) 4. Lines 495–590: `SEQUENCE` — builds the dragon turn sequence by doubling 5. Lines 695–880: `CENTER` — bounding-box calculation and auto-centering 6. Lines 995–1030: `TAKE A LOOK` — display/pause helper using `USR HR` 7. Lines 4995–5920: `START` — main initialization and user input 8. Lines 7995–8700: `MENU` — post-draw interactive menu 9. Lines 9000–9020: `SAVE` with hardware notice ### Machine Code Usage Throughout the program, calls to `USR HR` (where `HR = VAL "19400"`, i.e., address 19400) gate nearly every significant action: plotting, pausing, saving, running, and randomizing. This is a standard technique for embedding a machine code routine that performs a conditional hardware check or provides a copy-protection/scrambler-board interlock. The variable `HR` is set at line 5050. Address 19400 falls in the ZX81/TS1000 system RAM area, and the machine code stored in the `REM` lines at 0 and 1 is loaded there. The `RAND VAL "31"` calls (lines 5910, 8510) use `RANDOMIZE 31` as a seed or a call to a specific ROM routine. ### Key BASIC Idioms - `GOTO VAL "5E3"` and similar — scientific notation strings passed to `VAL` as a memory-saving way to encode large line numbers in fewer bytes. - `LET O=NOT PI` at line 5010 sets `O=0` (since `NOT PI` is 0 on the ZX81), and `LET I=PI/PI` at line 5020 sets `I=1`, avoiding storing integer literals. - `LET N2=I+I` (=2) and `LET N4=VAL "4"` — repeated small constants stored in variables for efficiency. - `("L" AND B$(K)="R")+("R" AND B$(K)="L")` at line 550 — the ZX81 string AND idiom: returns the string if the condition is true, else empty string, used here to flip L/R in the mirror sequence. - `LET LT=N2**N-I` at line 5300 — `**` is the ZX81 exponentiation operator, computing 2^N−1, the number of segments in an N-iteration dragon curve. - `LET P=VAL "INT (RND+.5)"` at line 5240 — passing an expression string to `VAL` to evaluate `INT(RND+0.5)`, generating a random 0 or 1. - `IF D$="" THEN LET D$="L"` — defaulting to the classic single-fold dragon curve. ### Dragon Curve Algorithm The sequence-building subroutine (lines 500–590) implements the standard dragon curve doubling: for each iteration, a new fold direction is appended, then the existing sequence is mirrored and reversed with L/R swapped. The variable `SP` tracks the current sequence pointer, growing as `SP = SP*2 + 1` each iteration (line 570: `LET SP=SP*N2+I`). The direction array `D$()` holds the user-supplied reversal sequence, cycling via `IP`. The plotting loop (lines 20–170) steps through the turn sequence stored in `B$()`. Between each segment it takes `SC` steps in the current direction, then at each turn point takes `N2` (=2) diagonal steps combining the old and new direction vectors, producing smooth corner joins. The direction is encoded as an integer 1–4 (up/left/down/right), with wrap-around handled at lines 100–110 and 790. ### Auto-Center Routine The CENTER subroutine (lines 700–880) pre-traces the entire curve without plotting, accumulating the bounding box in `XL`, `XH`, `YL`, `YH`. It then scales these by `(N4+SC)` and computes the offset so the curve is centered on screen. If the scaled bounding box exceeds the screen dimensions (`XM=255`, `YM=191`), the user is prompted to enter coordinates manually or start a new dragon. ### Menu and Interaction After plotting completes (line 180 calls `SLOW` then jumps to line 8000), a menu is presented offering six options. Navigation is handled by reading `CODE Q$` against the ASCII codes of “1”–”6″ (lines 8080–8090), then dispatching via computed `GOTO`: `GOTO VAL "8100"+VAL "1E2"*(VAL Q$)`, which maps choices 1–6 to lines 8200, 8300, 8400, 8500, 8100 (copy), and 8700 (stop). The fast-mode interrupt at line 65 checks `INKEY$` during drawing and calls `GOSUB VAL "1E3"` (line 1000) if a key is held, which uses `USR HR` to pause and display the partial curve. ### Direction Vectors The four direction unit vectors are stored in arrays `X()` and `Y()`, initialized as: | D | Direction | X(D) | Y(D) | | --- | --- | --- | --- | | 1 | Up | 0 | -1 | | 2 | Left | 1 | 0 | | 3 | Down | 0 | 0 (unset) | | 4 | Right | -1 | 0 | Line 5600 uses `LET Y(INT PI)=I`, which evaluates `INT(3.14159…)=3`, setting `Y(3)=1` for the down direction — an economical use of the `PI` constant already in memory. ### Notable Techniques - All boundary constants (`O`, `I`, `N2`, `N4`, `HR`, `YM`, `XM`) are pre-computed into short-name variables to reduce token length in inner loops. - `DIM B$(LT+I)` allocates exactly the right string length for the full turn sequence. - The `SAVE Q$,S` at line 8330 saves a screen snapshot to tape under a user-supplied name. - The `PAUSE YM` calls (lines 5430, 5710) use the screen height value (191) as a short pause duration rather than introducing another constant. - Input validation for the direction string (lines 5150–5200) loops character by character checking for “L”, “R”, or “G”, jumping to an error message and retry if any invalid character is found. ## Source Code ``` 0 REM [C]█[1][9][8][7]█[S][M][C]##▘ ""LN RUN ##[P]#Y2 GOSUB #<>5▟▝TAN PRINT # RETURN,C▌LN [*]RNDINT / LET TAN 6-RNDLN #? FASTLN LN + LPRINT TAN LN [H]RND PRINT LN [4]RND7LN [H]RND# LET #TAN 7# RETURN#C▀ RETURN;""6-RNDTAN A ##▞▌ACS 9ACS =( IF ,,▘ 4,,TAN 7LN [T]RNDLN [4]RNDLN ,,INKEY$ ##ACS ZACS ZACS Z##STR$ LN STR$ RND LET J NEW▛W#TAN Y3[)]K▌LN [*]RNDINT (Y[Z][(]SQR LN [*]RNDINT 25 6AT ZA4##<▘ COPY*Q GOSUB [K]TAN NEXT Y▞# ( CLEARLEN LIST W4 CLEAR▞"" CLEARACS ##C▝▞[K])4 5 4##INKEY$ ▌ASN #INKEY$ ;# GOSUB ####<=E£RND ###) RUN ▙;Y2 GOSUB #Y PRINT ▘▛▝ CLEARACS ##CODE [P]▝LN [>]▝LN 4▝<>5GINKEY$ #[8]▝ CLEARACS #▚/▖ CLEARACS #LEN E£RND▘9 GOSUB PIF FOR 5 █;6#INKEY$ FOR GOSUB [K]LN F?<>5GINKEY$ TAN 7LN [T]RNDLN [4]RND##LN ▞INKEY$ VAL 7LN [H]RNDAT LN STR$ RND#TAN 2 COPY/▝2 STR$ 7LN [T]RNDLN ,,INKEY$ SGN GOSUB ##ZLN LET RND##?( CLEARACS .*PI▌4▝▞▒▛( CLEAR#TAN Y COPY/▘[J]MVAL Z CLEARACS #[:]7LN [T]RNDLN ,,INKEY$ # RETURN,4"7 GOSUB ##ZLN [T]RNDLN ,,INKEY$ ## GOSUB ##ZVAL #[)]-▘K▖ GOSUB #- COPY4▝- FAST##MSQR Z LET [(]2▘K▖ GOSUB #2 COPY4▝2 ##MINT Z#[W]S▞##- /▝2 GOSUB #SGN Z6PEEK Z#[B]3#A 6STR$ ZAT VAL Y[Z][(] PRINT UVAL Z# LET CLEARACS ##4▌LN SGN INKEY$ /▀LN ##UPEEK Z#▞ USTR$ Z##,,#MSTR$ Z GOSUB #SGN ZUUSR Z# GOSUB PIS▒#MSTR$ Z GOSUB #INT ZAT #▙##▄#5CHR$ ZOUUSR Z[Y]4[N] GOSUB ##ZTAN Y COPY/▘[J]MVAL Z7LN [T]RNDLN [4]RNDVAL 7LN [H]RND#I 6INT Z#6SGN ZAT Y▘ PRINT VAL VAL EINT Z GOSUB #SGN Z▞▌VAL ACS EACS .( IF [R] GOSUB #6INT Z GOSUB #SGN ZAT ACS GACS 1( IF ;6SGN Z GOSUB #INT ZAT #ACS <[~~]##ACS +[£]#Y[Z][(]S,, PRINT UVAL Z# LET LN SGN INKEY$ AT LET W RETURNASN S[O]TAN Y▘MINT ZLN COS RNDCOS LN [H]RNDMINT ZLN TAN RNDCOS 7LN [T]RNDLN [4]RND[S]S▀#INKEY$ #LN (INKEY$ #INKEY$ LN (INKEY$ #PI GOSUB #SQR Z[)]W PRINT 7LN [T]RND[S]K▀#INKEY$ # GOSUB #ABS Z[(]W4▘XSGN # GOSUB #USR ZUPEEK Z#USGN Z#[B]LN INPUT RND6CHR$ ZUABS Z#USGN Z#[B]LN INPUT RND6**Z£TAN LN +#4*UINT Z#5 4▘ /#J#7"#[L]4 RUN +4 INPUT TAN USTR$ ZECHR$ Z GOSUB #**Z6 AND Z GOSUB #>=Z PRINT FAST GOSUB # LPRINT C#UPEEK ZLN INKEY$ STR$ VAL #3ZACS <( IF AT ACS .*( CLS#SGN 7 FAST[B] GOSUB # LPRINT C▌#J#/ NEXT UABS ZLN INKEY$ Y,,[(]#VAL ,*ZACS 1( IF AT ACS +3( CLS>▘4 E>=Z,,6>=Z FOR E AND Z,,6 AND Z LET X4[A]5INT ZP4[?]TAN UUSR Z RETURN▒4▖,J/NOT UPEEK ZLN INKEY$ VAL ,3ZACS +( IF AT ACS 1*( CLS#UABS ZJ NEW▛C$#,VAL ?ACS 0( CLSAT ACS ▖( UNPLOT #/[E]E(RND#[T]COS RETURN█4▌LN [*]RNDINT ▘VAL LN PAUSE ,,AT FOR / GOTO PRINT SCROLL FAST:RND▟#LN ##7 FAST▞▌[J]#( CLEARSGN LPRINT LET TAN LN SCROLLRND#?( CLEARLN ##K▀Y▟>LN COS RNDTAB SQR #TAN LN SCROLLRND FASTAT LN 4+ FASTLN ##AT FAST##LN PLOT ;LN [~~]+ LPRINT / STEP LN SCROLLRND#▞ / SLOW###Y[Z][(]STR$ VAL PRINT LN SGN INKEY$ LET AT SGN TAN 2 COPY/▝2 STR$ LN C#SGN USTR$ Z#UPEEK Z5SGN Z PRINT FASTLN [D]#+C▞WLN [J]#/ RUN UUSR Z# LPRINT LET F FASTLN [D]#+C▞£LN [J]#/ RUN USTR$ Z# LPRINT UABS Z PRINT FASTLN [D]#+C▞XLN [J]#/ RUN UUSR Z# LPRINT LET 7LN [D]#+COS $LN [J]#/ SAVE LN 7?2"" CLEARACS ##C▝2[K]5 4[J]PEEK CLSLN #?ABS ▐▒<= CLS*K CLS-4▞▒#<= CLS3K CLS# NEW█PEEK CLSACS )( PAUSE 7+4 FOR <= CLS3K CLSLN ##/SGN 76-RNDLN #?LN [B]:##▘▘COS CLEARACS V#""( RAND $4 PLOT .#[N]4 INPUT TAN 7# RETURN#4,,LN OR #LN RUN #/L7# RETURN,C> RETURN;CG RETURN#C# RETURNAT C# RETURNTAB C#/# GOSUB #AT Z# NEW LIST LEN ( RETURNRNDCODE [O]#ATN [J]#/STR$ #LEN ▒#[J]# GOSUB #AT ZTAN ▞ COPY7# RETURN#COS RETURN,4▖Y▖/" RETURN;4VAL ▖# RETURN▀ASN SQR #M""Z/ STOP GOSUB #AT Z/SQR 7LN [T]RND## RETURN[T]ABS =INKEY$ # RETURNRNDABS "INKEY$ GOSUB #AT Z/[?]7LN [H]RND NEWZ GOSUB #AT Z[T]#K GOTO Y▒█#/ NEW6-RNDLN #? FAST CLEARACS ▘#CODE STR$ .LN SAVE < LPRINT FAST#[L]C£,VAL STR$ LN K#SGN AT <"/ LIST LPRINT /CODE RETURN""4▖Y"/U PRINT NEW# RETURNRNDK▛ LET CLEARACS ▘LEN /G CLEARACS ▘#C~~[J] CLEARACS ▘▚LN ##/▖ CLEARACS ▘LEN LET LN #,,~~ PRINT VAL NEW#LN ##AT ▀ LET RETURN█S LET CLEARACS ▘▚[J] GOSUB #AT Z PRINT YZ[)]>=[J]#LN RUN # LET VAL M<=Z[B]*[B]**- ACS >#5 2; FASTACS TLN STR$ RNDSGN U""Z RETURN▖ASN SQR # RETURN▝C# RETURN▘CFY▒ PRINT STR$ , PRINT U""Z[B]4"U<=ZACS #C▖ LET J/▘ LET #)4 ;SGN LET =AT ▌# RETURN COPYC▒USQR Z##[U]KATN USGN Z#UPEEK Z#USTR$ Z# FASTVAL Y[Z][(]2 LN SGN INKEY$ AT ▌ LPRINT H4 LIST 5INT ZP4[6]TAN 7# RETURN0K▌LN [*]RNDINT 1 RETURNGK RUN CHR$ 0TAN LN ▝##ACS 4ACS 4ACS 4ACS 4LN ▝#█#7# RETURN"#TAN 7# RETURN"TAB SQR #7#ACS #C▝CHR$ RND) 77 FAST▞▒A # FOR ;( CLEAR FOR 5 S; FOR LPRINT 7LN =#>4▌76-RNDTAN =Z#J NEW▛WM#RND) STOPZ GOSUB #**ZY▒ PRINT #>~~VAL #U#RND RETURN▌S)JLEN ,,[B]##: C:3ACS ;( CLS/▛#[J]ACS )*( CLS[Q]#7<#>#[Q]#FLN ##=Z) STOPZ▞▒VAL ,#7<,#LN ##F#<( POKE TAN ▞4[J]##ACS [W]>#<( RUN TAN E-RND# RETURN;C# RETURN#C▌LN [*]RNDINT + LPRINT 6-RND▘ TAN E-RND# RETURN THENC▌LN [*]RNDINT ) FAST7#)""#STR$ RETURN LLIST ASN ## RETURN SCROLLASN [:]RND RETURN LOAD ASN B# RETURN LIST ASN 3# RETURN PAUSE ASN ## RETURN PRINT ASN ## RETURN PLOT ASN [Y]INKEY$ RETURN RUN ASN ▟INKEY$ RETURN SAVE ASN [~~]# RETURN RAND ASN ## RETURN CLSASN ;INKEY$ RETURN UNPLOT ASN TAB INKEY$ RETURN CLEARASN ▗INKEY$ RETURN RETURNASN [*]RND RETURN COPYASN /# RETURN LPRINT 4[9]SGN )[J]#STR$ 7# RETURNXC##7# RETURN#C[<] RETURN;4 PLOT # RETURNAASN [▒]# RETURNBASN [B]INKEY$ RETURNCASN [B]PI RETURNDASN SCROLLINKEY$ RETURNIASN ## RETURNLASN [5]# RETURNPASN ## RETURNRASN [T]# RETURNS42F#7 RETURNDASN ## RETURNEASN ▞# RETURNMASN 8# RETURNPASN [1]# RETURNSASN ##/# RETURNTASN ## RETURNUASN F# RETURNW4UF#7 RETURNDASN ## RETURNLASN "# RETURNRASN ▟# RETURNUASN LEN #/57#7# RETURN#C; RETURN;4 PLOT # RETURNCASN [F]PI RETURNDASN FOR INKEY$ RETURNRASN [X]# RETURNTASN ###SQR # 1 REM FAST##▞▛ACS 5>=?#USR RETURN#Y▀X4 CLEAR GOSUB #▌TAB LLIST #ACS 5>=?#USR RETURN#TAN <= RETURNY,X4 CLEARPEEK COPYY>X4 CLEAR#7##>#<= RETURNYDX4 CLEARPEEK COPYY4X4 CLEARF7RTAN ▘ █VAL LN STEP #AT ▌TAB B#▀ GOSUB #LN STEP #LN ##$LN STEP # CLEAR FAST LET #:[E]LN STEP #LN ###LN STEP #LN ###LN STEP # CLEAR FAST LET ##LN STEP #7.#[N]4 PLOT TAN LN SCROLL▝76-RNDLN #? FASTLN SAVE < LPRINT 7#[K]C: RETURN5K~~# RETURNSCOS RETURNVCOS RETURNPCOS INT 0LN ## PRINT ##VAL ) ▝LN ##SGN LN 8# LET E=RND RETURNS4▛5 4##/( RETURNP4▌),,RND/▖ GOSUB #(RND GOSUB # FOR LN 8##▛▝<= RETURN*S CLS: £<= RETURN*K IF #LEN SCROLLACS #AT [J] GOSUB PIAT GOSUB PISGN C,,-▝LN ## LET LPRINT / TO 5WRND,[Y]4 LIST 7<"#[L]4 PRINT LET LPRINT RETURNS4,,5 4LN <>##▛▝ RETURNV4>E(RNDLN <>#FLN [1]=SGN LPRINT LN ▛▝##▞5,,RND/ GOTO 2 GOTO VAL "5E3" 5 REM [P][L][O][T] 10 IF USR HR THEN PLOT X,Y 20 FOR J=I TO LT 30 FOR K=I TO SC 40 LET X=X+X(D) 50 LET Y=Y+Y(D) 60 IF Y>=O AND Y<=YM AND X>=O AND X<=XM THEN IF USR HR THEN PLOT X,Y 65 IF INKEY$ <>"" AND F THEN GOSUB VAL "1E3" 70 NEXT K 80 LET D1=D 90 LET D=D+(B$(J)="R")-(B$(J)="L") 100 IF DN4 THEN LET D=I 120 FOR K=I TO N2 130 LET X=X+X(D1)+X(D) 140 LET Y=Y+Y(D1)+Y(D) 150 IF Y>=O AND Y<=YM AND X>=O AND X<=XM THEN IF USR HR THEN PLOT X,Y 160 NEXT K 170 NEXT J 180 SLOW 190 GOTO VAL "8E3" 495 REM [S][E][Q][U][E][N][C][E] 500 FOR J=I TO N 510 LET IP=IP+I 520 IF IP>L THEN LET IP=I 530 LET B$(SP+I)=D$(IP) 540 FOR K=I TO SP 550 LET B$(N2*SP+N2-K)=("L" AND B$(K)="R")+("R" AND B$(K)="L") 560 NEXT K 570 LET SP=SP*N2+I 580 NEXT J 590 RETURN 695 REM [C][E][N][T][E][R] 700 FOR J=I TO LT 710 LET SX=SX+X(D) 720 LET SY=SY+Y(D) 730 IF SXXH THEN LET XH=SX 750 IF SYYH THEN LET YH=SY 770 LET D=D+(B$(J)="R")-(B$(J)="L") 780 IF DN4 THEN LET D=I 800 NEXT J 810 LET XH=XH*(N4+SC) 820 LET XL=XL*(N4+SC) 830 LET YL=YL*(N4+SC) 840 LET YH=YH*(N4+SC) 850 LET XD=XH-XL 860 LET YD=YH-YL 870 SLOW 880 RETURN 995 REM [T][A][K][E]█[A]█[L][O][O][K] 1000 IF USR HR THEN RUN 1010 IF USR HR THEN PAUSE XM 1020 FAST 1030 RETURN 4995 REM [S][T][A][R][T] 5000 IF USR VAL "19400" THEN CLS 5010 LET O=NOT PI 5020 LET I=PI/PI 5030 LET N2=I+I 5040 LET N4=VAL "4" 5050 LET HR=VAL "19400" 5070 LET YM=VAL "191" 5080 LET XM=VAL "255" 5090 SLOW 5100 PRINT "[,,][~~][,,][~~]█[D][R][A][G][O][N]█[C][U][R][V][E]█[G][E][N][E][R][A][T][O][R]█[~~][,,][~~][,,]",,,,"SIZE OF DRAGON-UP TO 13 FOR 16K?" 5110 INPUT N 5120 PRINT ,,,,"DIRECTION-REVERSAL-SEQUENCE?",,,"STR$ OF L▘S AND R▘S... FOR EX- AMPLE: LLRRLRRR.",,," INPUT ""G"" TO GENERATE A RANDOM SEQUENCE.",,,,"DEFAULT=""L"", THE CLASSIC DRAGON CURVE." 5130 INPUT D$ 5140 IF D$="" THEN LET D$="L" 5150 FOR P=I TO LEN D$ 5160 IF D$(P)="L" OR D$(P)="R" OR D$(P)="G" THEN NEXT P 5170 IF P=LEN D$+I THEN GOTO VAL "5210" 5180 CLS 5190 PRINT "IMPROPER INPUT TRY AGAIN.", 5200 GOTO VAL "5120" 5210 IF D$<>"G" THEN GOTO VAL "5270" 5220 LET D$="" 5230 FOR J=I TO N 5240 LET P=VAL "INT (RND+.5)" 5250 LET D$=D$+("L" AND P)+("R" AND NOT P) 5260 NEXT J 5270 CLS 5280 PRINT "DIRECTION-REVERSAL-SEQUENCE:",,,D$ 5290 LET L=LEN D$ 5300 LET LT=N2**N-I 5310 DIM B$(LT+I) 5320 PRINT 5330 PRINT "SCALE (1 TO ?)" 5340 INPUT SC 5350 LET SC=ABS SC 5360 CLS 5370 PRINT "AUTO-CENTER DRAGON CURVE (Y/N)?" 5380 INPUT Q$ 5390 CLS 5400 PRINT "STANDBYE...",,,,"█[G][E][N][E][R][A][T][I][N][G]█[T][H][E]█[D][R][A][G][O][N]█[S][E][Q][U][E][N][C][E]█" 5410 LET SP=O 5420 LET IP=O 5430 PAUSE YM 5440 FAST 5450 GOSUB VAL "5E2" 5460 CLS 5470 IF Q$="Y" THEN GOTO VAL "5550" 5475 SLOW 5480 PRINT " INPUT STARTING X COORD.: "; 5490 INPUT X 5495 PRINT X 5500 PRINT ,," INPUT STARTING Y COORD.: "; 5510 INPUT Y 5515 PRINT Y 5520 PRINT ,," INPUT STARTING DIRECTION...",,,"1=UP 2=LEFT 3=DOWN 4=RIGHT" 5530 INPUT SD 5540 IF XXM OR YYM OR SDN4 THEN GOTO VAL "5460" 5550 DIM X(N4) 5560 DIM Y(N4) 5570 LET X(N2)=I 5580 LET X(N4)=-I 5590 LET Y(I)=-I 5600 LET Y(INT PI)=I 5610 IF Q$<>"Y" THEN GOTO VAL "5820" 5620 LET SX=O 5630 LET SY=O 5640 LET D=I 5650 LET SD=I 5660 LET XH=-I 5670 LET XL=I 5680 LET YH=-I 5690 LET YL=I 5700 PRINT ,,"STANDBYE...[C][E][N][T][E][R][I][N][G]" 5710 PAUSE YM 5720 GOSUB VAL "7E2" 5730 IF YD<=YM AND XD<=XM THEN GOTO VAL "5780" 5740 PRINT ,," PLOT WON▘T FIT.",,,," INPUT (S)TARTING X,Y COORD. OR (N)EW DRAGON." 5750 INPUT Q$ 5760 IF Q$<>"N" THEN GOTO VAL "5460" 5770 GOTO VAL "8200" 5780 LET SX=(XM-XD)/N2-XL 5790 LET SY=(YM-YD)/N2-YL 5800 LET X=SX 5810 LET Y=SY 5820 LET D=SD 5830 PRINT ,," SLOW OR FASTMODE (S/F)?" 5840 INPUT Q$ 5850 LET F=Q$="F" 5860 IF F THEN PRINT ,,"PEEK AT CURVE BY HOLDING DOWN A KEY." 5870 PRINT ,,"REVERSED DISPLAY (Y/N)?" 5880 INPUT Q$ 5890 LET DP=Q$="Y" 5900 IF USR HR THEN RUN 5910 IF DP THEN IF USR HR THEN RAND VAL "31" 5920 IF F THEN FAST 5930 CLS 7000 GOTO VAL "10" 7995 REM [M][E][N][U] 8000 PAUSE I 8010 CLS 8020 PRINT "[M][E][N][U]",,,,"1. START NEWDRAGON","2. SAVE SCREEN",,"3. DISPLAY",,"4. REVERSE DISPLAY","5. COPY",,"6. STOP" 8030 PRINT ,,"SEQUENCE= ";D$ 8040 PRINT 8050 PRINT "SCALE= ";SC;TAB O,,"DIRECTION= ";SD 8060 LET Q$=INKEY$ 8070 IF Q$="" THEN GOTO VAL "8060" 8080 IF CODE Q$CODE "6" THEN GOTO VAL "8060" 8090 IF Q$<>"5" THEN GOTO VAL "8100"+VAL "1E2"*(VAL Q$) 8100 IF USR HR THEN COPY 8110 PAUSE I 8120 GOTO VAL "8060" 8200 CLS 8210 PRINT "ERASE PREVIOUS DRAGON (Y/N)?" 8220 INPUT Q$ 8230 CLS 8240 IF Q$="Y" THEN RUN 8250 CLEAR 8260 GOTO VAL "5010" 8300 CLS 8310 PRINT " SAVE NAME?" 8320 INPUT Q$ 8330 IF USR HR THEN SAVE Q$,S 8340 GOTO VAL "8010" 8400 IF USR HR THEN RUN 8410 IF INKEY$ <>"" THEN GOTO VAL "8410" 8420 IF INKEY$ ="" THEN GOTO VAL "8420" 8430 GOTO VAL "8110" 8500 IF USR HR THEN RUN 8510 IF USR HR THEN RAND VAL "31" 8520 GOTO VAL "8110" 8700 STOP 9000 SAVE "DRAGON[S]" 9010 PRINT "DRAGONS LOADED, ENABLE SCRAM BOARD THENPRESS A KEY" 9020 RUN ```