
ANDROMEDA 3
by Graeme Poole
from ZX Collection, Winter 1984

If you think that you're the adventurous type,
just have a go at escaping from Andromeda 3!

[I added a bit of code at line 9500 to include a display of the exits]
[from each location, as they're not always given in the descriptions.]
[JimG                                                                ]

The time is 12:15 am in the year 3058 AD. You were on a routine flight
to all of the major planets in the Solar System. Suddenly, out of
nowhere, appeared five Space Fighters from Andromeda 3. Unfortunately
your instruments did not register them and you were taken completely
by surprise.

The fighters launched a full scale attack on your ship (for no
apparent reason) and your shipped was crippled beyond normal flight.
You did, however, have enough of the basic controls left working so
that you could crash land your spaceship on the vast planet of
Andromeda 3. Your ship was completely destroyed but you managed to
escape, alive and without injury.

By this time, the Andromedan fighters had landed and the pilots took
you to the leader of the planet. Before you had a chance to speak, the
pilots explained to the leader that you had launched the attack on
THEM. You of course denied this, but unfortunately, the leader did not
believe you. He ordered you to be taken into the depths of the planet,
where prisoners are left to rot in a large underground prison.

It is here in this prison cell that you are now sitting; you must try
to escape alive and report back to Earth notifying them of the
situation. This is of the utmost importance: you have heard two guards
talking in the guardroom, saying that the leader was going to report
the 'incident' to Earth and that full scale war was to be launched
between the two planets.

So you can see that the entire future of Earth depends on you... Good Luck!

Playing the Game

You move around the prison by choosing the direction you wish to go.
There are 10 possible directions you can try. They are as follows: N,
NE, E, SE, S, SW, W, NW, U and D. As you move around, you will be
given a description of your location along with a picture of what you
can see. On your travels you will find various objects in certain
rooms and you can either TAKE or GET these.

There are 28 different instructions you can use to talk to the
computer. They are: N, NE, E, SE, S, SW, W, NW, U, D, LIGHT, UNLOCK,
USE, OPEN, CROSS, JUMP, GET, TAKE, BRIBE, GIVE, LIST, SWIM, FEED,
FIRE, PUT, SHOOT, SHOW and EAT. There are 2 commands which will
probably be very useful to you, these are LIST and Z. If you type
LIST, you will be given a complete list of the objects you are
carrying, if you have any. Typing Z (the key with COPY on it) the
computer will copy the screen to the printer which you can then use to
create a map as you go along. This saves a lot of time if you want a
map with the pictures and detailed descriptions.

The program, unlike other adventures, does not restrict you to using
only two words like GET TORCH etc, but will allow a fair amount of
different variations of one sentence to make it more "human" and
friendly. For example, all the following sentences will result in the
same command being executed: JUMP PIT, JUMP THE PIT, JUMP OVER PIT,
JUMP OVER THE PIT, JUMP ACROSS THE PIT etc. There is only one location
in which you can be killed, and you are given plenty of warning about
this, so that you will not have to restart every 30 seconds or so.
There are over 70 locations to explore, but you may not have to
explore them all to escape from the prison, but then again you might.
There are lots of one way passages making the game more difficult, and
also beware of the twisting paths which can take you from one side of
the prison to the other in one move which can be very annoying.

The Program

The user defined graphics and all the variables used in the program
are created in lines 20 to 50. Lines 100 to 3650 contain all the
information for the 72 locations along with some special variables to
tell the computer where you are and what to do depending on what you
type in.

The main part of the program is from lines 9500 to 9930. This checks
the input and moves you from room to room or carries out specific
instructions like OPEN DOOR. It also checks that you have taken an
object before you try to use it, and if you try to take an object it
checks to see if the object is in the room. Most of the computer's
replies are held in lines 3700 to 4500 and each one is printed
depending on where you are and what you asked the computer to do.

Each of the room descriptions has a string variable called r$. This
string is used to hold the line numbers of the rooms in the 10
possible directions, and they are held in the order N, NE, E, SE, S,
SW, W, NW, U, D. For example, if r$="325010001250", then going North
would take you to line 3250, NE would go to 1000 and East would be
1250. If r$="170020500000", then North is 1700, NE is 2050 and East is
a wall. Walls are detected by 0000. Line numbers which are not 4
digits long, eg. 800 are written as 0800 etc.

Lines 9505, 9660, 9670 and 9680 convert the input into numbers and
pick out the relative set of numbers from r$. The user can convert
this program to make his own adventures quite easily by changing the
room descriptions, the relevant r$, and the objects used. The
adventure was originally written as an entirely text only game, but I
felt that the addition of some simple graphics, colour and sound added
more interest to the game.


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


MATHS PACKAGE (Spectrum)
by Colin Carruthers


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


CITY BOMBER
by  Barry McGaw

You must bomb the city In order to land your aircraft, but it's not
quite that simple!

Imagine you are flying your aircraft and you have suddenly run out of
fuel. DON'T PANIC! Even though there is not a runway for miles, the
situation is not totally hopeless. A city lies below, and in order to
land you must bomb this city. When you have successfully completed
your task, the pilot gets out to stretch his legs, gets back into the
plane and flies off only to find himself in the same situation again
over another city!

Head in the clouds

However, this time things are starting to get a little more difficult:
there are clouds to contend with. The clouds do not hurt you but stop
your bombs until you are right above them. However, they do have
advantages ...

There are 19 skill levels, five speeds, a high-score table, 18
graphics characters and lots more in this great action-packed game. In
order to drop your bombs, merely press Enter. Have fun!


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


SOUND ANALYSER (Spectrum)
by Darren Adkinson


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


RED ALERT (Spectrum)
by M.S. Harris


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


SCREEN FORMAT UTILITY
(aka. Screen Formatter)
by Alistair de Wet

Read on and a fantastic screen format / data base utility will unfold
before your very eyes!

This program is a screen format / data base utility for on screen data
capture and information storage, sorting, editing, enquiry and general
manipulation. The screen format section of the program is designed to
emulate what is commonly available on larger business micros.

Operating instructions

The program on loading presents the user with 10 options available for
use. The program is idiot-proof in as much as it will not allow you to
use an option if it is not logical to use the option at the stage -
eg: trying to display or sort data which does not exist. A logical
sequence of using the program could be as follows:

1. OPTION 1: Instructions and Scope

This option will list a summary of what the the SF-UTIL program does
as an overview to the user. It is not intended to be a full set of
instructions. It also shows an example of a formatted screen.

2. OPTION 2: Format Screen

This option will display a sub menu which will allow you to format
your screen with fixed text and variable data definition and then
return to the main menu.

OPTION 1: Text on a blank screen.

Use cursor keys to move the cursor. Use edit to move the cursor to
start of next line. Use caps/lock to change from upper to lower case
and vice versa. Press ENTER to accept your screen. This is where you
enter the fixed text portion of your screen - eg: those portions that
remain the same each time you capture information (headings, titles,
underlinings, etc).

OPTION 2: Variable Data Fields.

The idea here is to place the cursor at the position of the first
field to be captured and then press ENTER. The program will then ask
you to input field length (from 1 to 30), paper (0-7), ink (0-7),
bright (0 or 1), flash (0 or 1) and inverse (0 or 1). Thereafter it
prints a row of X's the length of the field that you specified with
the colour attributes which you entered. If this looks correct you
press ENTER to continue to the next field to be defined or you press 0
(zero) to wipe out the current field if it is wrong to allow you to
try again or move the cursor to a more desirable position and try again.

When you have moved your cursor to all the fields that need defining
you press DELETE to return you to the sub-menu.

Remember one important factor. If you re-enter the Option 2 phase of
this sub-menu and try to define new variable data fields, all data
previously captured in the machine will be cleared out of memory. If
you, therefore, wish to save such data you must first use the SAVE
DATA option of the main menu. Obviously if no data has as yet been
captured then you lose nothing. Up to 40 variable fields are
permitted.

OPTION 3: Display Finished Screen

This option will display the completed screen which you will be
presented with when you enter the data capture phase of the system. If
any aspects of this screen are not to your liking you can re-enter
Options 1 and/or 2 of the sub menu to redefine the entire screen of
text and/or variable data.

OPTION 4: Display Data Definition

This option will display a full definition of the data. This
definition is held in memory in an array T (40,9). Each variable field
is defined here. Up to 40 variable fields are permitted and each has 9
parameters viz:

1. Row position on screen.
2. Column position on screen.
3. Length of field in characters.
4. Start position of data in the array D$
5-9. Paper Ink Bright Flash Inverse

This definition will be extremely useful to the budding programmer, as
it allows access to any of the stored data (in D$ array) at field
level for extra program codes to be included in this program or in
other programs which he may write to read the data which has been
saved from this program. If you are going to write your own program, I
would suggest that you merge the load procedure from ST-UTIL into your
program which will save you time and trouble, as there are 3 files to
load into memory (FIXED TEXT ARRAY, TABLE ARRAY, DATA ARRAY). Also the
data array size is governed by the variable fields as defined in the
table array and is thus set up in the load subroutine at run time.

OPTION 5: Return to Main Menu

Does just that.

3. OPTION 3: Formatted Data Capture

This allows you to capture data according to the definition you set up
in the Option 2 sub menu. The cursor will position itself on the first
column of the first field to be captured. Start entering information.
The cursor moves automatically from one field to the next as it fills
up the field. To move the cursor from one field to the next without
entering data use the [UpArrow] and [DownArrow] cursor keys for next
and prior fields.

To move the cursor from one character to another use the [RightArrow]
and [LeftArrow] cursor keys for next and prior character. Caps lock
will change from upper to lower case and vice versa. Press ENTER once
you have entered all the data you want, to accept the screen data and
store it in memory.

4 OPTION 4: Edit/Enquiry

The first thing you are asked to do is to enter the number of the
field on which you wish to enquire. This action will cause the
appropriate field to flash. You are then asked if this is correct and
you have a chance to change your mind or correct your choice. You will
then be asked to input the string of data you wish to enquire on. This
could be the entire field length or just part of a field - ie, you may
wish to enquire on the surname field and look for all surnames
starting with "SM". You would Just enter "SM". The enquiry system will
search the entire surname field looking for "SM". As soon as the first
record is found containing an "SM" within the surname the document
will be displayed with options at the bottom of the screen that read:
1 ALT 2 DEL 3 PRT 4 CONT 5 QUIT.

If you enter:

(1) You can alter the contents of the record using the same method of
moving the cursor and pressing ENTER after you have completed your
changes as per data capture instructions.
(2) Will delete the current record which is displayed on the screen.
(3) Will copy the current record to the printer.
(4) Will search for further records with the same seek key (in this case "SM").
(5) Will not search any further but will return to main menu.

5. OPTION 5: Display Records

This option starts at the first record and displays all the records
stored so far. Pressing any key will stop the display at the current
record at which point the option is given to continue or return to
main menu.

6. OPTION 6: Save Data

SAVE DATA saves the three arrays used by the system. You will have to
press a key when the machine requests you to do so. The 3 arrays are
interdependent upon each other in the controlling of the data handling
of the system.

7. OPTION 7: Load Data

Enter the name of the file to be loaded or just press ENTER to load
any file. The 3 arrays previously saved will now be loaded. This load
module will obviously overwrite any formats or data presently in the
machine.

9. OPTION 9: Sort the Data

The first thing you are asked to do is to input the number of the
field on which you wish to sort. This section wIll cause the
appropriate field to flash. You are then asked if this is correct and
you have the chance to correct your choice. Once you are satisfied the
sort begins. Entering Option 5 (Display Data) will show that data has
been correctly sorted.

10. OPTION 10: End Routines

This routine will give the user the option to stop the run or to go
back to the main menu if he has forgotten to save his data.

NOTE

The program is, under normal operating conditions, not likely to
crash. If, however, you manage to crash the program, type GO TO 500.
Do not type RUN or all your data will be lost.


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


HOPPIT
by Robert Kirtland

A nice little version of "amphibious" fun.

This is a version of Frogger for the 48K Spectrum. It has all of the
usual features plus some interesting extra features. You must first
cross the busy road then avoid the snake which weaves it's way along
the central reservation, cross the river by jumping on to logs, and
reach the safety of your lily pad. If the lily pad has a butterfly on
it then you will score extra points but you must be quick or it will
soon fly away.

The program has some interesting features that may be of interest to
other programmers. The program is compatible with the Kempston
joystick, it has a high score table and it redefines that character set.

The Spectrum uses the system variable CHARS to point to the character
set and by making this address point to a location in RAM it is
possible to redefine the character set. Lines 9500-9925 poke in the
new character set and if you include this subroutine in your own
programs then the character set will be redefined.

When the program is RUN there will be a long pause while the character
set and user defined graphics are poked into the memory.


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


O/S DISASSEMBLER
by Mike Henning

Unravel the mysteries (or at least begin to) of
your ZX81's operating system.

[The checksum routine at 9200 will not give the correct result, as:]
[a) Some of the inverse video REMs in the listing are partially    ]
[   illegible, so I put in ? for characters I couldn't read.       ]
[b) I changed line 2802 from:                                      ]
[   2802 IF T1=221 THEN LET C$="IY"                                ]
[   to:                                                            ]
[   2802 IF T1=221 THEN LET C$="IX"                                ]
[   because code 221 prefixes IX register commands.                ]
[c) I changed line 2892 from the erroneous:                        ]
[   2892 LIST B$(1)=A$(D543+17)                                    ]
[   to:                                                            ]
[   2892 LET B$(1)=A$(D543+17)                                 JimG]

