Checklist
Correctly working code.
No changes made to functions already provided in
cat+mouse.cc
, or to the public interface in
positions.h
.
Sufficient testing, with output sufficient to verify test correctness:
tests on specified values for cat and mouse positions;
evidence of independent tests of all functions in positions.cc;
tests sufficient to exercise all statements in the program.
Adherence to CS 9F style standards:
appropriate use of indenting and white space;
avoidance of forbidden C++;
variable and function names that reflect their use;
informative comments at the head of each function;
no routine more than twenty-four lines of code.
Clean case analysis and simple loop structuring.
Suitable input prompts and informative output, including at least the positions of the cat and mouse after each move, and the final result of the chase.
cat+mouse.cc
framework
#include <iostream.h>
#include <math.h>
#include "positions.h"
// You define the GetPositions function.
// It should read legal cat and mouse positions from the user
// and return the position values in its two arguments.
void GetPositions ( ... [you fill these in] ) {
... [you fill this in]
}
// You define the RunChase function.
// Given initialized cat and mouse positions,
// it should simulate the cat chasing the mouse, printing the
// result of each movement of cat and mouse. Either the cat will
// catch the mouse, or 30 time units will go by and the cat will
// give up.
void RunChase ( ... [you fill this in] ) {
... [you fill this in]
}
int main () {
Position cat, mouse;
GetPositions (cat, mouse);
RunChase (cat, mouse);
return 0;
}
positions.h
#ifndef POSITIONS_H
#define POSITIONS_H
// typedef int bool; // necessary for some C++ programming environments
class Position {
public:
// Initialize a position.
Position (); // radius = 1, angle = 0.
Position (float r); // angle = 0.
Position (float r, float thetaInRadians);
// Reinitialize a position.
void SetAbsolutePosition (float r, float thetaInRadians);
// Change the current position, incrementing the radius by
// rChange and incrementing the angle by distChange.
// Negative radius values represent movement toward the statue.
// Positive distance changes represent counterclockwise
// motion; negative values are clockwise.
void IncrementPosition (float rChange, float distChange);
// Print a position.
void Print ( );
// Return true if someone at the position can see someone or
// something at the argument position (i.e. the statue does
// not block one's view), and return false otherwise.
bool Sees (Position pos);
// Return true if the position is at the base of the statue,
// i.e. its radius = 1, and return false otherwise.
bool IsAtStatue ( );
// Return true if the position is between the first argument
// position and the second. Precondition: the counterclockwise
// difference between the first and second argument positions
// is less than radians, and the radii of all the positions
// are the same.
bool IsBetween (Position pos1, Position pos2);
private:
float radius;
float angleInRadians;
};
#endif
C++ version with inheritance
M. Clancy, U.C. Berkeley
The directory
~cs9f/lib/inherit/cat+mouse
contains a version of the cat-and-mouse programs. You are to complete it by adding a module that uses inheritance. The following files are provided in
~cs9f/lib/inherit/cat+mouse
.
cat+mouse.cc
This contains the main program, which constructs a scene of animals running around the statue and runs the simulation. The simulation stops when one of the animals in the scene captures its target. The code doesn't do much error checking. Dont worry about that; just use it unmodified.
park.h
and
park.cc
These comprise the module for the scene and the basic animal object. The Scene constructor prompts the user for the name, animal type, starting position, and target object for each animal in the simulation. The
Animal
class is the base class for simulation animals. It defines a virtual
Chase
method that
Animal
objects use to move.
positions.h
,
hp.positions.o
,
dec.positions.o
, and
solaris.positions.o
These comprise a module for positions similar to what you wrote for the flow of control project. Use the appropriate
.o
file depending on whether you work on a Hewlett-Packard workstation (in Soda or Cory), a DEC workstation (in Cory), or a workstation running Solaris (in Soda). If youre working on another platform, you will have to implement the changes yourself to the positions module from the flow-of-control project, but they wont be difficult.
You are to provide files
animals.h
and
animals.cc
that define classes
Mouse
,
Cat
, and
Person
. A
Mouse
object doesnt chase anything; it merely moves counterclockwise around the statue, one meter per call to
Chase
. A
Cat
object has a
Mouse
object as its target. If the cat sees its target, it moves one meter toward the statue; otherwise it circles 1.25 meters counterclockwise around the statue. A
Person
object is trying to photograph the situation. It doesn't try to capture anything. If it sees its target, it doesn't move; otherwise it circles 2 meters clockwise around the statue.
Mouse
,
Cat
, and
Person
are to be derived from class
Animal
. Provide enough diagnostic output in each member function so that a tutor can see whether its performing as specified. Test your program in the same way you did for the flow-of-control project. Your program should also adhere to standards described in the section "Style guidelines" in this study guide.
cat+mouse.cc
#include <iostream.h>
#include "inherit/cat+mouse/park.h"
void RunChase (Scene allAnimals) {
for (int time=1; time<=30; time++) {
for (int k=0; k<allAnimals.Length (); k++) {
if (allAnimals[k]->Chase ()) {
return;
}
}
cout << endl;
}
cout << "Chase took too long; all animals drifted away."
<< endl;
}
int main () {
Scene allAnimals;
RunChase (allAnimals);
return 0;
}
park.h
#ifndef PARK_H
#define PARK_H
#include "vectors.h"
#include "Astrings.h"
#include "inherit/cat+mouse/positions.h"
class Animal {
friend class Scene;
public:
Animal (string s, Position p);
string Name () const;
Position Pos () const;
// Move the animal, and return true if it catches
// its target.
virtual bool Chase () = 0;
protected:
string name; // animal's name
Position pos; // animal's position
Animal *target; // ptr to animal being chased; 0 if none
};
class Scene {
public:
Scene ();
int Length ();
Animal* &operator[] (int k);
private:
Vector<Animal*> allAnimals;
};
#endif
park.cc
#include "vectors.h"
#include "Astrings.h"
#include "inherit/cat+mouse/positions.h"
#include "inherit/cat+mouse/park.h"
#include "animals.h"
const int NUMANIMALS = 3;
// Set up the scene of animals.
Scene::Scene (): allAnimals (NUMANIMALS) {
string response1, response2;
float r, thetaInRadians;
int k;
for (k=0; k<NUMANIMALS; k++) {
cout << "What kind of animal should be next? ";
cin >> response1;
cout << "What is its name? ";
cin >> response2;
cout << "What is its starting position?" << endl
<< " radius = ";
cin >> r;
cout << " angle in radians = ";
cin >> thetaInRadians;
Position coords (r, thetaInRadians);
if (response1 == "mouse") {
allAnimals[k] = new Mouse (response2, coords);
}else if (response1 == "cat") {
allAnimals[k] = new Cat (response2, coords);
}else if (response1 == "person") {
allAnimals[k] = new Person (response2, coords);
}else {
cout << "I don't know what that is." << endl;
exit (1);
}
}
// Define all the targets for the animals.
for (k=0; k<NUMANIMALS; k++) {
cout << "Who is " << allAnimals[k]->name << " chasing? ";
cin >> response1;
for (int k2=0; k2<NUMANIMALS; k2++) {
if (response1 == allAnimals[k2]->name) {
if (k2 == k) {
cout << allAnimals[k]->name << " can't chase itself!" << endl;
exit (1);
}else {
allAnimals[k]->target = allAnimals[k2];
break;
}
}
}
if (allAnimals[k]->target == 0) {
cout << "*** not chasing anyone." << endl;
}
}
}
// Return the number of animals in the scene.
int Scene::Length () {
return allAnimals.Length ();
}
// Index the scene.
Animal* &Scene::operator[] (int k) {
return allAnimals[k];
}
// Constructor (s is the animal's name,
// coords is its starting position).
Animal::Animal (string s, Position coords) {
name = s;
pos = coords;
target = 0;
}
// Access functions.
string Animal::Name () const {
return name;
}
Position Animal::Pos () const {
return pos;
}
positions.h
#ifndef POSITIONS_H
#define POSITIONS_H
class Position {
public:
// Initialize a position.
Position (); // r = 1, angle = 0.
Position (float r); // angle = 0.
Position (float r, float thetaInRadians);
// Reinitialize a position.
void SetAbsolutePosition (float r, float thetaInRadians);
// Change the current position, incrementing the radius by
// rChange and incrementing the angle by distChange.
// Negative radius values represent movement toward the
// statue. Positive distance changes represent
// counterclockwise motion; negative values are clockwise.
void IncrementPosition (float rChange, float distChange);
// Compare two positions.
bool operator== (Position coords);
// Print a position.
void Print ();
friend ostream& operator<< (ostream &out, Position &pos);
// Return true if someone at the position can see someone
// or something at the argument position (i.e. the statue
// does not block one's view), and return false otherwise.
bool Sees (Position pos);
// Return true if the position is at the base of the statue,
// i.e. its radius = 1, and return false otherwise.
bool IsAtStatue ();
// Return true if the position is between the first argument
// position and the second. Precondition: the difference
// between the first and second argument positions is less
// than pi radians, and the radii of all the positions
// are the same.
bool IsBetween (Position old, Position current);
private:
float radius;
float angleInRadians;
float Normalize (float radians);
};
#endif
Java applet version
M. Clancy, U.C. Berkeley
Checklist
Correctly working code:
completion of the
Cat
move
method;
completion of the
Position
class;
completion of the
CatMouseChase
actionPerformed
method.
Sufficient testing:
applet to test the
Position
methods;
an
init
method in that applet that supplies sufficiently comprehensive tests;
html
files that exercise all statements in the remainder of the applet.
Good style:
appropriate use of indenting and white space;
variable and method names that reflect their use;
informative comments at the head of each method;
clean case analysis.
CatMouseChase.fw.java
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class CatMouseChase extends Applet implements ActionListener {
public void init ( ) {
super.init ( );
nextStep = new Button ("Move once");
add (nextStep);
nextStep.addActionListener (this);
ourWindowWidth = getIntegerParam ("width");
ourWindowHeight = getIntegerParam ("height");
myXCenter = ourWindowWidth/2;
myYCenter = ourWindowHeight/2;
int smallestDimension
= ourWindowWidth < ourWindowHeight? ourWindowWidth: ourWindowHeight;
double mouseAngle = getDoubleParam ("mouseangle");
double catRadius = getDoubleParam ("catradius");
double catAngle = getDoubleParam ("catangle");
myUnit = (smallestDimension/2 - BORDER)/((int) (catRadius+1.0));
myCat = new Cat (new Position (catRadius, catAngle));
myMouse = new Mouse (new Position (1.0, mouseAngle));
statusString = "Chase is in progress.";
}
private int getIntegerParam (String name) {
String value = this.getParameter (name);
if (value == "") {
return 0;
}
try {
return Integer.parseInt (value);
} catch (Exception e) {
return 0;
}
}
private double getDoubleParam (String name) {
String value = this.getParameter (name);
if (value == "") {
return 0.0;
}
try {
return Double.valueOf (value).doubleValue ( );
} catch (Exception e) {
return 0.0;
}
}
public void actionPerformed (ActionEvent event) {
// You fill this in.
}
public void paint (Graphics g) {
// The magic numbers used here should really depend on the height of the
// type face used to display the window annotations.
// We'll fix that for next semester.
g.drawOval (myXCenter+5-myUnit, myYCenter+5-myUnit, 2*myUnit-10, 2*myUnit-10);
g.drawString ("C",
myCat.getPosition ( ).xCoord (myXCenter, myUnit)-5,
myCat.getPosition ( ).yCoord (myYCenter, myUnit)+5 );
g.drawString ("M",
myMouse.getPosition ( ).xCoord (myXCenter, myUnit)-5,
myMouse.getPosition ( ).yCoord (myYCenter, myUnit)+5 );
g.drawString ("Mouse at " + myMouse.getPosition ( )
+ "; cat at " + myCat.getPosition ( ), 50, ourWindowHeight-30);
g.drawString (statusString, 50, ourWindowHeight-15);
}
private Cat myCat;
private Mouse myMouse;
private boolean chaseIsOver = false;
private int timeElapsed;
private final int TIME_LIMIT = 30;
private Button nextStep;
private String statusString = "Not yet started.";
private final int BORDER = 50; // margin for buttons and status strings
private static int ourWindowWidth, ourWindowHeight;
private int myXCenter, myYCenter, myUnit;
}
Position.fw.java
public class Position {
// Represent a position (radius, angle) in polar coordinates.
// All angles are in radians.
// The internal representation of an angle is always at least 0
// and less than 2 * PI. Also, the radius is always at least 1.
public Position ( ) {
myRadius = 0;
myAngle = 0;
}
public Position (Position p) {
myRadius = p.myRadius;
myAngle = p.myAngle;
}
public Position (double r, double theta) {
myRadius = r;
myAngle = theta;
}
public int xCoord (int xCenter, int unit) {
return xCenter + (int) (myRadius * Math.cos (myAngle) * unit);
}
public int yCoord (int yCenter, int unit) {
return yCenter - (int) (myRadius * Math.sin (myAngle) * unit);
}
public String toString ( ) {
return "(" + myRadius + "," + myAngle + ")";
}
// Update the current position according to the given increments.
// Preconditions: thetaChange is less than 2 * PI and greater than -2 * PI;
// one of rChange and thetaChange is 0.
public void update (double rChange, double thetaChange) {
// You fill this in.
}
// You will also need other methods.
private double myRadius;
private double myAngle;
}
Cat.fw.java
public class Cat {
public Cat ( ) {
myPosition = new Position ( );
}
public Cat (Position p) {
myPosition = p;
}
public Position getPosition ( ) {
return myPosition;
}
public boolean move (Position mousePosition) {
// You fill this in.
}
private Position myPosition;
}
Mouse.java
public class Mouse {
public Mouse ( ) {
myPosition = new Position ( );
}
public Mouse (Position p) {
myPosition = p;
}
public Position getPosition ( ) {
return myPosition;
}
public void move ( ) {
myPosition.update (0.0, 1.0);
}
private Position myPosition;
}
