Maze

A 10-line TurboBASIC XL program for the Atari 8-bit computer
Written for 2014 NOMAM programming competition

Bill Kendrick, March 22, 2014

An entry for the NOMAM 2014 10-line TurboBASIC XL game competition.

Objective

You begin in the center of a randomly-generated maze, and must navigate to the top left corner as quickly as possible.

Gameplay

Befor the game starts, you'll be asked whether or not your trail through the maze should be exposed. Press [Y] for yes, or [N] for no. The screen will go blank for a few moments while the maze is generated.

When the game begins, you'll see the walls (brick) and floor (checkerboard) around your current location. Use the joystick to move around the maze.

Once you reach the top left corner, the full maze is displayed, and some sound effects and flashing colors are shown. Then, the time it took you to complete the maze (in HHMMSS format) will appear for a few moments, and the game will restart.

Development notes

My objective was to make a game similar to "Hidden Maze" that was published in Compute!'s First Book of Atari Games, which I had as a kid. It uses the depth-first method of carving a maze, which I brushed-up on by reading a Wikipedia article on the subject. I did not refer to "Hidden Maze" when writing this game.

Based on what I learned from Wikipedia, and from what I remembered from "Hidden Maze", I knew you could simulate the recursive nature of a depth-first algorithm by utilizing the map itself as a kind of stack. That is, you leave a 'breadcrumb' trail as you carve through the maze, pointing in the direction you came from. When you hit a dead-end, you simply backtrack until you find a spot where you have another option, or you've returned to your starting point (at which point, you're done).

I utilized the Atari's color indirection (color palette) to 'hide' the maze by setting its color to black, just like the background. I then took advantage of TurboBASIC XL's built-in bitwise "and" (&) and "or" (!) operators to alter the characters (tiles) that make up the maze to change their colors. (In large-text mode (GRAPHICS 1 and GRAPHICS 2), 64 symbols can be shown, in one of four colors, depending on the two highest bits of the byte.)

Hiding the wall in your old location, and exposing the wall in your new location, caused too much flicker. So I tried a few other ways of doing it until I settled on:

expose the walls directly around your location ((x-1,y-1) to (x+1,y+1))
hide the walls beyond that ((x-2,y-2) to (x+2,y-2), (x-2,y+2) to (x+2,y+2), and so on)

Attempts to use the modulus operator (MOD) or bitwise "and" proved too slow, and/or didn't work like I intended (because I was tired).

Finally, I squeezed the game by creating at first two small subroutines, then combining them into one, for hiding walls... utilizing variables for some two-digit values (_ for -1, and T for 20)... and so on. Then, after squeezing the code down some more, I added a game over routine, and utilized TurboBASIC XL's TIME$ to show you your 'score' — how long it took to solve the maze (the smaller, the better).

Line-by-line Breakdown of the Source Code

Setup


10 GRAPHICS 17:SC=DPEEK(88):FOR X=21 TO 37:POKE SC+X,3:NEXT X:FOR Y=2 TO 17:MOVE SC+20,SC+Y*20,20:NEXT Y:ZZ=SC+42:Z=ZZ:OPEN #1,4,0,"K:"

Switch to 20x24 large, colored text mode, with no text window
Find the start of screen memory (SC)
Draw one row of the wall to carve through; it's 17 cells wide, and starts at position 1,1
Duplicate that one row almost all the way down the screen; this gives us a 17x17 area in which to carve a maxe
Set the position of the exit, aka the starting position for generating the maze (ZZ)
Set our current position (Z)
Open the keyboard device (K:) for read


20 _=-1:T=20:DIM D(4):D(0)=_:D(1)=-T:D(2)=1:D(3)=T:RR=_:? #6;"MAZE! expose yn":REPEAT :GET #1,N:UNTIL N=78 OR N=89:POKE 708,0

Set some constants (_ and T)
Create and assign values to array that will be used for describing how many bytes to move when going different directions in the maze. (-1 is left, +1 is right, -20 is up, 20 is down) (D())
Set a default out-of-bounds value for RR, which is used below
Prompt the user
Read input from the keyboard until the ATASCII value of "N" or "Y" have been read
Change color 1 to be black

25 POKE Z,0:G=1000:IF N=89:GG=128:ENDIF :POKE 559,0:CH=(PEEK(106)-16)*256:POKE 756,CH/256

Draw a blank spot at the starting position
Set a constant used to jump to our "hide the walls" subrouting (G)
If the user hit [Y], set a bitmask to be used to expose walls as we navigate the maze, rather than hide them completely (GG)
Disable ANTIC DMA. Hides everything on the screen, but also has the useful side-effect of allowing our code to run slightly faster
Find a location for a character set (CH)
Point CHBAS at the character set memory

Maze generator


30 REPEAT :A=0:OD=-1:FOR I=0 TO 3:A=A+(PEEK(Z+D(I)*2)=3):NEXT I:IF A=0 THEN RR=PEEK(Z)-128:POKE Z,0:POKE Z-D(RR),0:Z=Z-D(RR)*2

