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

ZX81 PROGRAM LIBRARY - DISK 2

INFO about the ZX81 programs (.P) suitable for XTricator & XTender
Version 0.30 as of 93.04.05

Compilation & Descriptions (c) by Carlo Delhez, September 1992.

The programs on this library disk as well as this text file are part
of a registered copy of XTricator or XTender and may NOT be further
distributed in any way!

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

3DESCAPE        * 3D Escape, author unknown, undated
                * 3D maze game, in Basic
                * you are trapped in a maze, all you have to do is escape
                * program presents 3d view of the corridors
                * limited supply of oxygen available
                * steering: instructed
                * exit any time by break

ANIMALS         * Animals, author unknown, undated
                * classical artificial intelligence game, in Basic
                * the computer applies artificial intelligence to guess
                  an animal and learns from the user when it fails to deduce
                  the right animal
                * the A.I. data is stored dynamically in an ever increasing
                  string, already containing information for 14 animals
                * answer the first two questions with 'N' and 'Y', respectively
                * exit any time by Stop

AQUAMAR         * Aquamarin, author unknown, 1984
		* graphical adventure, combination of Basic and machine code
                * German version of Enterprise; see Library Disk #1

ASTEROID	* Asteroid Storm, author unknown, undated
		* shooting and evasive game, in Basic
		* double feature: first destroy the asteroid and then fly
		  safely through the underground caves
		* personal hall of fame
		* steering: 1st screen: 5/8/0 = left/right/fire
			    2nd screen: 6/7   = down/up
                * exit any time by Break

AWARI		* Awari by P.E. Canter, undated
                * ancient African game, in Basic
		* sow as many beans in your home pit by making intelligent
		  moves with the beans in your six other pits
		* instructions included
                * exit any time by Break

BARCHART        * Staartgrafiek Plotter, author unknown, undated
                * barchart plotter, in Basic
                * up to 9 named data sets with monthly data can be entered
                  and up to 3 of these may be shown simultaneously by way
                  of barcharts
                * commands:  C  = Clear current plotscreen
                             Ex = Enter dataset x (x=A,B,...,I)
                             EM = Edit Maximum plot value
                             ET = Edit chart Title
                             H  = show Help
                             S  = Save program with datasets etc.
                             nx = plot dataset x (x=A...I) as chart n (n=1,2,3)
                * texts in Dutch
                * exit any time by Break or Stop

BILLYJMP        * Billy Jumper by Wolfgang Labus & Frank Beer, undated
                * original athletics game, machine coded
                * Billy has to run an obstacle race: avoid bumping into
                  the front of hindrances on the ground but also take care
                  for the bars at the ceiling
                * 10 speed levels (0=fastest!), texts in German
                * scores & penalties appear in the top line during the race
                * long pause after loading when code is poked in memory
                * steering: 1,2,3,4,5 for low up to high jumps
                * exit at title page by Break

BIORHYTH        * Biorhythmus, author unknown, undated
                * calculates personal biorhythm, in Basic
                * first type birthdate as "dd-mm-yy", then the current date
                  in the same format (year assumed to be in 20th century)
                * program calculates your corporal, psychical and intellectual
                  condition on a scale of -100 to 100
                * also calculates the day of the current day
                * after calculation, enter "Y" for another current date
                  or "N" for another birthdate
                * all texts in German
                * exit any time by inputting Stop

COSMIC          * Invaders by Ch. Zwerschke and M. Zwerschke, 1982
                * space invader game, machine coded
                * destroy the aliens before they destroy you
                * 9 speed levels, German texts
                * steering: 5/8 = left/right
                            0   = fire
                * no official exit

CRASH           * Crash by Panayi & Canter, September 1981
		* evasive and defensive game, in Basic
		* try to trap the growing computer snake while not bumping
		  into it or into yourself
		* wrap-around screen makes this game more difficult
		* steering: unshifted cursor keys
                * exit any time by Break

DAMPER		* Damper by M.P. Crane, Quicksilva, December 1982
		* painter game, machine coded
		* completely fill the tracks around the block in order to
		  paint them grey, but watch out for the guards
		* smooth graphics, personal hi-score table
		* steering: instructed
                * exit any time by Break