I was introduced to computers in 1965 when the US Navy decided that I
should be a computer and peripheral repairman. The first computer I
worked with was almost seven feet tall and four feet square. The
computer had a memory access time of eight microseconds, 32K of memory
and an instruction repertoire of 77 function codes. The ZX81 that sits
on my desk is faster, has a larger repertoire, and I can carry it
around in a shoe box along with a tape recorder and printer.

The bulk of the coding that was done in 1965 was done in low level
code or machine language. When diagnostic routines had to be written
to fix a piece of equipment they were normally written by the
technician using machine code. Low level and machine code gave the
programmer a great deal more latitude than high level languages
because there were no rules (that is still the case in the use of
machine code as you will see later). Since there was a lack of
guidelines for coding, programmers developed short cuts in coding such
as jumping into the middle of a subroutine to perform only part of the
task. Short cuts also conserved the precious resource of memory which
was the most expensive component of the system in the 1960s. These
non-standard practices allowed programmers to put more program into
the same amount of memory than they could with high level languages.

I feel a great deal of frustration at times with the BASIC language
because of its slow speed and limited amount of data that can be put
in the 16K of usable memory of the ZX81. Even if the user has more
than 16K, that is the only portion available for BASIC programs so
machine language is required for expanded systems. I am sure that I am
not the only ZX81 user who has felt this frustration. The only
alternative Sinclair users have when memory space becomes a problem is
descoping messages and arrays so programs fit within the rampack. Low
level or machine code allows the programmer to put more computational
power in the same 16K of memory. That is why many of the program tapes
available commercially are written in machine code rather than BASIC
and generally interact directly with the operating system.

