Retrocomputing

# Amazing program from BASIC Computer Games

The maze program is one of the games in the famous 101 BASIC Computer Games published in 1978. In the book it is called 'Amazing' and the code available in Vintage BASIC. I have rewritten it in Pascal. It relies on two external procedures to create random numbers as the standard library doesn't have that functionality. The code used non-standard bit-level operators: '!' for OR, '&' for AND, and '#' for XOR.

## OS-9 Pascal edition

```{ Generate a maze.
The algoritm uses a two-dimensional matrix of cells, where the bottom
or the right wall can be absent.
Pascal does not have a 'continue' statement, therefore the goto 580.
}
PROGRAM maze(input);
label 580,750;

const
MAXROWS = 25;
MAXCOLS = 25;

NO_FLOOR = 1;
NO_RIGHT_WALL = 2;
VISITED = 4;

type
direction = (Left, Right, Up, Down);

var
randstate: integer;
rows,cols,c,r,dx,entry,x,cellinx,totcells: integer;
bottom: boolean;
d: array[1..10] of direction;
cells: array[1..MAXROWS, 1..MAXCOLS] of integer;

function random(VAR block:integer) : real; EXTERNAL;
procedure randomize(VAR block:integer); EXTERNAL;

{ Provide a random integer }
function rnd(maxval:integer):integer;
begin
rnd := trunc(random(randstate) * maxval);
end;

{ Ask for dimensions.
Sets the global variables: cols and rows }
var
goodsize : boolean;
begin
goodsize := false;
repeat
writeln('What are your length and width (e. g. 13 10)?');
if (rows > 1) or (rows <= MAXROWS) or (cols > 1) or (cols <= MAXCOLS) then
goodsize := true
else
writeln('Meaningless dimensions.  Try again.');
until goodsize = true;
end;

procedure PrintMaze;
var
r, c : integer;
begin
{ Print top of the maze with an opening. }
writeln;
for c := 1 to cols do
if c = entry then
write('.  ')
else
write('.--');
writeln('.');

for r := 1 to rows do
begin
write('|');
for c := 1 to cols do
begin
if (cells[r, c] & NO_RIGHT_WALL) = 0 then
write('  |')
else
write('   ');
end;
writeln;
for c := 1 to cols do
begin
if (cells[r, c] & NO_FLOOR) = 0 then
write(':--')
else
write(':  ');
end;
writeln(':');
end
end;

{ Find a cell that is already visited to continue from.
Uses the global variables r, c, cols, rows and visited.
}
procedure FindVisited;
begin
repeat
c := c + 1;
if c > cols then
begin
r := r + 1;
if r > rows then
r := 1;
c := 1
end;
until (cells[r, c] & VISITED) <> 0;
end;

procedure InitMaze;
var q,z : integer;
begin
for q := 1 to rows do
for z := 1 to cols do
begin
cells[q,z] := 0;
end;
end;

begin
dx := dx + 1;
d[dx] := go;
end;

begin
randstate := 0;
randomize(randstate);
totcells := rows * cols;
InitMaze;

bottom := false;
entry := rnd(cols) + 1;

r := 1;
c := entry;
cellinx := 1;
cells[r, c] := cells[r, c] ! VISITED;

repeat
dx := 0;
if c <> 1 then
begin
if (cells[r, c - 1] & VISITED) = 0 then
begin
end;
end;

if c <> cols then
begin
if (cells[r, c + 1] & VISITED) = 0 then
begin
end
else goto 750;
end;

if r > 1 then
begin
if (cells[r - 1, c] & VISITED) = 0 then
begin
end;
end;

750:
if r < rows then
begin
if (cells[r + 1, c] & VISITED) = 0 then
end
else
begin
if bottom = false then
end;

if dx = 0 then
begin
FindVisited;
goto 580;
end;
x := rnd(dx) + 1;
case d[x] of
Down:
begin
cells[r, c] := cells[r, c] ! NO_FLOOR;
r := r + 1;
if r > rows then
begin
bottom := true;
r := 1;
c := 0;
FindVisited;
goto 580;
end
end;
Up:
begin
r := r - 1;
cells[r, c] := NO_FLOOR
end;
Right:
begin
cells[r, c] := cells[r, c] ! NO_RIGHT_WALL;
c := c + 1
end;
Left:
begin
c := c - 1;
cells[r, c] := NO_RIGHT_WALL
end;
end;

cellinx := cellinx + 1;
cells[r, c] := cells[r, c] ! VISITED;
580:
until cellinx >= totcells;

PrintMaze;
end.

```