Start a loop...
- Clear an accumulator (A)
- Set a default out-of-band value for OD, used below
- Start a loop to look around us (I)...
  - Add to the accumulator (A) if the cell two steps in the direction we're examining contains a wall tile
- If the accumulator is 0 — if there are no un-carved cells to go into (we are at a dead end)...
  - Look at the breadcrumb at our current location and store it (RR)
  - Remove the breadcrumb at our current location
  - Remove the breadcrumb in the immediately-adjacent cell
  - Move in the direction the breadcrumb pointed


35 UNTIL A<>0+(Z=ZZ):IF Z<>ZZ OR RR=-1 THEN REPEAT :R=RAND(4):UNTIL PEEK(Z+D(R)*2)=3 AND R<>OD:FOR I=0 TO 1:Z=Z+D(R):POKE Z,128+R:NEXT I:GOTO 30

In a loop...
- Stop looping as soon as we're not in a dead-end (A is not 0) or we've back-tracked to our starting position
If we aren't in the starting position (we haven't back-tracked to it), or we haven't even begun yet (RR=-1)...
- Start a loop...
  - Pick a random direction (R)
  - Until the cell two steps in that direction is found to contain a wall tile, and it's not in the direction we just came from (OD)
- Loop twice (I)...
  - Move one step in the direction chosen
  - Carve into the wall, replacing it with a breadcrumb denoting what direction we just travelled to get here (so we can use that breakcrumb for backtracking)
- Go back to line 30 to continue carving

More set-up


40 Z=SC+210:MOVE ADR("........"),CH,8:MOVE ADR("........"),CH+24,8:POKE 710,8:POKE 559,34:TIME$= "000000"

Set our gameplay starting position to the center of the maze (Z)
Store some character set data — checkerboard for the space character, and a brick shape for the "#" character
Set the playfield color we'll be using for exposed parts of the maze to grey
Re-enable ANTIC DMA
Set TurboBASIC XL's clock to 00:00:00

Main Game Loop


50 FOR Y=_ TO 1:FOR X=_ TO 1:NZ=Z+Y*T+X:POKE NZ,PEEK(NZ)!64:NEXT X:NZ=Z-2+Y*T:GOSUB G:NZ=NZ+4:GOSUB G:NEXT Y:FOR X=-2 TO 2:NZ=Z-40+X:GOSUB G

Loop from above us to below us (Y)...
- Loop from left of us to right of us (X)...
  - Get the screen position (NZ)
  - Set the 2nd-highest bit of the tile on the screen at that location to change it to the color that shows our location in the maze
- Get screen position of two cells to the left of us (NZ)
- Call the subroutine that erases (or greyes out) the cell at 'NZ'
- Move to the screen position of two cells right of us (NZ)
- Call the subroutine that erases...
Loop from two cells left of us, to two cells right of us (X)...
- Get the screen position of two rows above us (NZ)
- Call the subroutine that erases...


60 NZ=NZ+80:GOSUB G:NEXT X:REPEAT :S=STICK(0):UNTIL S<15:NZ=Z+D((S=14)+(S=7)*2+(S=13)*3):IF PEEK(NZ)&63=0:Z=NZ:ENDIF :GOTO 50+1000*(Z=ZZ)

Looping from two cells left of us, to two cells right of us (X)...
- Move to the screen position of two cells below us (NZ)
- Call the subroutine that erases...
Start a loop...
- Record the joystick's state (S)
- Keep looping until the joystick has been moved
Determine what would be our new position, based on joystick input (NZ)
If the tile at the new location is blank, move to it (Z)
Either go back to the beginning of the game loop (line 50), or go to the game-over subrouting (line 1050), depending on whether we've reached the goal at the top left (ZZ)

Subroutines


1000 POKE NZ,(PEEK(NZ)&191)!GG:RETURN

Hide (or grey out) the tile at position NZ


1050 FOR A=0 TO 15:FOR B=0 TO 15:SOUND 0,100+A*10,10,B:POKE 708,A*16+B:POKE 712,15-B:NEXT B:NEXT A:GRAPHICS 18:? #6;TIME$:PAUSE 120:RUN

Loop from 0 to 15 (A)...
- Loop from 0 to 15 (B)...
  - Play a sound (pitch based on A, volume on B)
  - Change the hidden wall color to make it flash colors
  - Change the background to make it flash greys
Switch to 20x12 large text mode
Display the time that's passed since you started playing this maze
Pause for a few moments
Restart the program (prompts for exposure, and generates a new maze)

Download

MAZE.TBS - tokenized TurboBASIC XL file
maze_20140322.atr - ATR disk image containing:
- MyDOS 4.53/3 (DOS.SYS, DUP.SYS)
- TurboBASIC XL (auto-run, TBASIC.AR0)
- The game (TBXL auto-run, AUTORUN.BAS; except for the filename, same as MAZE.TBS stand-alone file, above)

Bill Kendrick, 2014, nbs@sonic.net, New Breed Software
Other games I wrote for NOMAM 2014