DEFFORCE	* Defence Force by Greg Jarvis, undated
		* shooting game, in Basic
		* destroy the alien ships which attack your defensive
		  shield as to kill you
		* 5 skill levels, nice effects for a game in Basic
		* steering: instructed
                * exit any time by Break

DISASSEM        * Disassembler by G. Merkel, October 1981
                * Z80 disassembler, in Basic (!)
                * type start and end address in hex; then enter A for screen
                  output or D for printer output, and wait...
                * the disassembly is stored in a string array; at the end
                  of each dissembly screen, type a subscript number to select
                  any part of the disassembly or 0 to quit
                * texts in German
                * exit any time by Break or Stop

ESCAPE          * Escape by DERF Software, undated
                * evasive game, in Basic
                * try to reach the exit (X) in the bottom of the screen
                  while avoiding the block appearing randomly on the screen
                * exit may become unreachable during the game...
                * collect dollars for extra score
                * bonus for clearing screen and for collecting all dollars
                * texts in Dutch
                * exit any time by Break

ESCAPE-2        * Escape-2, author unknown, undated
                * evasive game, in Basic
                * escape from the screen by avoiding the moving bar and
                  jumping through the moving hole at the right time
                * steering: keys 5 through 8
                * exit any time by Break

FONTDEMO        * Font Demo, author unknown, undated
                * alters ZX81 character font, machine coded
                * demonstrates how to use the 8-16k area for alternative
                  fonts; a `bold' font is included as an example
                * press Break to keep font, NewLine to new ZX81
                * use USR 16514 to select new font again when it disappears

FORTYNIN        * Forty Niner by Cosmic Cockerel, Software Farm, undated
                * high resolution game, machine coded
                * dig for the coals in the earth, but look out for the mice;
                  awake the sleeping snakes to let them eat the mice
                * 5 skill levels, processor speed independent timing loops
                * steering: instructed & redefinable
                * no official exit

FRED            * Fred, author unknown, undated
                * evasive game, in Basic
                * Fred has to reach one of the teleports without being
                  hit by the growing bars
                * growing speed of bars increases each level
                * steering: instructed
                * exit any time by Break

FROGGIE         * Froggie by Richard Braunton, 1983
                * classical game of frogger, machine coded
                * let the frogs reach their home bases but watch out for
                  the road with heavy traffic and the river
                * nice title page and exit page
                * steering: 5/6/7/8 = left/down/up/right
                            F/S     = freeze/start
                * exit at the end of a game by pressing N

GALACTIC        * Battlestar Galactica by Ch. Zwerschke, June 1982
                * space shooting game, machine coded
                * how far can you invade the Ceylon empire to reach the
                  central robots without hitting the caverns or being hit
                * 2 levels of play
                * press 0 or 9 in score-screen to start game
                * steering: instructed
                * exit any time by Break

GALAXY          * Galaxy Warrior by Artic Computing, 1981
                * space shooting game, combination of Basic and machine code
                * free the galaxy from the Klingons
                * 10 speed levels, Klingons can be stationary or moving
                * first shoot the Klingons (K), then go to the exit (O);
                  do not bump into a Klingon; walls and +'s are harmless
                * steering: instructed
                * exit any time by Break

GEKKENHS        * Gekkenhuis by S.S.S., 1984
                * text adventure, in Basic
                * escape from the madhouse and try to reach your home by
                  making the right choices at the right time
                * any wrong choice will bring you back to the starting point
                * varied and amusing locations, characters and texts
                * texts in Dutch
                * exit any time by Stop

GLOOPER         * Glooper by M.P. Crane, Quicksilva, undated
		* pacman game, machine coded
		* smooth and good-looking version of PacMan
		* 7 levels of play and personal hi-score table
		* steering: 6 / 7 = left / right
			    8 / 9 = up / down
			    A	  = halt
			    Enter = resume
			    B/N/M = stop
		* exit any time by Break

GRABEN          * Graben by Thoralf Klatt, 1982
                * game in Basic
                * dig for the ozzes of gold hidden underground, bring them to
                  the bank, but watch out for various hazards
                * you mission is obstructed by granite rocks, collapsing mine
                  galleries and galleries being filled up with water
                * texts in German
                * steering: G to start
                            T / V = up / down
                            F / G = left / right
                * exit any time by Break

GULP-II         * Gulp II by Campbell Systems, 1982
                * the ultimate pacman-type game for the ZX81, machine coded
                * game offers a choice out of 15 mazes
                * 9 tempos, 9 grades, 2 key modes
                * includes extensive instructions and demo mode
                * exit demo-mode by pressing X and then any key of the menu
                * limited number of lasers to shoot the ghosts
                * exit by pressing Q at the main menu

HANGMAN         * Hangman, author unknown, undated
                * word game, in Basic
                * input single letters in order to guess the word
                * at most 9 mistakes are allowed before you `hang'
                * graphical illustration of the gallows
                * texts in German
                * 100 German words are stored in the array W$(100,10); these
                  may be replaced by words of any other language
                * exit any time by break

