Mouse in a Maze Program

In this program you will implement a simulation of a mouse looking for a piece of cheese in a maze.

Problem Specification:

Design a program to simulate mice moving through a maze until they find cheese.  A mouse always starts at the starting position, and moves one unit at a time.  Your program should be able to support mice with different movement strategies.

• One type of mouse teleports directly to the cheese (the "beam-me-up mouse").
• Another moves randomly until it happens to stumble across some cheese (the "clueless mouse").
• Another moves randomly unless there is cheese in sight within two units, in which case it moves to (and eats) the cheese (the "short-sighted mouse").  (This mouse does not see cheese that is around a corner, even if it is only two units away.)
• Another moves randomly unless there is cheese anywhere in sight, in which case it moves toward the cheese (the "long-sighted mouse").
• Another moves toward the smell of cheese (the "nosy mouse").  (Implementing this strategy is optional!)
• Another moves systematically through the maze until finding the cheese (the "systematic mouse").  (Implementing this strategy is optional!)
• You may also implement other strategies that you find interesting.  (Implementing additional strategies is optional!)

Your program should read in a maze configuration, including the starting position and the location of the cheese (the start and end locations for the maze).  It should allow the user to run the experiment several times, with different maze configuration files.  Each time, a piece of cheese is put at the end of the maze, a mouse is put at the starting location, and the mouse is allowed to move around the maze looking for the cheese.  The user should be able to choose the type of mouse or mouse movement strategy for each run of the experiment.  Your program should graphically display the state of the mouse and the maze at the end of each time unit.  When a mouse finds the cheese, your program should report how many time units it took for the mouse to find the cheese.

More specific details:

Your program should have a graphical user interface with a File menu, a mouse choice drop-down menu, a button to add a mouse, a panel in which the maze is graphically displayed, and a slider bar for changing the speed of the mouse movement.  (Actually, it controls the speed of the animation -- how long the program pauses to let you view the display between time steps -- rather than the speed of the mice.)

You may use the following classes or files, which have been fully implemented and are available in MouseInAMaze.zip and grid.jar:

• Cheese - an extension of the ColorBlock class (you could implement it in some other way, though, if you chose)
• MazeDataFileHandler - a class that reads the maze information from a file and constructs the maze
• MouseFileMenu - a class that provides a File menu with an Open menu item; you may ignore this class as it is only used by the graphical user interface
• MouseMazeController - a class that controls the mouse movement during program execution
• MouseMazeGUI - a class that provides a graphical user interface for the Mouse-in-a-Maze project
• maze1.dat - a sample maze initial configuration file
• grid.jar - a Java archive library containing classes such as BoundedGrid, ColorBlock, ColorBlockDisplay, BasicGridFileMenu, etc.  The class documentation for all classes in this library is available online.

You will need to implement or modify the following classes:

• Maze - an extension of the BoundedGrid class
• Mouse - an object that moves around the maze looking for cheese
• MouseInAMazeApp - a main class that specifies how to display mice and color blocks, specifies the type of mice in the program, and constructs a MazeGUI object; you will need to edit this class when you add new Mouse types to the project and want them to appear in the drop-down menu.
• several classes that represent different types of mice, including the Mouse class and several subclasses

One possible plan of attack:

You will probably find it useful to implement this program in stages (iterative development).  For example, you might:

1. Implement the minimum amount of code that will let you compile and run a working program. (More details are below.)
2. Implement a (theoretically) moving mouse. (More details are below.)
3. Implement various types of moving mice. (More details are below.)
4. Display the mouse graphically or with an image (this could be done earlier if you like). (More details are below.)

You do not have to develop the program in this way, but if you want to follow this structured approach you will find more details below.

Implementing the minimum amount of code that will let you compile and run a working program:

• Download mousemaze.zip and extract the files.
• Create a project in a folder and import the extracted files from mousemaze.zip into the project (Project->Import, or File->Import in older versions of BlueJ) Bring up the the Tools->Preferences dialog box (or File->Properties in older versions of BlueJ) and, in the Libraries tab, add the grid.jar file.
• Construct a Maze class that extends BoundedGrid.  The MazeDataFileHandler object will read in a maze configuration file and construct a Maze object that corresponds to the configuration file.  In order for MazeDataFileHandler to work correctly, the new class must be called Maze and it must have a two-parameter constructor just like BoundedGrid.  It should also have two instance variables to keep track of the starting location (for the mouse) and the finish location (the location of the cheese). It should have "getter" and "setter" methods for those instance variables, which must be called setStartLoc, setFinishLoc, getStartLoc, and getFinishLoc in order for the MouseMazeGUI and MouseMazeController to work correctly.   The two setter methods must each take a single Location as a parameter and have a void return type.  The getter methods do not need any parameters, but should return the appropriate Location object.  You should implement the constructor and the four methods to interact with your two instance variables correctly. 
• Construct a Mouse class.  The MouseMazeGUI object will construct a mouse and add it to the maze when the user clicks on an Add Mouse button.  In order for MouseMazeGUI to work correctly, the new class must be called Mouse and it should have a zero-parameter constructor.  As a starting point you may wish to have your Mouse class extend the ColorBlock class in the same way that Cheese does so that you have something you can easily display.  You may wish to make your mouse LIGHT_GRAY rather than YELLOW.
• Run the program.  Use the File menu to open the maze1.dat initial configuration file.  This should create and display a maze with a piece of cheese in it, but no mouse.  Test the various components of the graphical user interface to see which ones work at this point.  Look at the contents of maze1.dat and see if you can figure out what each line of the file might mean.  Test your hypotheses by creating a new initial configuration file with different values.

