Electron User 2.11 (Acorn Electron) - Everygamegoing.com

Electron User 2.11 (1985) (Acorn Electron, Cassette) United Kingdom
 
 
Publisher: Database Publications
Database Educational | Database Publications | Database Software

Contents: Asteroydz (Database Publications), Digga (Database Publications), FX2 Program 2 (Database Publications), FX2 Program 3 (Database Publications), FX2 Program 4 (Database Publications), Hexagram (Database Publications), M/Code Program 1 (Database Publications), M/Code Program 2 (Database Publications), M/Code Program 3 (Database Publications), M/Code Program 4 (Database Publications), M/Code Program 5 (Database Publications), M/Code Program 6 (Database Publications) and Moveit Puzzler (Database Publications)

Cover Art Language(s): English

Machine Compatibility: Acorn Electron

Release: On Cassette (Side 1

)

Compatible Emulators: Elkulator 1.0 (PC (Windows))

How To Play

Game Information

Original Release Date: 1st Aug 1985
Original Release Price: Unknown
Market Valuation: £2.50 (How Is This Calculated?)
Weight Boxed: 64g
Box Type: Cassette Single Plastic Clear

 

There are no users who want to buy a copy of this item.
(Browse Most Wanted)

Asteroydz (Acorn Electron Version, 0 Screenshots)

Digga (Acorn Electron Version, 0 Screenshots)

FX2 Program 2 (Acorn Electron Version, 0 Screenshots)

FX2 Program 3 (Acorn Electron Version, 0 Screenshots)

FX2 Program 4 (Acorn Electron Version, 0 Screenshots)

Hexagram (Acorn Electron Version, 0 Screenshots)

M/Code Program 1 (Acorn Electron Version, 0 Screenshots)

M/Code Program 2 (Acorn Electron Version, 0 Screenshots)

M/Code Program 3 (Acorn Electron Version, 0 Screenshots)

M/Code Program 4 (Acorn Electron Version, 0 Screenshots)

M/Code Program 5 (Acorn Electron Version, 0 Screenshots)

M/Code Program 6 (Acorn Electron Version, 0 Screenshots)

Moveit Puzzler (Acorn Electron Version, 0 Screenshots)

Cover Art

Front Cover

Where To Get It

A digital version of this item can be downloaded right here at Everygamegoing (All our downloads are in .zip format).

Download What It Contains
A digital version of Electron User 2.11 suitable for Elkulator 1.0 (PC (Windows))
A digital version of Electron User 2.11 suitable for Elkulator 1.0 (PC (Windows))

Instructions


Asteroydz | Digga | Hexagram | Move It!

ASTEROYDZ

Run the gauntlet of the asteroids as you try to deliver the goods in this nailbiting game by Himesh Shah

ASTEROYDZ It's not that easy being a space ferry pilot. Not only is deep space far less interesting than it's cracked up to be, it's also full of dangerous asteroids.

The trouble is that you don't have enough money to pay for your passage back to earth. To earn it you've got to run the gauntlet of the asteroids, delivering supplies.

Should you be successful as a comic errand boy you can get back to earth, but crash ten times and you get the sack. And as time goes on, things get harder.

As we said at the beginning, it's not easy being a space ferry pilot...

Procedures
PROCrnd_screen Sets up the asteroids in their random positions and stores these locations in memory at ast%
PROCgame This is the main procedure, responsible for the flow of the game
PROCmove Responsible for the movements of the ship and checking to see if a bomb is to be dropped
PROCcheck Checks to see if the ship has hit an asteroid or if either end of the screen was reached
PROCsmash Called if you crash. It tells you how many ships you have left and displays an explosion
PROCscroll Creates the moving asteroid effect
PROCbomb If the SPACE bar has been pressed this procedure displays the dropping bomb
PROCupdate After every crossing this procedure tells you how much money you have in the bank and the total number of crossings you have made
PROCend As you might guess this is called at the end of the game. It tells you how much you've earned
PROCinit Initialises all variables and defines the characters and envelopes
PROCwin1
PROCwin2
PROCwin3
Called on completion of appropriate level
PROChiprint
(xb%,yb%,word$,size%)
Prints word$ at text coordinations xb%,yb% size% characters high
PROCwait(pau%) Creates a pause. The larger the value of the parameter pau% the longer the pause

DIGGA

Dig for diamonds - and dear life in this arcade classic devised by Stephen Martin

DIGGA As an interpid adventurer you decide to risk your fortune in the infamour Scrubble mines. All seems well until you meet the afore mentioned Scrubblie - one touch from him and you're doomed.

To help you combat this menace the mine provides the explorer with some weapons, namely the rocks. One bash on the head from these and the Scrubblie is crushed, but unfortunately another immediately takes its place.

