Those who would like to read a brief description of the history of this popular game (and find out why it isn't called Puck-man) might want to visit the Wikipedia article on Pac-Man. If you want to increase your familiarity with the official version of the game, you can find a working version on-line.

In case you haven't guessed, for your final test program we would like you to write a program that implements Pac-Man. Well, actually it might be more appropriate to describe what we want you to implement as proto-Pacman -- a game clearly related to Pac-Man but simplified in many ways to make the assignment more reasonable.

Our proto-Pacman game board is shown on the left. The basic game board is a maze of walls and passageways. Through these passageways will wander four colorful ghosts and "Pac-Man", a smiley face gone bad.

The ghosts travel down passageways moving ahead as long as there is only one path they can take. When a ghost reaches a cell in the maze where several passageways meet, it chooses among the passageways randomly (except that a ghost won't go back out using the passageway it just came from).

The player controls Pac-man's motion using the four arrow keys on the keyboard. When one of the buttons is pressed, Pac-Man begins moving in that direction if it is possible. (If there is a wall in the way, then the button press is ignored.) Once Pac-Man is moving in a particular direction, he keeps moving that way until he runs into a wall (in which case he just stops moving), or one of the other direction buttons is pressed.

Unfortunately for Pac-Man, the ghosts and Pac-Man exist in a predator-prey relationship. If any of the ghosts bump into Pac-Man, he perishes. In the arcade version, Pac-Man actually has several lives so that for one token a player gets to bump into at least three ghosts. Our game will only give Pac-Man one life. Bump into a ghost and the game is over.

The passageways initially contain little dots which Pac-Man appears to eat as he makes his way through the maze. In fact, the object of the game is to eat all the dots before bumping into any ghosts. Recognizing and announcing Pac-man's success (or failure) on the screen will earn you extra credit.

Some of the dots that were present in the arcade version of the game (the big ones) increase Pac-man's appetite so much that he can even eat ghosts. Since we won't have any big dots, this will never happen to your Pac-Man. Bumping into a ghost will always be fatal.

Implementation Details

XXXXXXXXXXXXXXXXXXX
X        X        X
X XX XXX X XXX XX X
X XX XXX X XXX XX X
X                 X
X XX X XXXXX X XX X
X    X   X   X    X
XXXX XXX X XXX XXXX
XXXX X       X XXXX
XXXX X XXXXX X XXXX
XXXX   XXXXX   XXXX
XXXX X XXXXX X XXXX
XXXX X       X XXXX
XXXX X XXXXX X XXXX
X        X        X
X XX XXX X XXX XX X
X  X           X  X
X  X X XXXXX X X  X
X    X   X   X    X
X XXXXXX X XXXXXX X
X                 X
XXXXXXXXXXXXXXXXXXX

an array of FilledRects has to do with the fact that in this game a cell in the maze may be in one of three states (part of the wall, an unvisited passage cell, or a visited passage cell). If you use an array of FilledRects, you won't be able to simply test for "null". Both wall cells and visited passage cells will contain graphic objects. To tell them apart you would have to something like checking the color of the object. Alternately, if you define a Cell class, you can fill every element of the array with Cells and then include in the Cell class methods like "isWall", and "visit".

We will provide a Cell.java file in the starter folder, but will leave it to you to decide whether you find it simpler to use an array of Cells or an array of DrawbleInterface (recall that variables of type DrawableInterface can hold rectangles and ovals).

If you do use the Cell class then we suggest that each cell contain an instance variable of type DrawableInterface (to hold the graphics associated with the cell) and another variable (perhaps an int) that will represent information about the cell. For example 0 could represent an empty cell, 1 could represent an empty cell that has been visited, and 2 could represent a wall cell. These codes can make it fast and easy to determine what kind of cell it is while the game is running.

We will also provide you with predefined classes Position and Direction. The Position class is the same as the one used in Nibbles, while the Direction class has two extra features. First there is a new constant direction NONE, which may be useful for the beginning of the program when Pac-Man is not moving. It also has a new method:

    public Direction randomDirection()

which will be useful for helping the ghosts wander around at random.

Whether you use the Cell class or not, your program will involve the definition of four other classes:

Maze

The role of the Maze class will be similar to that of the NibbleField class from the Nibbles program, though it will likely be simpler if you make the array an array of Cells. It is responsible for keeping track of all of the cells in a two-dimensional array. It should also respond to requests asking if a position contains a wall, check to see if a cell has been visited (and erase its dot if it has not been). You will doubtless find a number of other methods that will be useful to have as part of the Maze class.

Ghost

The Ghost class will be an extension of ActiveObject that implements the random motion of the ghosts on the screen and the fatal interaction between ghosts and Pac-Man. We will provide a few ghostly images in files blueghost.gif, purpleghost.gif, redghost.gif, and yellowghost.gif. Like your Vehicles from the Frogger lab, the constructor for Ghosts will need to be passed the Pacman object as a parameter so that each Ghost can periodically send a message to Pac-Man to see if it has killed him. The Ghosts will also need to be passed the array that represents the maze so that they can figure out how to stay within the passages. When first created, a Ghost should randomly place itself in any cell that is not part of the maze wall. Although we would like to encourage you (with extra credit) to have your ghosts move smoothly between the cells of the maze (as ours do), the basic version of the program should be written so that ghosts (and Pac-Man) hop from cell to cell. There are two reasonable ways you could pick adjacent cells into which to move. You could first find all the adjacent passageway cells and then randomly pick one of them. Alternately, you could just repeatedly, randomly pick adjacent cells until you pick one that is not a wall and not the cell from which you arrived in your current cell. Note that ghosts are never allowed to reverse direction and go back where they just came from!

Pacman

The Pacman class will also be an extension of ActiveObject. Pac-Man will always start in row 12 and column 10, in a passageway just below the center of the board. Unlike the ghosts, Pac-man's motion will not be random, but instead will be guided by the user pushing the arrow keys. Pac-Man will also need to be passed the board as a parameter. It will use the board both to make sure that it stays in the passageways and to determine whether it has already visited a cell. The Pacman class will have to provide several methods so that it can respond to the direction buttons and to Ghosts who think they may have killed it.

PacmanController

The Controller for this program will have to input the maze description from a file named pacMaze and create the maze, and create the Pac-Man and Ghosts. It will also act as the listener for the arrow keys. My Pacman game runs in a window that is 475 by 650 pixels, though you may use other sizes if you like. The program uses a number of constants (many of which are pre-declared in the start-up code) to determine things like the size of the individual cells. If they are needed in other classes than the ones in which they are declared, you may make them public and refer to them as ClassName.aConst where ClassName is the name of the class where they are defined and aConst is the name of the constant. As always, instance variable will never be public.

The Design

As indicated in the heading of this document, you will need to turn in a design plan for your Pac-Man program well before the program itself. This design should be a clear and concise description of your planned organization of the program. Note that this design counts for 20% of your grade on the project, so take this requirement seriously.

Include in your design a sketch of each class (excluding Position and Direction) including the types and names of all instance variables you plan to use, and the headers of all methods you expect to write. You should write a brief description of the purpose/function of each instance variable and method. These should be sufficient to form the comments on each of these in your final program.

In addition, you should provide pseudo-code for any method whose implementation is at all complicated. In particular, if a method is complicated enough that it will invoke other methods you write (rather than just invoking methods provided by Java or our library), or involves a loop, then include pseudo-code for the method so that we will see how you expect to use your own methods.

Implementation Order

We strongly encourage you to proceed as suggested below to assure that you can turn in a running program. While a partial program will not receive full credit, a program that does not run at all generally receives a lower grade. Moreover it is easier to debug a program if you know that some parts do run correctly.

1. Run the demonstration program.

2. Write a program that reads the maze file and creates the maze from it. The maze file is named "pacMaze. This should result in a picture of the maze on the screen.

3. Write enough of your Ghost class to make a ghost that can wander randomly without going through walls (don't worry about killing Pac-Man at this point). The ghosts should just hop from cell to cell without a smooth animation.

4. Write a Pacman that pays attention to the arrow keys. Note that Pacman will continue in the same direction until it either runs into a wall (at which point it stops moving) or the user presses a key to move it in a new direction in which there is an empty cell.

5. Add a method to Pac-Man and ghosts to allow the ghosts to try to kill Pac-Man.

6. Add code to Pac-Man to make it erase the dot when it visits a cell for the first time.

7. Add code to make sure that the ghosts and Pac-Man both stop moving if Pac-Man dies.

If you get stuck at an early stage of this project, please come see me. I can provide you with code for the early parts for a grade penalty. For example, if you cannot read in the board correctly, I can help you do that for a penalty of 5 points on the assignment.

Extensions

Since we have left out many of the features of the original Pac-man game, there are clearly many additional features you could add to your program. The base version of the program described above is worth a maximum of 90 points. We will award up to 20 points for extensions.

The version that I have running on line has several extra features that you may wish to add to your program. There are also several features from the original game that are not in the required portion of the game, but that will earn you extra points. Here are some suggestions for extra features:

• (3 points) Add code to the Ghost and Pacman classes to make both kinds of objects move smoothly from cell to cell. In the demo, it takes my objects 7 steps to completely move from one cell to the next. Leave the main structure of the moving loop alone, just replace the single step in that moving loop by a call to a method that makes that single step go more smoothly.

• (3 points) Make it easier to steer Pac-Man. You will notice that in my version of the game, if the user tells Pac-Man to go north, but that way is blocked, Pac-Man will continue going his current direction until there is a passage way to the north and then take that passage. This make it much easier to play as you don't have to get your timing exactly right to get him to turn.

• (2 points) Further animate Pac-Man by having his mouth pointing the same direction he is moving (pictures of Pac-Man going each of the directions are available in the start-up folder), and have the mouth open and close while moving (see the original game).

• (2 points) Add a button to allow the user to start a new game.

• (2 points) Allow the user three tries before losing. I.e., after dying the first or second times, Pac-Man is resuscitated without resetting all of the dots on the board. Show how many lives are left by showing a "Pac-Man" image at the bottom of the canvas for each life left.

• (2 points) Add a message at the end of the game indicating whether or not Pac-Man won.

• (2 points) Keep track of the score. (See the wikipedia article for scoring rules.

• (2 points) If keeping track of the score, allow extra points for capturing randomly placed fruit on the screen (see the wikipedia article).

• (2 points) Change the game board to be closer to the original game by allowing a passage from the left side of the board directly to the right side (see the link to the original game).

• (2 points) Use inheritance effectively so that both the Ghost and Pacman classes inherit from a MazeWanderer class in order to avoid duplicated code.

• (2-5 points) Make the ghosts smarter so that if they are within range (whatever that means!) of Pac-Man they will chase him.

• (2 points) Have the ghosts start out from a home base in the center of the field.

• (5 points) Add power pellets so that when on steroids Pac-Man can now eat the ghosts and chase them back to their home.

• (2 points) Add extremely annoying music and sound effects to the game.

Finally, let me emphasize that you will gain more points from writing really good, clear, well documented code than from adding any of these extensions. Make sure your base code is as good as you can make it (and that it works correctly) before moving on to extensions.

The Starter

As usual, I will provide a starter folder for this assignment. It is available on-line now.

Turning it in

Your design should be turned in on paper in class. Keep a copy for yourself since we will not be able to return them to you until after the last day of classes.

When your work is complete you should deposit in the dropoff folder a copy of the entire folder containing all of your files (check to make sure they are all there before you turn it in. Before you do this, make sure the folder name includes your name and the phrase "TP 2". Also make sure to double check your work for correctness, organization and style.

This program is due at 3:30 p.m. on December 6th, the last day of classes. While you may turn your program in late, you will be assessed a 10 point penalty for each day it is late. I.e., if you turn it in at 3:45 p.m. on December 6th, you will receive a 10 point penalty. If you turn it in at 3:45 p.m. on December 7th, you will receive a 20 point penalty, etc.

051
Department of Computer Science
Pomona College