The only thing that prohibited me from interacting with the operating
system using my own machine code was that I did not know what was in
the 8K ROM. A couple of years ago when I was using the ZX80, I would
dump the contents of the 4K ROM on the screen, write them down, and
decode the operations using the Z80 microprocessor repertoire. Before
doing that again with the ZX81 I decided it would be much easier if I
let the computer help me by at least providing the instruction
mnemonic for the machine code. The program described In this article
does just that.

Mnemonically speaking

I will be the first person to admit that obtaining the mnemonic is
only a small portion of the task of finding out what the code is
doing. But this way the menial work is done by the machine and the
programmer can devote his talents to the cerebral task of interpreting
the code. The man or men who wrote the operating system for the ZX81
did not have much memory to work with, so decoding the machine code
also shows you many of those short cuts that have been used by machine
code programmers since the beginning of the computer era.

I suppose that you are asking why you would want to do all this work.
Machine code in the ZX81 operates much faster than the equivalent
BASIC code. As an example, one of the procedures in the REM statement
at the beginning of this program changes all the PRINT statements to
LPRINT if the printer output has been selected. The execution time of
this routine is less than one second. I had originally done the
routine in BASIC but it took almost five minutes to do the same
function. Therefore speed and more computational power for each byte
of memory are the major advantages of using machine code and
interacting with the operating system.

If you know what code exists in the operating system and what it does,
you do not need to use valuable cells of memory duplicating functions
that already exist. Instead you make a call to the ROM. Not only does
this save memory in your program but it also saves you the time of
writing the code.

The final advantage of knowing what is in the operating system is that
you will have a much better understanding of your equipment. You will
be able to interact with your system and feel a real rapport with your
system.

Entering the program

This program allows you to display on the screen or print on the
personal printer, the mnemonics for the machine code contained
anywhere in memory. The format for the output is: address, contents,
then mnemonic. The addresses are printed in decimal so it is easier to
identify the references to BASIC variables as described in your Users
Manual. The contents of memory are printed in octal. That is mostly
personal preference on my part but it also makes the identification of
some of the Z80 instruction fields easier. The repertoire I have for
the Z80 is in binary. Since I have been working with binary coded
octal (BCO) for eighteen years, octal was a natural choice for me. The
mnemonics come from the repertoire that I use. I have noticed that
there are some subtle differences in mnemonics used for the Z80. These
differences are not major and there should be no problem deciphering
what the mnemonics used by this program mean.

If you are not familiar with the Z80 architecture, it is important for
you to get a book on the Z80 microprocessor. The books should describe
the processor and define the instruction set. Without this guide, the
mnemonics will not make sense because they manipulate registers and
flags that are unique to the Z80.

Firstly