KALABRIA        * Kalabriasz, author unknown, undated
                * card game, in Basic
                * graphical display of cards, trump card option
                * you will have to know the rules yourself as the program
                  asks for your score instead of calculating it itself...
                * exit any time by Break

KILLER          * Killer by W. Stoopendaal & A. Sickler, undated
                * text adventure, in Basic
                * adventure is located in a house with 5 floors, a lot
                  of rooms, objects and persons
                * commands include help, noord, oost, zuid, west, trap op,
                  trap af, dood[t], pak, verbind etc.
                * texts in Dutch
                * exit any time by Break or Stop

LANDSCAP        * Landscape, author unknown, undated
		* shooting game (scramble), machine coded
                * move your aircraft over the landscape and try to destroy
		  the enemy installations while avoiding their projectiles
                * 6 lives per game
                * steering: 7 / Y = up and down
                            A / S = forward gun and bomb
                            many more combinations possible
                * exit any time by Break

LASERBAS        * Laser Bases, author unknown, undated
                * game of tactics, in Basic
                * destroy the opponent's bases and shield your own
                * the computer and you each own 10 bases with 3 energy units;
                  each base can fire another base (-3 units), shield (-1)
                  or do nothing (-0)
                * an unshielded base is always destroyed when attacked
                * a shielded base is only destroyed if it is attacked twice
                * the computer reveals its moves before you enter them!
                * exit any time by Break

LIFE            * Life, author unknown, undated
                * a simulation of microscopic life, machine coded
                * following fixed rules for birth and death, the evolution of
                  a community of microscopic organisms can be followed in time
                * the organisms live on a 16x16 walled grid (no wrap)
                * program counts generations and determines periodicity
                * texts in German
                * keys: W     = repeat previous pattern
                        Enter = start new random pattern
                        M     = create new pattern yourself (5/6/7/8/P/Enter)
                * exit any time by break

MANUFACT        * TS1000 Manufacturing Control System, author unknown, undated
                * manufacturing aid, in Basic
                * options of the main menu include add/delete part/dept/oper,
                  list file, compute total/part costs, implode/explode part,
                  save and quit
                * up to 150 parts may be defined
                * exit any time by Break

MSTRMIND        * Mastermind by Creative Computing, undated
                * brain game, in Basic
                * try to break the colour code with as few guesses as possible
                * the code is a sequence of 4 colours; each 'digit' of the code
                  can be chosen out of the 6 colours Blue, Green, Orange,
                  Purple, Red and Yellow; a colour may appear more than once
                  in a code, yielding 1296 possible codes
                * guess a code by typing four letters (e.g. "BYOG")
                * black pegs: number of colours on the right position
                  white pegs: number of colours on wrong positions
                * type "BOARD" to see all your previous moves or "QUIT to stop
                * a "master" should win in less than 8 guesses!

MENS-EJN        * Mens Erger Je Niet by Henc de Roo, Herosoft, 1983
                * board game, in Basic
                * move your four pegs around the board to your home base
                  but don't let the opponent capture your pegs
                * two-player version: you against ZX81
                * all rules incorporated properly
                * really entertaining if you are stress-proof, know the rules
                  and have some spare time
                * texts in Dutch
                * exit any time by Break

