"Capella" design


Class Node—Describes one “spot” on the board. A Node can hold references to up 
to four other Nodes (described as north, south, east, and west), one Robot, 
and one Beeper. 


Constructors:
Public Node()
Public Node(Node north, Node east, Node south, Node west)—Creates a Node with 
references to the specified Nodes. 


Fields and variables:
Static int NORTH
Static int EAST
Static int SOUTH
Static int EAST


Methods:
public Beeper getBeeper()
public void setBeeper()
public Robot getRobot()
public void setRobot()
public void setNode (Node node, int direction)
public void setWall (int direction)—sets the specified node to null. 
public Node[] getClearPaths—returns an array of all Nodes which have non-null 
references (i.e. all spaces not blocked by walls) in this Node. 



Class SubMaze—Describes an individual sub maze. This is a standard maze in 
which every node has exactly one path to every other node in it. 


Constructor:
public SubMaze(int width, int height)—constructs a SubMaze of the given 
dimensions, out of individual Nodes.



Class Maze—Describes the entire game board maze. Is composed of SubMazes, with 
exactly one opening between any two adjacent SubMazes, so that there is 
exactly one way for objects traveling within any given SubMaze to get to the 
SubMaze next to it. 


Constructor:
public Maze(int width, int height, int submazeWidth, int submazeHeight)—
constructs a Maze of the given dimensions, out of individual SubMazes.



Class Beeper


Constructor:
public Beeper (int row, int col)—Constructs a Beeper object at the specified 
location. 


Methods:
public void getAge()—returns the number of steps that have gone by in the game 
since this Beeper was instantiated. 
public void incrementClock()—increments this Beeper’s age by 1. 
public int [] getCoordinates—returns the row and column of this Beeper. 



Class Robot


Constructor:
public Robot (Maze theMaze, Beeper[] theBeepers)—Constructs a new Robot 
object, with references to the Maze and an array holding all of the Beepers. 


Methods:
public void move()—Carries out one step of execution for the Robot. Handles 
deciding where to move, moving there, and collecting a beeper if applicable. 
public void getBeepersCollected()



Class BeeperHunt (implements Observable)—controls the entire game. Holds a 
number of constants that pertain to game parameters, such as NUMBER_OF_BEEPERS 
and such. Keeps track of how many turns have passed, removes and instantiates 
new beepers as they expire, tells the robot when to move, and ends the game 
when appropriate. Instantiates and sends messages to the GUI (Dr. Dave’s 
classes) to display what is going on. 


Constructor:
public BeeperHunt (int turns, int height, int width)—constructs a new 
BeeperHunt game to be played for the specified number of turns, in a maze of 
the given size. Takes care of instantiating all objects, including the Robot 
and an array of Beepers. 


Methods:
public static void main()—Instantiates a BeeperHunt object, which in turn 
instantiates and runs the entire game.