You are to implement five classes. The behavior of each class is described below.
Class getChar getMove
Bird B Randomly selects one of the four directions each time
Frog F Picks a random direction, moves 3 in that direction, repeat (same as bird, but staying in a single direction longer)
Mouse M West 1, north 1, repeat (zig zag to the NW)
Turtle T South 5, west 5, north 5, east 5, repeat (clockwise box)
Wolf W Randomly select Bird, Frog, Mouse or Turtle class and copies their move
For the random moves, each possible choice must be equally likely. You may use either a Random object or the Math.random() method to obtain pseudorandom values.
The first four of these classes won’t use the CritterInfo object that is passed to getMove. This object is provided in case you want to do something with this information in defining your Wolf class. See the description of CritterInfo later in the writeup.
The critter world is divided into cells that have integer coordinates, much like the pixels in a DrawingPanel. There are 100 cells across and 50 cells up and down. As with the DrawingPanel, the upper-left cell has coordinates (0, 0), increasing x values move you right and increasing y values move you down.
Notice that the Critter class defines five constants for the various directions. You can refer to these using the name of the interface (Critter.NORTH, Critter.SOUTH, etc) or you can refer to them directly (NORTH, SOUTH, etc) because you are implementing the interface. Your code should not depend upon the specific values assigned to these constants, although you may assume they will always be of type int. You will lose style points if you fail to use the named constants when appropriate. As noted above, your critter can stay in its current location by indicating that the direction it wants to move is CENTER.
Here is the implementation of the five classes:
```java
import java.util.Random;
public interface Critter {
int NORTH = 0;
int EAST = 1;
int SOUTH = 2;
int WEST = 3;
int CENTER = 4;
int getChar();
int getMove();
}
class Bird implements Critter {
private Random random;
public Bird() {
random = new Random();
}
public int getChar() {
return 'B';
}
public int getMove() {
return random.nextInt(4); // Randomly selects a direction (0-3)
}
}
class Frog implements Critter {
private Random random;
public Frog() {
random = new Random();
}
public int getChar() {
return 'F';
}
public int getMove() {
return random.nextInt(4); // Randomly selects a direction (0-3)
}
}
class Mouse implements Critter {
private int direction;
public Mouse() {
direction = WEST;
}
public int getChar() {
return 'M';
}
public int getMove() {
direction = (direction == WEST) ? NORTH : WEST; // Zig zag to the NW
return direction;
}
}
class Turtle implements Critter {
private int step;
public Turtle() {
step = 0;
}
public int getChar() {
return 'T';
}
public int getMove() {
int move = CENTER;
switch(step % 20) {
case 0:
case 1:
case 2:
case 3:
case 4:
move = SOUTH; // South 5
break;
case 5:
case 6:
case 7:
case 8:
case 9:
move = WEST; // West 5
break;
case 10:
case 11:
case 12:
case 13:
case 14:
move = NORTH; // North 5
break;
case 15:
case 16:
case 17:
case 18:
case 19:
move = EAST; // East 5
break;
}
step++;
return move;
}
}
class Wolf implements Critter {
private Random random;
private Critter critter;
public Wolf() {
random = new Random();
}
public void setCritter(Critter critter) {
this.critter = critter;
}
public int getChar() {
return 'W';
}
public int getMove() {
return critter.getMove(); // Copies the move of the selected critter
}
}
```
Note that for the `Turtle` class, the `getMove()` method is designed to move the turtle in a clockwise box pattern by making a complete cycle of 20 steps. It returns the appropriate direction for each step. The `step` variable is used to keep track of the current step in the cycle.
For the `Wolf` class, the `setCritter()` method is provided to set the critter whose move will be copied. This allows the wolf to choose randomly from the available critters and mimic their moves.