MILLION         * Millionaire by Creative Computing, 1982
                * text adventure, in Basic
                * your life starts in 1982 and by making the right decisions
                  during your life, you may get old and rich
                * claims IBM means `Incredibly Bad Machines'
                * exit any time by break

MONEYGRB	* Moneygrabber by J. Dave Rogers (Hogroprog), January 1984
		* evasive game, combination of Basic and Machine Code
		* collect the money of the same type as the man is (pounds
		  initially) while the screen scrolls upward
		* collecting wrong objects will decrease the score
		* steering: instructed (several options)
		* exit any time by Break

MONITOR         * Monitor & Disassembler by Ian Stamp, Crystal Computing, 1982
                * very versatile monitor and disassembler, machine coded
                * after loading, type RAND USR 28416 to start
                * commands are issued by a single letter; commands include:
                  - Assign <reg>=<value> : set single/double register value;
                    examples: Assign HL=400C, Assign B"=7F etc.
                  - Break <addr> : set breakpoint
                  - Copy <begin>,<end>,<to> : copy data block
                  - Disassemble <addr> : disassemble, exit by pressing space
                  - Edit <addr> : edit memory; type hexnumber to change value,
                    S and J to change address, Q to stop
                  - Find <begin>,<end>,<byte> : find byte in given interval
                    Find <begin>,<end>,"<text>" : find text in given interval
                  - Goto <addr> : execute program at <addr>
                  - Insert <len> : create free space of <len> bytes inbetween
                    last program line and display file (preceeded by FFh byte)
                  - Jr <from>,<to> : calculate offset for a relative jump at
                    address <from> to address <to>
                  - Konvert <num> : convert hex to dec and vice versa
                  - Print <addr> : show character contents of memory block
                  - Reg : show register contents (useful after Goto with Break)
                  - Tabulate <addr> : show hex contents of memory block
                  - Xit : enter to confirm
                  - Zero <start>,<end> : fill memory block by spaces (00h)
                * numbers may be typed hexadecimal or decimal; decimal numbers
                  must be preceeded by a pound sign (Shifted-Space)
                * many commands take useful defaults when no parameters are
                  typed by the user

MUSIC-ED        * Music Educator, author unknown, undated
                * educational program on musical notes, in Basic
                * teaches the notes on the treble or G clef staff
                * subjects include appearance of notes A thru G, eight,
                  quarter, half and whole notes, bar lines, time signature,
                  beats in 4/4 meter
                * program also takes tests with intermediate results, final
                  result and grade
                * notes are displayed graphically
                * exit any time by Break

NGHTMARE        * ZX Nightmare Park by J.D.S. Cranston, 1981
		* graphical and text adventure in Basic
		* you must make your way through the park, but the shortest
		  route may not be the best
		* all kinds of tests need to be passed before reaching the
		  finish; failing any test ends the game
		* exit any time by Break or Stop

NIGHTDRV        * Nightdriver by Ch. Zwerschke, 1982
                * car driving game, machine coded
                * keep your car in the middle of the road
                * very narrow and bendy road!
                * steering: Q..T : left
                            Y..P : right
                * exit at the end of a game by break

OLYMPIAD        * Olympiade by Walther Messing, 1985
                * olympics game, machine coded
                * you have to play six olympic sports: 100 meters, long jump,
                  discus throwing, javelin throwing, 400 meters and hurdle race
                * nicely animated athletes, one or more named players
                * moving stands, texts in German
                * steering: all movements can be controlled by keys 5, 8
                  and 0 (depending on skill)
                * exit any time by Break

OTHELLO 	* Othello by C. Panayi and P.E. Canter, September 1981
                * brain game, in Basic
		* outflank your opponents pieces but don't get your own pieces
		  be outflanked
		* instructions included
		* 8x8 board, 2 levels, nice layout
		* remains exciting up to last move
		* exit any time by Break

PACMAN          * Pacman by Philip Harwood, undated
                * the classical pacman game, machine coded
                * all the well known features of the original game included
                * smooth action graphics, 4 ghosts, power pills etc.
                * steering: instructed
                * no official exit

PACMAZE1        * PacMaze 1, author unknown, undated
                * variation of the pacman game, combined Basic and machine code
                * try to clear the screen of dots while avoiding the ghosts
                * six mazes (named A thru F) available; these have to cleared
                  one by one
                * ghosts move very quickly, making winning hardly possible
                * steering: instructed
                * exit any time by Break

PACMAZE2        * PacMaze 2, author unknown, undated
                * variation of the pacman game, combined Basic and machine code
                * the same program as PACMAZE1, but configured for six other
                  mazes (G thru L); please refer to PACMAZE1 for more info

PAINTER         * Painter, author unknown, undated
		* evasive game in Basic
		* try to paint the wall entirely grey while avoiding the
		  borders, the obstacles and your own paint
		* texts in Dutch
		* steering: unshifted cursor keys
                * exit any time by Break

PAIRS		* Pairs by P. Rushton, 1982
                * brain game in Basic
		* the computer and you take turns in turning over two cards
		  with the goal of collecting equally valued pairs
		* simple yet warned to be addictive
		* use pen & paper to cheat
                * exit any time by Break

PANZER          * Panzerschlacht by H. Stamm, 1982
                * tank shooting game, machine coded
                * two players each control a tank and have to hit the enemy
                  tank as often as possible without bumping into any wall
                * game ends when a tank hits a wall, texts in German
                * steering: Z / B = rotate anti-clockwise
                            X / N = rotate clockwise
                            C / M = move forward
                            V / . = fire
                * exit by driving a tank into a wall and pressing Break

PONTOON 	* Pontoon by C. Panayi, August 1981
		* card game in Basic
		* try to break the bank by getting as close to (but not
		  exceeding) 21 with you cards
		* options include stick, twist and buy
		* exit any time by Break or Stop

PRINCESS        * Princess of Kraal by N. Streeter, undated
		* graphical and text adventure in Basic
		* find the Princess of Kraal while you wander through the
		  multi-room multi-level building in which she is hidden
		* 300 (!) levels, 65535 mazes, 10 playing times
                * exit any time by Break

RECTANGL        * Rectangles, author unknown, undated
                * board game, in Basic
                * try to fill large portions of the 26x20 playing board
                  with your stones by setting up corners
                * rules are a bit mystical and the articifical intelligence of
                  the program is doubtable, despite its large size
                * exit any time by Break

SCOTSMAN        * 4472 Flying Scotsman, author unknown, undated
                * text adventure, in Basic
                * guide the train called `Flying Scotsman' safely from
                  London Kings Cross to Edinburgh
                * total length 400 miles, 450 minutes with stop in Newcastle
                * you control the speed by adjusting the steam inlet from
                  1 through 8 or decelerating (-1)
                * general speed limit of 100 miles per hour, steam pressure
                  limit of 220 pound force per square inch
                * special speed limit near main stations
                * screen shows route, speed, distance travelled, time taken,
                  time according to schedule, angle of inclination etc.
                * all texts in Dutch
                * exit any time by Stop

