Java Game Programming For Dummies - W. Holder, D. Bell

Chapter 7:2-D Maze 165

Generating a wall maze

Here are the steps the W a 1 1 M a z e class uses to generate a maze:

1.Set all the squares in the maze grid to the B LO C K E D state.

2.Randomly select a square on the left edge of the maze as the current square, clear the wall on the left side of the square, and set 1 a s t S i d e

to LEFT.

3.Randomly choose a sequence to rotate through the remaining sides (the sides other than 1 a s t S i d e) of the current square.

4.Set nextSi de to the next selected side in the rotation.

5.If a BLOCKED square lies adjacent to the nextSi d e of the current square, go to Step 9.

6.If more sides remain in the rotation sequence decided on in Step 3, go to Step 4.

7.You get to this step when the current square isn't adjacent to any BLOCKED squares. Randomly select a non-BLOCKED square (a square already added to the maze) as the current square.

This creates a new branch in the maze by starting a path at the newly selected square.

8.Set 1 a st S i d e to one of the open sides of the selected square and go to Step 3.

9.You get to this step when you have found a square to add to the maze. Remove the wall between the current square and the square adjacent to its next Si de.

10.Set the new current square to the adjacent square and set 1 a s t S i d e to the wall of this square removed in Step 9.

This sets 1 a s t S i d e to the side opposite n e x t S i d e. For example, if

nextSi de is TOP, the new 1 astSi de is BOTTOM.

11.If any BLOCKED squares remain in the maze grid, go to Step 3, otherwise you're done.

The W a 1 1 M a z e class implements the abstract methods i s 0 p e n ( ) and defined in the superclass like this:

public boolean isOpen (int x, int y)

return inBounds(x, y) && sqr(x, y) != BLOCKED:

(continued)

sideInc = (sideInc + 1) % 3; // Step #6 - new side

else ''// dead end, start a new branch

-1/ inited in step #2 before the main loop, or set in

//step #9a below. If found then the nextSide

//wall is cleared in sq before setting maze[][] maze[xx][yyl = (byte)

(continued)

Chapter 7:2-D Maze 169

Step 7 in g e n e r a t e ( ) employs two different strategies for picking a random square from which to start a new branch. When lots of BLOCKED squares remain, g e n e r a t e ( ) randomly selects squares in the grid until it finds an unblocked square. Using random selection creates more interesting and varied mazes. When the number of BLOCKED squares remaining in maze[][] falls below the t h r e s h o 1 d level - arbitrarily set to 1/8 of the total grid squares - the code uses an exhaustive search to find the remaining BLOCKED squares. An exhaustive search quickly adds the remaining squares to the maze, additions that could take a long time to make randomly.

Generating a buck maze

The block maze algorithm maintains a list of squares that it must explore. The algorithm adds squares to the list as it adds them to the maze grid. Each square in the list keeps track of the unexplored directions from itself. Each square also remembers the direction in which the search was proceeding when the particular square was added to the list so that the algorithm can give a preference to continuing to search in the same direction. Each entry in the list is an object of the Sq r class shown here:

Sqr (int x, int y, int dir,

boolean t, boolean b, boolean l, boolean r) { this.x = x; this.y = y; this.dir = dir;

this.t = t; this.b = b; this.] = 1; this.r ° r;

// open() returns a count of the unexplored directions i nt open () i

return (t ? 1:0) + (b ? 1:0) + (r ? 1:0) + (1 ? 1:0);

1

i nt select (int n, boolean sameDir)

// Step #6b - select dir to explore and mark as explored i f (sameDir) // try to expand in dir square was entered

switch (dir) i case Maze.TOP:

(continued)

Chapter 7: 2-D Maze 151

The B 1 o c k M a z e class implements the abstract methods i s O p e n ( ) and generate() defined in the Maze superclass. generate() in turn uses the

private method tryDi r( ). tryDi r( ) uses the private methods

blocked(), noDi ag ( ), and an overloaded version of i sOpen( ). (Remember, an overloaded version of a method is an alternate method that accepts different parameters.) Here are fields and methods you add to B 1 o c kM a z e to

generate mazes:

private Vector pending; // list of available Sqr objects private int strt = 70; // prcb of exploring from same sqr private int sdir = 60; // prob of exploring in same dir private int thru = 90; // prob of blocking thru loop private int side = 60; // prob of blocking wide area private int diag = 100; // prob of blocking diag connection private int dens = 15; /I prob of leaving areas unexplored

public boolean isOpen (int x, int y)

return inBounds(x, y) && sqr(x, y) == FLOOR;

private boolean blocked (int x, int y) i

return inBounds(x, y) && sgr(x, y) == WALL;

private boolean noDiag (int x, int y, int dx, int dy) {

return blocked(x + dx, y) && blocked(x, y + dy) &&

isOpen(x + dx, y + dy, diag);

private boolean tryDir (int x, int y, int dir) {

ll Step #7 - check if adjacent square in direction dir

i f (isOpen(x, y-1, thru)

isOpen(x-1, y, side) I ~ i sopen(x+l, y, side) noDiag(x, y, -1, -1) ~~ noDiag(x, y, 1, - 1))

return false; break;

(continued)

156 Part II: Up to Speed

Here is the code from the t ry D i r ( ) s w i t c h statement:

case RIGHT: x++;

The first thing the code does is increment x to adjust the (x, y) coordinates from the current square (square 1 in Figure 7-3) to the new square candidate (square 2). Working from the candidate square, the code calls i s0pen ( x+1. y , t h r u ) to check whether the square to the right (square 3) is a floor square. Here is the i s0pen ( ) method:

private boolean isOpen (int x, int y, int allowProb) I

return prob(allowProb) && i sOpen(x, y);

I

The thru parameter specifies the probability (from 0 to 100) that i s0pen( ) returns t r u e regardless of whether or not the square is open. Because t h r u is 90 and square 3 in Figure 7-3 is open, there is a 90 percent chance that

p rob (90) returns t r u e and a 90 percent chance that the first call to

i sOpen( ) returns true. If i sOpen() returns true, tryDi r( ) returns fal se and doesn't use the square.

Even if t ry D i r ( ) decides not to use the square this time, the square could still be selected when evaluated from another direction. For example, square 2 in Figure 7-3 could be selected when moving to the from square 3.