Scrubblies aren't the only danger lurking in the mines - the place is infested with poisonous toadstools.

Your objective is to collect all the diamonds which are scattered around the caverns. Points are scoring for bashing Scrubblies, dropping rocks and collecting diamonds.

We think you'll dig this arcade classic!

Variables
SC% Score
LI% Lives left
L% Level
DI% Diamonds collected
scr% Screen number
HI%() High score table
HI$() High score names
 
Procedures
PROClevel Prints graphics for each level
PROCtitle Prints control keys
PROChi Prints high score table
PROCscreen Prints earth and bricks
PROCinit Initialises the graphic and sound
PROCpause Waits for a key to be pressed

HEXAGRAM

A compulsive educational board game by Andrew Kane

HEXAGRAM HEXAGRAM was written originally for children. I had earlier written one or two educational programs for my young son but he quickly tired of them because there was no game element in them.

HEXAGRAM now overcomes this by producing anagrams coupled to a board game which suits both child and adult players.

Two levels of play allow children to play adults as well as other combinations. The game helps with word recognition, spelling and vowel/consonant sequence.

A 4 x 4 grid of hexagons appears on the screen, each containing a letter. The players are coded blue and white. The text appears in these colours alternately to indicate the sequence of play.

The player selects a letter. A word staring with that letter appears in anagram form.

A clock starts the countdown from sixty seconds, during which time the anagram must be solved.

For a correct answer the hexagram containing the selected letter changes to the player's colour.

The first player to create a path across the screen - the blue player - or down the screen - the white player - is the winner. Blocking tactics can be employed.

The words are rearranged in memory during play so that they can only be encountered again after five selections of the same letter.

The text remains on screen for several seconds at each stage of the game so that children - and adults! - can read and learn the correct answers.

If instead of the Electron the game is played on a BBC Micro you may need to change PROCwait(J%) to increase the time span. Also VDU 23,1,0;0;0;0; must be switched to VDU 23;8202;0;0;0;

The data is plentiful. A total of 230 words are used, but this ensures an interesting competitive game. The words can be changed readily.

Young children may need three and four-letter words. Do not exceed eight letters or problems of screen layout may occur.

Try to avoid anagrams with more than one solution - such as one for QUITE which could be QUIET.

The most complex aspect of the program is the routine to check for a winning line. Initially I was tempted to allow the players to determine if there was a winner, but I felt this was ducking the issue.

The outcome is about sixty lines of program split into seven procedures.

There are scores of winning paths, some being very serpentine, so a complicated analysis routine was required.

Method of checking for winning line
A two-dimensional grid is stored in memory and, before the game starts, some locations outside the playing area are filled with value 1 (line 970) to assist the checking routine.

Each correct reply from the players is placed on the grid as value 1 or 3, depending on the colour of the player.

The computer, when checking vertically for a winning line, searches row 1 for a 3 and drops down to row 2 if successful. If unsuccessful it aborts the routine.

It then looks either side of that column which in row 1 contained a 3. It continues to do this until row 5 is reached, whereupon it declares a winning line.

If a dead end is found it changes the numbers in the grid leading to the dead end - and restores their values after completing the check.

The routine is now repeated, without that dead end, until a route is found or not found.

Extra routines are required when checking vertically since a winning line may move down, up and down a series of columns between rows 1 and 5 - hence PROCup.

The horizontal checking routine is similar. Column 1 is checked for a 1 and then the adjoining rows are scrutinised as described earlier.

PROCdiag checks for unusual winning lines by the BLUE player.

Variables
xpos%, ypos% Coordinates of hexagon centres
let% Numbers for letters used in game 1-23 (not x,y,z)
G%(R%,C%) Two-dimensional grid in memory only to check for winner
cos%,sin% Values to enable hexagons to be drawn in segments
int%,seg%,num%,loop% Sequential integers used in FOR...NEXT loops
col% Colour of hexagon
store% Temporary store for num%
word$ Words used int he game
chr$ Individual letter store of word to be scrambled
let$ Letter chosen by player
store$ Stores the answer one letter at a time
file$ Stores letters previously selected to check illegal moves
reply$ Stores player's answer
keep$ Stores letters in hexagons to check for illegal choice
T$ Temporary store for letters during scrambling routine
W% Takes value 1 when winning line occurs
Q% Colour of current player
A% Determines order of play at start
I% Sequential integers in FOR...NEXT loops
L% Temporary store for C%, also used as sequential integer
T% Flag to cause changes in checking routine
F%,E$ Codes for whether easy or hard words selected
R% Row number of grid for checking for winning line
C% Column number of grid for checking for winning line
S% Flag to indicate a successful search around one hexagon

MOVE IT!

John Woollard converts one of his favourite childhood games for the Electron