SIMDOS2         * SIMDOS/2 version 0.04 by Carlo Delhez, June 1992
                * RAMdisk driver, machine coded
                * after loading, the program is copied to the 8-16k section,
                  starting at address 14000; commands are issued as follows:
                  PRINT USR 14000;"<commands>"
                * available commands are (separate them by ';')

                   DEL:<name>.<type>:           delete file
                   DIR:                         show directory
                   FORMAT:<addr>:<len>:         format disk & show directory
                   LB:<name>:                   load basic program (.B)
                   LC:<name>:<addr>:            load code file (.C)
                   LL:<name>:                   merge basic lines (.L)
                   LP:<name>:                   load complete program (.P)
                   LS:<name>:                   load display file (.S)
                   RUN:<name>:                  load & run program (.P)
                   SHOW:                        show help screen
                   SB:<name>:                   save basic program (.B)
                   SC:<name>:<addr>:<len>:      save code block (.C)
                   SL:<name>:<1st>:<last>:      save basic lines (.L)
                   SP:<name>:                   save complete program (.P)
                   SS:<name>:                   save screen (.S)

                * the commands SBO, SCO, SLO, SPO, SSO are the same as the
                  ones without the 'O' but they will delete a file of the
                  given name first (when it exists) and then save the data

                * examples: "FORMAT:32768:16384:" : format 16k disk at 32k
                            "SS:TEST:;DIR:"       : save screen, show directory
                            "SC:ROM:0:8192:"      : save ROM code
                            "DEL:TEST.S:"         : delete screen file

                * error messages: E : lines merged
                                  H : file already exists
                                  I : linenumber does not exist
                                  J : syntax error
                                  K : file not found
                                  L : format error
                                  M : out of memory (disk full)

                * type NEW after loading to clear ZX81 memory; the RAMdisk
                  is preformatted for 32760 bytes at address 32768