The first step in entering this program is to input the BASIC
statements. Either execute a NEW command or reset the computer before
you start. This is necessary so the checksum feature will work. The
program is long so it is a good idea to save it often as you are
entering it. Statement 2 is a SAVE command. Do not use this command
until the entire program is in and checksummed. The use of the SAVE
command is described later in the article. Once all the BASIC code has
been entered, the machine code and data table can be put in.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 1
-------
16514	136
16515	052  LD HL,(16396)
16516	014
16517	100
16518	001  LD BC,17400
16519	370
16520	103
16521	355  SBC HL,BC
16522	102
16523	104  LD B,H
16524	115  LD C,L
16525	041  LD HL,17400
16526	370
16527	103
16528	076  LD A,245
16529	365
16530	355  CPIR
16531	261
16532	300  RET NZ
16533	053  DEC HL
16534	066  LD (HL),225
16535	341
16536	043  INC HL
16537	030  JR 16530
16538	367
16539	052  LD HL,(16396)
16540	014
16541	100
16542	001  LD BC,17400
16543	370
16544	103
16545	355  SBC HL,BC
16546	102
16547	104  LD B,H
16548	115  LD C,L
16549	041  LD HL,17400
16550	370
16551	103
16552	076  LD A,225
16553	341
16554	355  CPIR
16555	261
16556	300  RET NZ
16557	053  DEC HL
16558	066  LD (HL),245
16559	365
16560	043  INC HL
16561	030  JR 16554
16562	367
16563	052  LD HL,(16396)
16564	014
16565	100
16566	000  NO-OP
16567	021  LD DE,16515
16568	203
16569	100
16570	257  XOR A,A
16571	107  LD B,A
16572	355  SBC HL,DE
16573	122
16574	353  EX DE,HL
16575	041  LD HL,16515
16576	203
16577	100
16578	206  ADD A,(HL)
16579	117  LD C,A
16580	043  INC HL
16581	033  DEC DE
16582	172  LD A,D
16583	203  ADD A,E
16584	310  RET Z
16585	171  LD A,C
16586	030  JR 16578
16587	366
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

The REM statement at the beginning of the program is loaded with three
machine code routines. The listing in Table 1 was output from the
program so you could see what the routines do and what the output from
the program looks like. The first routine changes all of the PRINT
statements after the beginning set up statements to LPRINT commands.
This routine is called if the answer to the question concerning output
is yes. The second routine changes all of the LPRINT commands back to
PRINT at the end of the run. The final machine code routine performs a
checksum. This allows you to see if you have put the program in just
as it appears in this article. Table 2 contains the decimal values
that are used to input the machine code. To enter the machine code
execute a GOTO 9000. The address that the data are being poked into is
displayed. Enter the data from Table 2. After all the data have been
input the computer will stop with a 9/9099 displayed.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 2
-------
16514 94,42,12,64,1,248,67,237,66,68
16524 77,33,248,67,62,245,237,177,192,43
16534 54,225,35,24,247,42,12,64,1,248
16544 67,237,66,68,77,33,248,67,62,225
16554 237,177,192,43,54,245,35,24,247,42
16564 12,64,0,17,131,64,175,71,237,82
16574 235,33,131,64,134,79,35,27,122,131
16584 200,121,24,246
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

The final step is to put the data in the mnemonic table. The data in
Table 3 are used for this. The numbers in Table 3 are there as a guide
only and should not be input. Each item of the mnemonic table is five
characters long but it is not necessary to enter all five characters -
if the item is less than five, the computer takes care of that. Please
notice that items 107 and 108 are blank. This is intentional and
necessary. When you input these two items just hit enter. To put the
mnemonic table into the program execute a GOTO 9100. The item number
of the data element in the table that you are currently putting in
will be displayed on the screen. When all of the data has been input,
the computer will stop with a 9/9199 displayed.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Table 3
-------
01 NO-OP       32 RRCA        63 HL          94 IM0
02 EX AF       33 RLA         64 AF          95 IM1
03 ,AF'        34 RRA         65 POP         96 IM2
04 DJNZ        35 DAA         66 PUSH        97 LD I,
05 JR          36 CPL         67 OUT         98 LD R,
06 JR NZ       37 SCF         68 IN A        99 LD A,
07 JR Z        38 CCF         69 EX (S      100 LD A,
08 JR NC       39 ADD         70 EX DE      101 RRD
09 JR C        40 ADC         71 DI         102 RID
10 LD          41 SUB         72 EI         103 A
11 ADD         42 SBC         73 P),HL      104 A
12 BC          43 AND         74 ,HL        105 I
13 DE          44 XOR         75 CALL       106 R
14 HL          45 OR          76 RLC        107
15 SP          46 CP          77 RRC        108
16 HALT        47 RET         78 RL         109 LDI
17 B           48 EXX         79 RR         110 LDD
18 C           49 JP (H       80 SLA        111 LDIR
19 D           50 LD SP       81 SRA        112 LDDR
20 E           51 L)          82 ?????      113 CPI
21 H           52 ,HL         83 SRL        114 CPD
22 L           53 NZ          84 BIT        115 CPIR
23 (HL)        54 Z           85 RES        116 CPDR
24 A           55 NC          86 SET        117 INI
25 (BC)        56 C           87 IN         118 IND
26 (DE)        57 PO          88 OUT        119 INIR
27 HL          58 PE          89 SBC        120 INDR
28 A           59 P           90 ADC        121 OUTI
29 INC         60 M           91 NEG        122 OUTD
30 DEC         61 BC          92 RETN       123 OTIR
31 RLCA        62 DE          93 RETI       124 OTDR

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

And now

The program is now complete and should be saved. You are now ready to
see if all the BASIC and machine code have been input correctly. (This
checksum does not check the data area where the mnemonic table is
stored). To perform the checksum execute a GOTO 9200. If the program
has been input as it appears in the article, the program will stop
with a message that says "CHECKSUM OK". If the checksum is wrong, the
message will say "CHECKSUM WRONG". There is no easy way to find out
what has been input incorrectly. The process requires a line by line
check. For example, the checksum checks all of the statements,
therefore, it is possible an incorrect line number is causing the
checksum error.

There is no reason why you cannot change the number base or format of
the output to suit your particular references, but I would suggest
that the program be put in initially just as it appears in the
article. That way before you begin any changes you will know that you
are working from a valid baseline.

The program does not use all of the 6K RAM. There are about 3000 bytes
left. Therefore you can add special features to the program to print
specific types of data. I have included three special features in the
base program. The first special feature prints the Sinclair character
represented by the contents of memory. This feature is used to output
memory locations 126 through 507. This area contains the keyboard and
keyword tables. The second special feature prints the character pixel
data the Sinclair workhorse uses for the display. This table is
located at addresses 7680 through 8191. The third special feature will
take consecutive memory locations and print the decimal value for n
and n+1. This feature is helpful for printing jump tables that are
located throughout the system ROM.