MOVE IT! Many years ago I remember having a little plastic puzzle made of squares with letters on each one. The object was to move the tiles around until the letters were in the correct sequence.

Now I've brought it up to date with a program that takes all the hard work out of the job.

The puzzle starts with the fifteen piexes in a random order on the 4 x 4 grid.

A title has to be moved into the vacant space, thus creating a new space. A piece can then be moved into that space, and so on until the letters are all returned to their correct position and the space is at the bottom right-hand corner.

The program has been written in a structured way which gives it two benefits.

First, it's easier to understand how it works. The sequence of events is outlined in the first 37 lines.

Second, it's simpler to debug when copying from the page of the magazine as each section of program has a single, identifiable task to complete.

Lines 10 to 370 make up the "control module" which calls all the major procedures and functions. All variables and procedure/function names are given in lower case letters. All number variables are followed by a percent sign, such as move%.

Lines 90, 140 and 280 shouldn't be typed in until your program has been thoroughly tested. Line 90 makes sure that the program is not lose if BREAK is pressed, while line 140 prevents the ESCAPE key from stopping the program.

If ESCAPE is pressed while the puzzle is being played, then the micro plays the moves for you.

Although Mode 1 could have given a greater variety of colours on the screen, Mode 4 had to be used for this puzzle because there's a shortage of memory. The computer will remember up to 4000 moves - that is nearly 4K of memory.

Only two colours are permitted on the screen at any one time in Mode 4. If the chosen colours of black upon red aren't to your liking, then you can change them at line 120 and 130.

For an explanation of the VDU19 statement see pages 102/103 of the User Guide.

The first procedure initialises variables and also sets up a machine code routine to print double-height characters.

After the user has entered his or her name, the micro enters a series of nested REPEAT...UNTIL loops.

The first section deals with how the computer sets the problem that the user has to solve. The second part deals with how the user solves the problem.

The micro starts with the grid in its final - solution - position and moves pieces in a random way, destroying the pattern.

As it does so, it remembers the moves it is making. The computer therefore knows how to move back to the final solution at any time by making these same moves but in reverse order.

Pieces can be moved into a psace in up to four different ways - left, right, up and down. However, if the vacant space is on the top line it's not possible to move a piece down into it.

The function FNlegal checks to see if a proposed move is legal. It's used both in the first section, when the computer is setting up the problem, and in the second part, when the user is trying to solve the problem.

The number of moves the computer makes when setting up the problem is proportional to the level of play.

The grid is stored as a string variable grid$ and the final solution stored in home$. This final solution is where all the letters are in the correct order and the space is in the last position on the grid. In other words:

   home$="abcdefghijklmno "

The computer knows when the user has reached this position because the contents of grid$ will equal the contents of home$.

After a legal move has been chosen - by the computer in the first part when it is setting the problem, or by the user in the second part - the Electron then operates upon grid$, to make it represent the new position.

This is carried out in the procedure PROCupdategrid. The new grid is then displayed by the procedure PROCgriddisplay.

The program contains three utilities that you may wish to add to your own programs. They are:

  • PROCprint which prints double-height characters in all the graphic modes

  • FNinput which is the same as an INPUT statement in Basic but the characters entered are printed in double height

  • FNyesno which waits for the key Y ot the key N to be pressed

The procedure that prints double-height characters has a machine code call in it. This machine code program, fully explained in the July 1984 Electron User, is set up in the initialisation procedure.

Finally, if you wish to personalise your copy of the program try changing the title that is displayed. Line 400 contains that string.

You may wish to add sound cues on illegal moves or perhaps a tune when the user succeeds in getting the final solution.

Level 0 1 2 3 4 5 6 7 8 9
Moves 1 2 3 4 16 32 64 128 256 512

Procedures/Functions
autoplay Called if ESCAPE is pressed. It directs the computer to play all the moves to reach the solution
endmessage After the solution has been found, the user is given the choice to carry on or to stop the program. If the user carries on then they may choose to mvoe to the next level of difficulty
FNgetmove The computer waits for one of the arrowed (cursor) keys to be pressed
griddisplay Prints the present grid ont he screen by interpreting grid$
FNinput This is a double-height INPUT statement
print Prints a string in double-height characters at a specified location on the screen
FNrndmove This function returns a random number from 1 to 4 inclusive. It checks that it is not the complement of the previous number. That is, if the last move was down then this move will not be set up
sound Causes a beep of a random sound. The sounds are true musical notes
updategrid Changes the string grid$ to reflect the new position of the pieces
FNyesno Waits for Y or N to be pressed and returns the value 1 for yes and 0 for no

Electron User 2.11 is Item ID 3502 in our database. Last modified on Monday 15th July 2019 at 08:11:47 PM.

Spotted a typo or inaccuracy in the instructions for this item? and we'll fix it up at once!