Problem

2

This assignment will give you practice with defining classes. You are to write a set of classes that define

the behavior of certain animals. You will be given a program that runs a simulation of a world with

many animals moving

around in it. Different kinds of animals will move in different ways and you are

defining those differences. As the simulation runs, animals can die by ending up on the same location,

in which case the simulator randomly selects one animal to survive t

he collision.

For this assignment you will be given a lot of supporting code that runs the simulation. You are just

defining the individual critters that wander around this world. On each round of the simulation, each

critter is asked which direction i

t wants to move. Each critter can move north, south, east or west or can

stay on the current location by saying that the direction it wants is center.

This program will probably be confusing at first because this is the first time where you are not writ

ing

the main method. Your code will not be in control. Instead, you are defining a series of objects that

become part of a larger system. For example, you might find that you want to have one of your critters

make several moves all at once. You wont b

e able to do that. The only way a critter can move is to wait

for the simulator to ask it for a move. The simulator is in control, not your critters. Although this

experience can be frustrating, it is a good introduction to the kind of programming we do

with objects.

A typical Java program involves many different interacting objects that are each a small part of a much

larger system.

Each of your classes will implement the Critter interface, shown below.

// The Critter int

erface defines the methods necessary for an animal

// to participate in the critter simulation. It must return a

// character when getChar is called that is used for displaying it on

// the screen. The getMove method must return a legal move (one of

// t

he constants NORTH, SOUTH, EAST, WEST, CENTER). See the

// CritterInfo interface for a description of its methods.

public interface Critter {

public char getChar();

Lab

2

COSC 241

public int getMove(

CritterInfo info

);

p

ublic static final int NORTH =

-

1

;

p

ublic static final int SOUTH = 3

;

public static final int EAST = 8

;

public static final int WEST = 11

;

public static final int CENTER = 42;

}

Interfaces are discussed in detail in chapter 9 of the textbook, but to do this assignment you just

need to

know a few simple rules about interfaces. Your class headers should indicate that they implement this

interface, as in:

public class Bird implements Critter {

}

The other important detail about interfaces is that you must i

nclude in each class a definition for the

two methods in the interface (the getChar method and the getMove method). For example, below is a

definition for a class called Stone that is part of the simulation. Stones are displayed with the letter S

and alw

ays stay on the current location (returning CENTER for their move).

public class Stone implements Critter {

public char getChar() {

return 'S';

}

public int getMove(CritterInfo info) {

return CENTER;

}

}

Critters move aroun

d in a world of finite size, but the word is toroidal (going off the end to the right

brings you back to the left and vice versa; going off the end to the top brings you back to the bottom

and vice versa).

You are allowed to include a constructor for your

classes if you want, although it must be a zero

-

argument constructor

(one that takes no arguments).

Lab

2

COSC 241

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

direction

s 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

You

decide

You define this

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 wont use the CritterInfo o

bject 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 intege

r 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.

No

tice 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 th

e 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, y

our

critter can stay on its current location by indicating that the direction it wants to move is CENTER.

Every time your critters are asked to move, they are passed an object of type CritterInfo that will

provide information about that particular critter.

For example, you can find out the critters current x

and y coordinates by calling getX() and getY(). You can find out what is around the critter by calling

getNeighbor using one of the direction constants. You will be told the display character for wh

atever is

in that location (a period for an empty cell). The CritterInfo interface is defined as follows:

Lab

2

COSC 241

// The CritterInfo interface defines a set of methods for querying the

// state of a critter simulation. The getX and

getY methods return a

// critter's current location in the world. The getNeighbor method

// takes a direction as a parameter (one of the constants NORTH,

// SOUTH, EAST, WEST or CENTER from the Critter interface). It

// returns the display character for

the critter that is one unit away

// in that direction (a period if the square is empty). The getHeight

// and getWidth methods return the height and width of the world.

public interface CritterInfo {

public int getX();

public int getY();

pub

lic char getNeighbor(int direction);

public int getHeight();

public int getWidth();

}

Notice that you are asked to define the Wolf class yourself, including the display character. Critters are

asked what display character to use on each round of t

he simulation, so you can have a critter that

displays itself differently over time.

Four of the style points for this assignment will be awarded on the basis of how much energy and

creativity you put into defining an interesting class. These four points

will be much harder to earn than

the other 16 points for the assignment, so it really is a way for us to reward the students who decide to

spend time figuring out an interesting critter definition.

The rest of the style points will be awarded on the basis

of your use of good comments and variable

names and your ability to express these operations simply and clearly. Any data fields (state variables)

of your classes should be declared as private.

Your classes should be stored in files called Bird.java, Fr

og.java, Mouse.java, Turtle.java and Wolf.java.