Implementing a (theoretically) moving mouse:

• Implement a move method in the Mouse class that does the following:
  • Determine the location this mouse should move to.  You may wish to create a helper method, nextLocation for example, that calculates this location.  For now, the next location could be the current location.
  • If the new location is the same as the current location, you're done.
  • Otherwise,
    • If the new location contains the cheese, the mouse should "eat" it (remove it from the grid) before attempting to move into that location.  (You may wish to add a method that casts the grid to the Maze class, as described below.)
    • Regardless of whether the new location was the one containing the cheese, the mouse should move to the new location
• Even though the Mouse class inherits a method from GridObject that returns its grid, you may wish to create another method that returns the grid as a Maze object so that you don't have to cast the grid to a Maze over and over in your program.
• Redefine the toString method in the Mouse class to indicate the mouse's class and location.  You can get the name of an object's class with the following: object.getClass().getName().
• Test your initial move method.  (The mouse should not, in fact, move yet.)

Implementing various types of moving mice:

• Construct a subclass of the Mouse class that will "teleport" directly to the location of the cheese (the "beam me up" mouse).
• Modify your main class to add your new Mouse subclass to the list of mouse types passed to the graphical user interface.  If you do this correctly, your subclass should show up in the drop-down menu when you run the program.  If you have the subclass selected in the drop-down menu before you click on the Add Mouse button, the new mouse should be a "beam me up" mouse.
• Run your program several times until you have confidence that your new Mouse subclass is working correctly.  If your program throws an exception right away, make sure that your mouse is "eating" the cheese before attempting to move into that location, since a grid does not allow two objects in the same cell at the same time.
• Modify your program to keep track of how many moves it takes for the mouse to find the cheese and report this at the end of the run.  You may report the toal number of mouse moves with a call to System.out.println, or you may investigate using the JOptionPane class (optional). Run your program several times until you have confidence that your calculations of the number of moves is working correctly.  (You may wish to print the total after every step as you are testing, until you are confident that it is being calculated correctly.)
• Construct a subclass of the Mouse class that will move randomly to any adjacent location in the maze (the "clueless mouse").  You may wish to use the nextLocation method from the Fish class in the Marine Biology Simulation as a template.
• Add your new Mouse subclass to the list of mouse types in your main class.  Run your program several times until you have confidence that your new Mouse subclass is working correctly.
• Construct other subclasses that move in the various ways described in the problem specification above: as a short-sighted mouse, a long-sighted mouse, and any other types you choose to implement.  Add each class to the list of mouse types in your main class. 
• Run each type of mouse at least 10 times and manually calculate the average number of times each type of mouse takes to find the cheese.

Displaying a mouse graphically or with an image:

• Update your main class to specify how to display a mouse as something other than a color block.  You could create a MouseDisplay class that draws a mouse graphically, or you could use an image, such as the mouse.gif image.  To associate an image with a class, construct a new ScaledImageDisplay as the display object, passing it the name of the image file as a String parameter (e.g., "mouse.gif"). If you want the image to be take on the appropriate color for a mouse, add a ScaledImageTintDecorator to the image display. This will tint the image with the color specified by the mouse's color method.  You can find the class documentation for ScaledImageDisplay and ScaledImageTintDecorator online.
  
  Since your mouse is no longer displayed as a color block, you may wish to change your Mouse class to extend GridObject rather than ColorBlock.  If you do this, and if your method of displaying a mouse makes use of its color, you will need to add an instance variable and a color method to the Mouse class to keep track of and report its color.
   
  Optional: If you wish to write a class to display a mouse graphically, you may want to use the FishDisplay class as a model.  Note that a display class assumes that it is drawing in a 1 x 1 area with the origin at the center of the area.  In other words, the pixels range from -0.5 to 0.5 for both the x and y coordinates.  You can leave out (or comment out) the code for the gradient if you prefer.  (I suggest you not spend time creating a clever MouseDisplay class until after everything else in your program is working!)
   
• Optional: You can also display the cheese graphically or using an image, if you want.  (This is, in fact, the main advantage to having a separate Cheese class, rather than just use an object of the ColorBlock class.)
   
• Optional: If you want to, you could investigate adding an extra two rows at the bottom of a maze and then keeping a running total of the number of mouse moves in a cell in the bottom row.