SMAUGS		* Smaugs Lair by N. Brooks, undated
		* shooting game in Basic
		* you are a gunner captain on a mission to destroy dragons
		  castle with just 5 cannons and 12 cannonballs
		* beware... the sound of cannons wakes the dragon
		* variable power and angle, multi-screen graphical action
		* exit any time by Stop or Break

SPACEINV        * Space Invaders, author unknown, undated
                * classical space shooting game, machine coded
                * short but very fast very version of space invaders
                * due to high speed, hardly playable
                * steering: instructed
                * exit at the end of a game by Break

STARFGHT	* Starfighter by J.K. Greye, October 1981
		* space shooting game, combination of Basic and Machine Code
		* you are fighting at the end of the universe; the enemy
		  are trying to destroy your civilization; hit as many craft
		  as you can before your energy runs out
		* replay after 20 hits
		* steering: 1 7 2
			    5	8 = all directions; 0 = fire
			    4 6 3
		* exit any time by Break

SWAMP		* Perilous Swamp by Psion Computers, undated
		* text & graphical adventure in Basic
		* you are located in a swampy forest; find your way out,
		  alive, with as much treasure as possible and try to save
		  the beautiful princess being held by an evil wizard
		* only few verbs recognized
		* exit any time by Break

TAI             * Tai by B. Burdett, Personal Software Services, 1983
                * space shooting game, machine coded
                * defend the planet Tai against imperial ivaders trying to
                  reach the core of the planet until the republican battle
                  fleet arrives
                * two stages; the second stage can be reached when enough
                  fireballs and ghosts are shot in the first stage
                * well groomed graphics and animation
                * steering: instructed
                * no official exit