Program operation

To operate the program never use RUN. The RUN command does a clear
before it begins and this would cause the mnemonic table to be
destroyed. In order to alleviate that from accidentally happening,
there is a SAVE statement at line 2. When the program has been
verified for correctness, a GOTO 2 should be executed. This will save
the program so that it will start execution at statement 3 immediately
after loading without operation intervention. When the program is
saved in this manner the last character before the final quote mark in
the SAVE statement will be displayed in inverse video. The operating
system recognises this at load time as a program that is scheduled for
automatic execution.

At execution time the first question asked is if you want a special
feature. If the answer is "Y", then the menu of special features is
presented. A special feature can be selected and the program
continues. If the answer is "N" then the special feature menu is not
presented and the program will be in the disassemble mode. The next
input is the address that you want to start decoding at. There are no
validity checks on this input so any area of memory can be decoded.
The next question concerns an offset value. If there is memory
available in your system in an area that is not used by the BASIC
operating system, the contents of machine code located anywhere in the
system can be moved to that area and output by the program. The offset
allows the computed address of relative jump instructions to be
computed correctly. For example, if the contents of ROM were moved to
the 8K - 16K block of memory the offset value would be 8192. If the
contents of the 8K block starting at 24576 were moved to the same
location, the offset value would be 16384. The offset value is the
difference between where the program is located for disassembly and
the runtime execution location. Printing the system ROM starting at
address 0 requires an offset value of 0. A zero for the offset value
should be entered anytime the program being disassembled is located at
its runtime location. The program continues after entering the offset
by asking for the ending address. This input tells the program how far
you want to translate. If the ending address is in the midst of a
multiple byte instruction, the entire instruction will be output
before the program quits. The final operator input is whether you want
the output printed on the personal printer. If the answer to the
question is "Y" then all of the PRINT statements that output the
mnemonics are changed to LPRINT so the output will go to the printer.
If the answer is "N" then the output is directed to the screen and the
program runs in the SLOW mode and uses SCROLL. When the program
completes the requested action the end is signified by "RUN DONE"
appearing on the screen. At this point the program is in an idle state
executing the PAUSE statement, line 61. By depressing any key other
than the space key, the program will continue at line 3. The space key
will cause a D type stop.

Don't worry

As the program works through the contents of ROM there will be times
that the output is wrong. This is not a program bug! Because of the
limited space that the writers of the operating system had, there are
data stored throughout the operating system procedures. There is no
way for the program to distinguish between data and instructions so
everything is interpreted as an instruction. If the last byte of data
contains the code for a multiple byte instruction the first part of
the following routine will be in error. It does not take long for the
program to get back on track, but be aware that this does occur as you
are deciphering your output.

There are a number of special features that can be added to the
program. If you have extra memory you could put in a label table, and
add labels to your output. Another feature if you have extra memory is
a cross reference listing. I am looking forward to seeing more
programs that interact with the operating system.


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


DEFLECTOR
by Andrew Smith

Removing blocks with a ball sounds easy, doesn't
it? Try this game and see just how wrong you can be!

Deflector is a game for the Spectrum 16 or 48K. The aim of the game is
to remove the blocks (Graphic As) from the screen by rolling over them
with your ball (Graphic B). The only way to change the direction of
your ball is to place "slashes" in its path - these are the division
symbol (sym. shift and V) and the back slash (E mode shifted D). Each
of these will cause a 90 degree change of direction. If you get stuck
in a loop you can remove all the slashes on the screen by pressing
SPACE: this will also rearrange the positions of the blocks.

The Program

The program is arranged such that every task that the computer
undertakes is written in a subroutine of its own. The game loop starts
at line 8015 and consists of several GO SUBS and one GO TO which
repeats the loop. The UDG loader should be typed in first and then
RUN. It should then be NEWed. Line 9900 of the main program should be
typed in first to allow saving of the program and the UDGs at the end
of each session. The rest of the listing should then be typed in. The
program should be saved by "GO TO 9900" as this saves the program to
autorun at the correct point and also saves the UDGs with automatic
verification.

What's Your Score

The reckoning of the score is based on the following formula:

no. of blocks x 10 - (no. of slashes
+ no. of rubbed out slashes x 5)

Anything over 0 is quite good! The game is difficult when both high
numbers of blocks or low numbers are used; the easiest game is in the
25-65 range.

Take note

One problem I encountered and was unable to solve was that after
placing a new slash and acting on it a block in the next character
position to the slash in the new direction of travel is ignored,
however it is picked up on the return journey.

In programming this game I have adopted a "modular" approach; this
means that every task that the computer has to undertake is written in
a subroutine of its own. The game loop starts at 8015 and consists of
several GO SUBS and one GOTO which repeats the loop.

The UDG loader should be typed in first and then RUN, It should then
be NEWed. Line 9900 of the main program should be typed in first to
allow saving of both the program and UDGs at the end of each session.
The rest of the main listing should then be typed in.

The program should be saved by "GO TO 9900" as this saves the program
to autorun at the correct point and also saves the UDGs with automatic
verification.

