program makemaze;
{ Create and print a maze
  Daniel Scharstein 2/18/09
  derived from jaccl program
}

const
   rows = 16;
   cols = 24;

type
   dir	 = (right, up, left, down);
   field = record
	      visited : boolean;
	      wall    : array[dir] of boolean;
	   end;	      
   maze	 = array[1..rows, 1..cols] of field;


{ global variables }
var
   m	  : maze;
   dr, dc : array[dir] of integer;

procedure initconst;
begin
   dr[right] :=  0; dc[right] :=  1;
   dr[up]    := -1; dc[up]    :=  0;
   dr[left]  :=  0; dc[left]  := -1;
   dr[down]  :=  1; dc[down]  :=  0;
end;

procedure initmaze;
var
   r, c	: integer;
   d	: dir;
begin	    
   for r := 1 to rows do
      for c := 1 to cols do
      begin
	 m[r][c].visited := false;
	 for d := right to down do
	    m[r][c].wall[d] := true;
      end;
end;
   
procedure printmaze;
var
   r, c : integer;
begin	 
   writeln;
   write('  +');
   for c := 1 to cols do
      if m[1][c].wall[up]
	 then write('--+') else write('  +');
   writeln;
   for r := 1 to rows do
   begin
      if m[r][1].wall[left]
	 then write('  |') else write('   ');
      for c := 1 to cols do
	 if m[r][c].wall[right]
	    then write('  |') else write('   ');
      writeln;
      write('  +');
      for c := 1 to cols do
	 if m[r][c].wall[down]
	    then write('--+') else write('  +');
      writeln;
   end;
   writeln;
end;


function nextdir(d: dir): dir;
begin
   if d = high(dir) then
      nextdir := low(dir)
   else
      nextdir := succ(d);
end;

function prevdir(d: dir): dir;
begin
   if d = low(dir) then
      prevdir := high(dir)
   else
      prevdir := pred(d);
end;

function oppdir(d: dir): dir;
begin
   oppdir := nextdir(nextdir(d));
end;

function legalfield(r, c: integer): boolean;
begin
   legalfield := ((r >= 1) and (r <= rows) and
		  (c >= 1) and (c <= cols) and
		  (not m[r][c].visited));
end;

procedure createpath(r, c: integer);
var
   nr, nc, k : integer;
   d	     : dir;
   turn	     : boolean;
begin	   
   m[r][c].visited := true;
   d := right;
   for k := 0 to random(4) do
      d := nextdir(d);         { random starting direction }
   turn := (random(2) = 1); { random turning direction }
   for k := 0 to 3 do
   begin
      nr := r + dr[d];
      nc := c + dc[d];
      if legalfield(nr, nc) then begin
	 m[r][c].wall[d] := false;
	 m[nr][nc].wall[oppdir(d)] := false;
	 createpath(nr, nc);
      end;
      if turn then
	 d := nextdir(d) { counterclockwise }
      else
	 d := prevdir(d); { clockwise }
   end;
end;

{ main program -------------------- }
var
   r2 :  integer;
begin
   randomize;
   initconst;
   initmaze;
   createpath(1, 1);
   r2 := rows div 2;
   m[r2][1].wall[left] := false;      { create "door" on left }
   m[r2][cols].wall[right] := false;  { create "door" on right }
   printmaze;
end.