TASWORD         * Tasword by Tasman Software, 1982
		* word processor, machine coded
		* one of the rare, quite useful wordprocessors for the ZX81;
		  options include Centerline, Justify, Unjustify, Deleteline,
                  Insertline, Top, Bottom, Wordwrap, Help, etc.
		* extensive tutor included as Tasword file
		* exit by pressing STOP (Shift-`A') and option `Z'

TELEPHON        * Telephone address book, author unknown, undated
                * telephone directory, in Basic
                * configured to hold up to 50 telephone numbers
                * with full 48k (RAMtop at 65535) up to 340 entries possible
                * main menu offers the options: search, make, alter or delete
                  entries and save
                * 7 datafields hold title, initials, surname, address (up to
                  4 lines), additional info, telephone area and number
                * exit any time by Stop

TENNIS          * Tennis by Ch. Zwerschke, undated
                * classical computer tennis, machine coded
                * two-player game of tennis; bounce back the ball at your
                  side by moving the bat up and down
                * game ends when a player has 10 points
                * 9 speed levels, texts in German
                * steering: 2 / Q = left bat up and down
                            U / H = right bat up and down
                * exit when level is requested

TENPIN		* Ten Pin Bowling by Dr. D. Nowotnik, Phipps Associates, 1982
		* simulation of ten pin bowling game in Basic
		* 1 or 2 players, 10 frames, up to 2 balls per frame
		* supports strike and spare
		* variable strength and position of delivery; increasing the
		  strength decreases the accuracy
		* extensive instructions
		* exit any time by Break

TEXTPRO 	* Text-Pro V4 by M.J.J. Pantus, 1984
		* screen/text-editor, machine coded
		* simple to use text-editor (no graphics or word processing
		  features) for 21x31 screenpage
		* options: edit, scroll, invert, print, help and clear$
		* storage to and retrieval from tape (i.c. disk) or memory
		  (up to 10 pages)
		* uses the `TP-SLAVE' file (also on this disk)
		* no official exit

TFO		* The Fast One by Campbell Systems, undated
		* database, machine coded
		* one of the few quite useful databases for the ZX81
		* start by  GOTO USR R
		* options include: define items, add/update/delete records,
		  format report, select record/report, display/print
		* you will need a manual to understand the report format!
		* exit by selecting option "V" (Save) at the main menu
		  and then inputting STOP

TP-SLAVE	* Text-Pro Slave by M.J.J Pantus, 1984
		* slave file of `TEXTPRO' screen/text-editor; see there

TRIANGLE        * Triangles, author unknown, undated
                * mathematical program, in Basic
                * a triange may be defined by the lengths of its three sides,
                  by its three angles and/or by its area; this program requests
                  any 3 of these 7 variables and calculates the other 4
                * error reported if input does not define a realistic triangle
                * option of units included
                * exit any time by Break or Stop

VIER2           * Vier Gewinnt, author unknown, undated
		* brain game, in Basic
		* a two-player game in which each player must try to get four
		  blocks of his colour in a straight line (horizontally,
		  vertically or diagonally)
                * players take turns, blocks are dropped as in the real game
                * current player indicated in top screen corner
                * program tests for a winner, texts in German
		* exit any time by Break

WILDWEST        * Wild West by Ch. Zwerschke, 1982
                * western shooting game, machine coded
                * two players have a gunfight against each other
                * game ends when a player has scored 10 hits
                * steering: S/A/E   = left player up/down/shoot
                            J/H/I   = right player up/down/shoot
                            Shift-A = stop game
                * exit by pressing Shift-A followed by Break

WORDMAST        * Word Mastermind by C. Panayi and P. Canter, October 1981
		* word game, in Basic
		* guess the five-letter word by using the mastermind-coding
		* more extensive instructions included
		* up 30 guesses allowed
		* quite difficult if you stick to the rule that only real
		  English words are allowed as guesses
		* exit any time by Break or Stop

WORDSCRM        * Word Scramblings, author unknown, undated
		* word game, in Basic
		* unscramble the five words presented by the computer against
		  the clock
		* extensive instructions included
		* exit any time by Break

ZXAS0           * ZXAS `Code Loader' by Bug Byte Software, 1981
                * assembler, machine coded
                * lowers RAMtop to 27648, copies the 5k of ZXAS code above it
                  and then loads the file ZXAS1 which contains the BASIC part
                  of the compiler
                * see ZXAS1 for more details

ZXAS1           * ZXAS `Compiler' by Bug Byte Software, 1981
                * assembler, machine coded
                * this part must loaded when the machine code of ZXAS is
                  already present above RAMtop: see ZXAS0
                * source can now be typed in REM lines 1 through 8999
                * type RUN to compile the source
                * start source by a REM line containing a single '(' and end
                  the source by a REM line containing a ')'
                * comment lines are started by an asterisk ('*')
                * up to 256 labels (:L0 through :L256)
                * all Z80 mnemonics available; use '.' instead of ','
                * more instructions per line are to be separated by ';'

ZXASDEMO        * ZXAS Demo Source by Carlo Delhez, May 1992
                * demonstration of ZXAS source listing
                * ZXAS0 must have been loaded previously
                * type `LIST' after loading to see source lines
                * demonstrates mnemonics, numbers, comments and labels
                * note: indented lay-out is not necessary and may be avoided
                  for reasons of available memory (about 10k free)
                * assemble by typing `RUN' and entering (for example) 27000
                * after assembly, type `RAND USR 27000' to execute code

ZXASSEM         * ZX-Assembler, original version by D.P.Aknai and M.Streeton,
		  Artic Computing Ltd., 1982
		* excellent assembler, machine coded
		* resides above RAMtop; must be lowered to 25684 before loading
		* invoke by RAND USR 3E4
		* has its own editor; very fast assembly
		* the source code is stored in line 2, object code in line 1
		* use of the improved ZXASSEM2 (see below) is advised!
		* most options can be quitted by pressing Q or Shift-Q
		* exit assembler by pressing Q twice at main prompt

ZXASSEM2	* ZX-Assembler-2, revised version by Carlo Delhez, 1991
		* rewritten version of the excellent Assembler, machine coded
		* this version resides in line 0; the source code is stored
		  in line 2, the object code in line 1
		* Type	LET OC=USR 16516  then assemble your source and quit;
		  on return, OC holds the start address of the object code
		* ORG directive is added; use COPY option after assembly
		* use ORG +16516 and remove line 0 to get proper `1 REM' code
		* more extensive manual available on request
		* most options can be quitted by pressing Q or Shift-Q
		* exit assembler by pressing Q twice at main prompt

ZXASTERD	* ZX Asteroids, author unknown, undated
		* space shooting game, machine coded
		* destroy the asteroids before they crash into you
		* asteroids fall apart into fragments which have to be
		  cleared away too
		* steering: 7 = start (unshield)
			    2 = rotate anti-clockwise
			    4 = rotate clockwise
			    8 = start moving / change direction
			    0 = shoot
		* no official exit

ZXCHESS2	* ZX-Chess-II by Artic Computing, 1981
		* chess game against ZX81, machine coded
		* start by entering `GOTO 2'
		* Play and analyse option; 6 levels; play black or white
		* chess-men: K = King, Q = Queen, B = Bishop, N = kNight,
		  R = Rook (castle), I = pawn
		* Play:    - type move as e.g. B1C3 (enter)
			   - O = review last moves
			   - S = restart (e.g. to analyse)
			   - T = time-out (?)
			   - Z = cursor home (it's better to use backspace!)
		* Analyse: - A3WKXX puts white king at A3
			   - F8XXXX clears F8
			   - XXXXXX clears whole chess-board
			   - QQQQQQ to quit analyse and start game
		* Load: don't use it!
		* hitting `Enter' halfway the editor distorts the screen;
		  just use backspace to correct
		* no official exit

ZXDB            * ZX Disassembler/DeBugging program by Bug-Byte, 1981
                * powerful machine programming utility, machine coded
                * can be used together with ZXAS(0/1) to test programs
                * type RUN to start ZXDB; main prompt is an asterisk (*)
                * hexadecimal values are requested by an = prompt
                * summary of commands (activated by a keypress):

                  *A : view memory as characters; = start
                  *B : breakpoint; = breakpoint address; = execution address
                       when breakpoint is reached, registers and memory
                       contents are displayed; use the following:
                        - NewLine : perform single step
                        - G       : continue program normally
                        - nnnnN   : single-step next nnnn instructions
                        - O       : display mnemonics only
                        - nnnnP   : set breakpoint at nnnn
                        - Q       : return to main prompt
                        - R       : call subroutine, single step on return
                        - nnnnT   : single step if a double reg contains nnnn
                        - nnnnW   : set memory window at nnnn
                        - Z       : set register (e.g. A7F for A:=7F)
                  *C : compare blocks; = start 1st; = end 1st; = start 2nd
                  *D : disassemble program; = start
                  *E : hex loader; = start address
                  *F : fill memory; = value; = start; = end
                  *G : execute program; = start address
                  *M : move memory block; = start; = end; = destination
                  *Q : quit, return to Basic
                  *S : search memory for hex string; = hex; = start. Example:
                       = 2D.2A.31.31.34. > looks for "HELLO"
                       = CD.FF00.1F00.   > masked compare: looks for a ROM call
                  *V : view memory hexadecimal; = start
                  *W : set height of display; = number of lines

                * most commands can be cancelled or quitted by Edit or Q
                * the disassembly presents a strange combination of Zilog Z80
                  and Intel 8080 mnemonics

ZXSTDEMO        * ZX Stuff Demo by H. Stamm and Ch. Zwerschke, undated
                * demonstration of ZX Stuff, combined Basic and machine code
                * demonstrates the use of the various ZX Stuff commands
                * texts in German
                * see 'ZX Stuff' for more information

ZXSTUFF         * ZX Stuff by H. Stamm and Ch. Zwerschke, undated
                * Basic programming tools, machine coded
                * adds 13 new commands to ZX81 Basic which can be accessed
                  by combined POKEs and USR calls
                * commands include Fill, Reverse, Frame, Memory Usage, Screen
                  Save and Load, Scroll up/down/left/right, Point & connect
                * code resides in line 1
                * to use: delete all lines except 1 and add your own program

<*** End of File ***>