[Yes, I know that the last few paragraphs just repeat what was said earlier]
[but that's what was printed in the magazine.                          JimG]


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


ALIEN ATTACK
by Paul Hayward

Here's one for all you trigger-happy alien-zappers.

You are Earth-bound but, luckily, provided with weapons, when a mother
ship full of strange creatures and small craft approaches the planet.
Now's your chance to save the world by stopping them from landing.

In this version of the arcade game you aim with the 'Z' and 'X' keys
and fire with the Space key. Instead of bunkers there is an
'atmosphere' which will provide you with a limited amount of
protection, and rapid random firing is prevented since continual
firing will abort previously fired missiles. For each alien or ship
destroyed you score 10 points, and you gain another 100 points by
destroying the mother ship.

Variables
H	High score
S	Score
X	Vertical base coordinate
Y	Horizontal base coordinate
A	Vertical coordinate of first row of aliens
B	Horizontal coordinate of alien rows
L	Counter (starts at 0; when 9 is reached aliens move down
	vertically one row)
Z	Either 1 or -1, increments or decrements b
a()	Switch (0 or 1) status is determined by whether there are
	aliens left in each row
Fi,Fa	Switches tell whether a missile has been fired
Fx,Fy	Coordinates of Earth missile
Ax,Ay	Coordinates of alien missile
F	Allotted for general use

Structure
10-60	UDGs, variables and set-up routines
100	PRINTS missile base
110	Scans keyboard for base movement
120	Checks if space bar has been used to fire
122	Erases previous missile
124	Sets new missile coordinates
125	Checks whether there is a missile on the screen
130,140	Updates missile
150-200	Prints aliens
210-320	Alien fires, various checks
400	Update alien's horizontal coordinates
500	Loops back to 100

Subroutines
1000	Earth missile has hit something, determines what and acts
	accordingly
2000	Alien missile has hit something, determines what and acts
	accordingly
5000	Die routine, new game option
6000	Instructions
8000	Set up variables, string variables, 8090 draws atmosphere
9000	UDGs, data for music


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


BOOKFILE (ZX81)
by R Dickson


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


FRENCH LANGUAGE TEST (ZX81)
by M.W.J. Lodge


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


PRINT 64
by Kai Weber

Get 64 characters per line rather than the normal 32 on your Spectrum.

One of the many disadvantages of the Spectrum, as opposed to, say,
Auntie Beeb's micro, is its very low character resolution - 32 by 24.
Anyone who has endeavoured to write a word processor on a humble
Spectrum will appreciate that it is very difficult to overcome the
character problem, unless you happen to have software that can
generate at the very least 64 characters per line. You may well be
asking where you can get such software from - well, look no further!
The machine code routine in this article will allow you, by a very
slight alteration to your print statements, to output to the screen
all the normal characters but at 64 per line instead of the normal 32.
Both sizes of text can be mixed on the screen at the same time.

I was inspired to write the program after reading Mike Lord's article
"Spectrum Streams" (ZX Computing August/September '83) in which he
stated that the values in the system variable STRMS were in fact
pointers pointing to the Channel Information area of RAM. So I thought
to myself, why not make stream four point to a new printing
sub-routine instead of the usual error routine by poking locations
23568/9 (see "Spectrum Streams").

Getting in print

Fig.1 is a disassembly of the 48K version of Print 64. Basically, what
the routine does is to first change the Spectrum character set by
altering location 23606/7 CHAR$ into something which is a little more
suited to 64 characters per line ie. each character occupies only the
first four bits. Next, it will perform one of two operations. If the
current print position (in 64 character mode) is an even number or
zero it will simply print the character in the A register at the
position. However, if the current x-axis print position is an odd
number the character in the A register is first rotated right four
times before being printed OVER 1 at the current position (OVER 1 is
used because it means the character does not instantly delete the
previously printed character). Finally, the character set is made to
point back to the data held in ROM before returning. Sounds
complicated? It is!

The machine code and character data occupy just over 1K of memory
directly beneath the UDG's - 1215 bytes to be exact. To use the
routine first type in listing one. You should then proceed to input
all the numbers in Fig.2a if you own a 16K or 2b if you own a 48K. The
computer automatically compiles a checksum and when you have finished
typing will inform you of any errors. If you do make any errors, I am
afraid you will just have to enter all the numbers again. When
everything is correct, the computer will inform you in 64 character
mode and then save the code to tape. If you experience difficulty
reading the text at first try altering the tuning of your TV set very
slightly.

Using the routine

The only alterations needed to a
simple print statement are:
1. The addition of '#4;' just before the text to be printed.
2. The addition of the seemingly useless squiggle (located under the
'A' key) just before the text. (Don't worry! This character does not
actually get printed.)

So therefore, PRINT "text" would become PRINT #4;"(squiggle)text"

What it cannot do

For complicated reasons, the program cannot handle keywords or UDGs.
It simply subtracts 128 from them to turn them into ordinary
characters. It is also incapable of dealing with control characters,
so therefore any FLASH, OVER, AT, TAB, INK etc, statements should be
placed before the # character, ie.

PRINT INK 1; AT 12,12;#4;"(squiggle)text"

N.B: The numbers after AT and TAB are still expressed as values
between 0 & 31 - the first character to be printed always appears on
the left hand side of the current 32 character mode print position.

Unfortunately, for some reason unknown to me, the routine does not
like the CHR$ statement. It simply refuses to print anything if you
type, say,

PRINT #4;"(squiggle)";CHR$ 65

which should display an 'A'.

Get scrolling

If the screen fills up and the computer prompts "scroll?", you will
probably notice that the message is made up of small characters, but
with a space between each. if you stop the computer scrolling, all
output appears like the message. To restore normality, type PRINT #4;""

I said earlier that you needed a squiggle character at the beginning
of the text but this is not necessary if the previous print statement
was terminated by a semi-colon and you wish the next piece of text to
buffer onto the previous. For example, suppose you wanted to print out
the character set from space to copyright symbol, you would use a
program something like this:

10 PRINT #4;"(squiggle)";: REM
the first print statement should
always contain a squiggle.
20 FOR F=32 TO 127
30 LET A$=CHR$ F: PRINT #4;A$;
40 NEXT F

The only reason for putting the character to be printed into the
variable A$ is that, as mentioned previously, the routine does not
like the CHR$ statement. Generally speaking, upper case output tends
to look neater than lower case, which, in my opinion, often looks
straggly.

When using the routine in your own programs, If you do not already
have the machine code on board, you should place this line at the very
beginning:

CLEAR USR "A"-1215: LOAD ""CODE: LOAD ""CODE

You should then save both blocks of code directly after your program.
To save the code, first load it in using the above commands and then
simply copy both lines with 'SAVE' in them from the BASIC program in
listing 1.

Text editor

Listing two is a very simple text editor which sorts out text so that
no word overlaps from one line to another. The program assumes that
you have the machine code on board. When run, it will ask you to input
some text which should be more than 64 characters in length to see
what the routine does. Once entered, the program will display the
edited text at 64 characters per line. The only way to get it onto
printer paper is to use the COPY command - LPRINT #4 does not work
properly. Listing two is not meant to be a full-blooded word
processor, just an example of how the routine can be used - a word
processor may well feature in another article sometime in the future.
As can be seen from this article the potential applications of using
different streams are very powerful.

Print 64 has very obvious advantages for people wishing to use their
Spectrums for serious uses rather than ridding the complete and utter
universe of Klingons or similar alien menace. Your only problem now
for word processing on a Spectrum is getting a decent keyboard, a
decent printer, a printer interface and last but not least the actual
word processor software - watch this space!

Fig.1 - Disassembled listing
----------------------------
65180 FE7E           CP   126
65182 C8             RET  Z
65183 A7             AND  A
65184 CBBF           RES  7,A
65186 CDB2FE         CALL weber
65189 CDF409         CALL PRINT-OUT
65192 CDB9FE         CALL sincl
65195 21C1FE         LD   HL,65217
65198 2256FF         LD   (65366),HL
65201 C9             RET
65202 219AFA   weber LD   HL,64154
65205 22365C         LD   (23606),HL
65208 C9             RET
65209 21003C   sincl LD   HL,15360
65212 22365C         LD   (23606),HL
65215 C9             RET
65216 00             NOP
65217 FE7E           CP   126
65219 CAEBFE         JP   Z,strms
65222 A7             AND  A
65223 CBBF           RES  7,A
65225 CDB2FE         CALL weber
65228 CD12FF         CALL sethl
65231 CDF2FE         CALL rotr
65234 CD21FF         CALL dfcc
65237 F5             PUSH AF
65238 CD38FF         CALL over1
65241 F1             POP  AF
65242 F5             PUSH AF
65243 CDF409         CALL PRINT-OUT
65246 CD44FF         CALL over
65249 F1             POP  AF
65250 CD12FF         CALL sethl
65253 CD02FF         CALL rotl
65256 CDB9FE         CALL sincl
65259 219CFE   strms LD   HL,65180
65262 2256FF         LD   (65366),HL
65265 C9             RET
65266 0E08     rotr  LD   C,008
65268 F5             PUSH AF
65269 0604     loop  LD   B,004
65271 CB1E     il    RR   (HL)
65273 A7             AND  A
65274 10FB           DJNZ il
65276 23             INC  HL
65277 0D             DEC  C
65278 20F5           JR   NZ,loop
65280 F1             POP  AF
65281 C9             RET
65282 0E08     rotl  LD   C,008
65284 F5             PUSH AF
65285 0604     loop2 LD   B,004
65287 CB16     il2   RL   (HL)
65289 A7             AND  A
65290 10FB           DJNZ il2
65292 23             INC  HL
65293 0D             DEC  C
65294 20F5           JR   NZ,loop2
65296 F1             POP  AF
65297 C9             RET
65298 F5       sethl PUSH AF
65299 D5             PUSH DE
65300 110800         LD   DE,00008
65303 47             LD   B,A
65304 219AFA         LD   HL,64154
65307 19       loop3 ADD  HL,DE
65308 10FD           DJNZ loop3
65310 D1             POP  DE
65311 F1             POP  AF
65312 C9             RET
65313 21845C   dfcc  LD   HL,23684
65316 35             DEC  (HL)
65317 F5             PUSH AF
65318 ED4B885C       LD   BC,(23688)
65322 0C             INC  C
65323 ED43885C       LD  (23688),BC
65327 ED4B885C       LD   BC,(23688)
65331 2A845C         LD   HL,(23684)
65334 F1             POP  AF
65335 C9             RET
65336 3A915C   over1 LD   A,(23697)
65339 32B05C         LD   (23728),A
65342 21915C         LD   HL,23697
65345 CBC6           SET  0,(HL)
65347 C9             RET
65348 3AB05C   over  LD   A,(23728)
65351 32915C         LD   (23697),A
65354 C9             RET


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


SPACE RESCUE (Spectrum)
by Giles Toman

[The data listings for the machine code and UDGs were not printed in]
[the magazine, so it's not possible to enter this program.      JimG]


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


STARS (ZX81)
by Georges Bery


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


FRACTIONS (Spectrum)
by Paul Estcourt


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


DOMINOES (ZX81)
by Norman Brooks


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


VU-WORD (Spectrum)
by Alastair de Wet


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


STRANDED
by Craig Sanders

Those sneaky aliens are at it again - they've now invaded the 16K Spectrum.

Yes, you've guessed it - we've been got at again by those beasties
from outer space! It's really a case of whether you can get the aliens
before they can get you. Although there are many space-type games
around for the Spectrum, we felt that this particular version was
definitely worth including in this magazine. But you shouldn't need
too much explanation - just type in the program, don your space-suit
and get set to save the universe.

The graphics, variables and introduction were set up at the end of the
program to ensure speed for alien movement and player movement.

Notes on Listing
Lines 40-70	Go to the subroutine for graphics, introduction
		and variables. Define hi-score.
Lines 100-200	Main loop. Ships movement and randomly
		determine which alien attacks player.
Lines 300-360	Print first alien. GOSUB alien movements. Check if
		player is killed. Set up points given to that
		particular alien. Attribute for alien hit routine.
Lines 400-460	Second alien. Return to main loop.
Lines 500-560	Third alien. Return to main loop.
Lines 565-580	Random alien movement for jumping around
		effect on screen.
Lines 600-650	Lose one life: Print explosion: Set 'alien' to '0'
		indicating to run lines 170 to 190 and choose
		new alien.
Lines 1000-1150	Game over. Input name of player if new high
		score. Return to GOSUB for variables.
Lines 2000-2050	Alien dead. Print explosion: small tune. Add
		score for that particular alien.
Lines 6000-6200	Set up coordinates depending on the direction
		that the player's ship is pointing, plot and draw
		'fire' and if attribute is not the same as attribute
		set then GOTO alien killed routine
Lines 7000-7300	Introduction.
Lines 8000-8050	Set up variables.
Lines 9000-9200	Set up user-defined graphics


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


ON FINAL (ZX81)
by Georges Bery


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


MISSILE CONTROL (Spectrum)
by Michael Harley


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


MATHS MAZE (Spectrum)
by J.S. Thurlby


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


AQUASHARK
by Ayal Pinkus

Rather than be chased by nasty beasties, just try
your hand (or fin!) at being a shark to catch others.

This great arcade game was written in Spectrum BASIC on the 16K
Spectrum. After typing in the listing save it by typing SAVE
"AQUASHARK" LINE 1 and 'ENTER'. Now just type 'RUN' and you will hear
some melody. This means that the micro is defining the UDGs. Then
three pages of explanation will appear and your beloved Spectrum will
ask for your chosen skill level (level 9 is the easiest).

Keep swimming

Then comes the fun part - the game itself. You are a shark, who, being
somewhat hungry, has to eat all the fish in the aquarium. However,
there is another shark who is even more hungry and is out to try to
eat you! (You didn't think there wouldn't be a catch, did you?) It's
really as simple as that - if you have eaten all the fish, the melody
starts playing and you are presented with a new screen. If you're
beaten by that nasty other shark, you'll see another screen which will
tell you how the game went (as if you didn't know) and it will ask if
you want another game.

Be careful - that other fishy character can do very unexpected jumps!
So if you're feeling sufficiently hungry, start typing in the game and
start hunting.

Program structure

LINES:	FUNCTION:
1-4		set variables and explanation
5-92		set screen
95-106		main loop
200-220		own shark up
300-310		own shark down
400-410		own shark left
500-510		own shark right
600-690		logic-mover other shark
2000-2070	screen after game (melody too)
3000-3050	level-choice
4000-4020	melody after cleared screen
5000-5040	two pages explanation
8000-8050	set UDG

VARIABLES:	USE:
cnt		control subroutine
i		first loop-counter
j		second loop-counter
hsc		high score
sc		score
x,y		coordinates from own shark
x1,y1		coordinates from other shark
v,w,v1,w1	variables for branch-checking


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


UNLOAD THE CARGO
by D.G. Menary

[There's a gap in the listing between lines 400 & 422, so I've just]
[entered the bit that was left.                                JimG]

Unloading cargo may not seem the most exciting job in the world, but
when a helicopter is just waiting to steal the crates you've unloaded,
the situation becomes somewhat more interesting!

A ship has just docked and you, the man with the trolley, must unload
the cargo, one crate at a time, before the helicopter has a chance to
steal any.

At the end of the pier there is a gun to fire at the helicopter.
Sorry, but for every pass of the helicopter you only get three shots -
any more and the game would be too easy.

Because the helicopter is bigger than you it can carry two crates of
cargo to your one.

All instructions are explained in the program.

For people with issue one SPECTRUM you can change line 130 IF
INKEY$="0" to IF IN 61436=254; the rest of the line is the same. Using
the IN command enables you to keep your fingers on the key that
controls the man with the trolley and fire the gun at the same time.

Breakdown of Program

Line 3-30	Set up variables.
Line 40-95	Set up screen. The only graphics used that are not
		user defined are graphics capshift 8 and in line 130
		E (extended mode) symbol shift and keys Y and U.
Line 100-200    Main game loop.
Line 210-310    Scores and helicopter explosion, random
		helicopter appearance.
Line 400-440    End of game, high scores update and start game.
Line 500-750    User defined graphics.
Line 900-970	Instructions. While you read the first screen the user
		defined graphics are being set up, much better
		than a PLEASE WAIT on the screen.
Line 9990	To save the programme so that it will auto run, as a
		direct command GOTO 9990 ENTER.


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


RENUMBER
by Matthew Homer

This machine code program will renumber the lines in your programs and
alter any affected statements accordingly.

Here is a renumber program written in machine code for the Spectrum.
It renumbers all lines and alters GOTO, GOSUB, RESTORE, LIST, LLIST,
RUN and LINE statements accordingly. The program takes up just over
2/3K at the top of memory. It is as fast as any commercially available
renumber program, although it does a bit extra, by renumbering all
commands which can have line numbers as their parameters (ie. not just
GOTO and GOSUB commands).

We give you the listings for both the 16K and 48K versions. Each
listing will place the Renumber machine code above RAMtop and below
the user defined graphics for the Spectrum (the machine code can only
go into these locations; it is not relocatable). Each listing
incorporates a routine for testing its own DATA statements which can
be used by entering GOTO 700. This routine takes 30 seconds to run and
performs three tests on the data in order to determine if the data are
correct (see 16K listing). There is also a routine for saving the
machine code.

Get typing

Once you have typed in the program and are satisfied that the data are
correct, you may run the program. The machine code is then ready to
use and you will not require the BASIC any more (it is only needed
initially, to place the machine code in memory). You may save the
machine code by entering GOTO 500 (Microdrive) or GOTO 600 (tape). I
would suggest that you also save the BASIC, just in case.

Note

Whenever you want to load the renumber code, you must enter CLEAR
64664 (48K) or CLEAR 31896 (16K) before loading, otherwise the
Spectrum will crash.

Up and running

To run the renumber program, simply enter RANDOMIZE USR 64665 (48K) or
RANDOMIZE USR 31897 (16K). If there Is a program. to renumber, the
prompt: Enter renumbering step (MAX = number)

0000

will appear. Type in the number (if you make a mistake type it in
again - you will notice that the number will rotate from right to left
as you press each key). Press Enter when you have finished or "H" to
exit. After a few seconds or milliseconds depending on the size of
program (a full 40K program can take up to 15 seconds to renumber),
the computer will be returned to BASIC. You will notice that your
previously alphabet-soup-like line numbers are now neat and
structured. GOTO, GOSUB, LIST, LLIST, RESTORE,RUN and LINE commands
are also altered to suit these new line numbers, although if these
commands have no parameter or have a variable as a parameter, they
will be left alone. If any of these commands point to a line number
beyond the end of the program (GOTO 9000 when the last line in the
program is 7000), they will be changed to point to line 9991. This is
the largest prime number available for line numbers and therefore
unlikely to be occupied after renumbering; you can then put a STOP
statement in line 9991 to trap such GOTO and GOSUB commands.


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


WORDSEARCH (Spectrum)
by K Ward


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


CRASHER (Spectrum)
by James Drury


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


KNIFE, STONE, PAPER (Spectrum)
by Colin Gooch


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


MC INDEX (ZX81)
by K Robbins


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


DAM ATTACK (Spectrum)
by Neil Wood


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


MASTERMIND CHALLENGE (ZX81)
(aka. Code Breaker)
by Norman Stevens


= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =


