2 java files :
1)catfish.java
==============================================
2) crocodile.java
import java.util.Vector;
/**
* Crocodile - simulates a crocodile - can swim, eat, and consume
* energy in the process.
*/
public class Crocodile extends LivingBeing {
/**
* The crocodile is born "alive".
* Then it dies, becoming a corpse.
*/
private static final String ALIVE = "alive";
/**
* Energy needed to swim in a block of time.
*/
private static final int ENERGY_TO_SWIM = 2;
/**
* The crocodile is born "alive".
* Then it dies, becoming a "dead" corpse.
*/
private static final String DEAD = "dead";
/**
* Lowest possible energy needed for a baby to survive.
*/
private static final int BABY_MIN_ENERGY = 700;
/**
* Maximum energy that a baby can store.
*/
private static final int BABY_MAX_ENERGY = 2000;
/**
* Energy needed to look for food once.
*/
private static final int ENERGY_TO_LOOK_FOR_FOOD = 1;
/**
* Energy expended to eat once.
*/
private static final int ENERGY_TO_EAT = 1;
// Concept example: final. since it is a constant
// Concept example: static. since only one value is needed
// irrespective of number of object instances
/**
* String constant - used to indicate the direction crocodile is facing.
*/
private static final String RIGHT = "right";
/**
* String constant - used to indicate the direction crocodile is facing.
*/
private static final String LEFT = "left";
/**
* String constant - used to indicate the direction crocodile is facing.
*/
private static final String UP = "up";
/**
* String constant - used to indicate the direction crocodile is facing.
*/
private static final String DOWN = "down";
/**
* Name of species
*/
private static final String SPECIES = "Crocodile";
/**
* Row-wise location of the crocodile
*/
private int row;
/**
* Column-wise location of the crocodile
*/
private int column;
/**
* Is the catfish dead or alive?
*/
private String deadOrAlive;
/**
* Amount of energy the crocodile has.
*/
private int energy;
/**
* Age expressed as blocks of time lived
*/
private int age = 0;
/**
* Name of this crocodile.
*/
private final String name;
/**
* The simulation to which this crocodile belongs.
* This is needed so the crocodile can send a message
* to simulation and ask
* for prey (or predator) in the neighboring locations.
* Prey is food. Food is good!
*/
private Simulation simulation;
/**
* Minimum energy level needed to survive.
* The minimum could increase as the individual grows.
*/
private int minEnergy;
/**
* Maximum energy level that the crocodile could carry.
* The maximum could change as the individual grows.
*/
private int maxEnergy;
/**
* Which direction am I facing.
*/
private String direction;
/**
*
* Number of crocodile created
*/
private static int nCrocodileCreated = 0;
/**
* Constructor. Initialize an crocodile to start life at a specified
* location with a specified energy. If location is out of bounds,
* locate the catfish at the nearest edge.
*
* @param initialRow - the row at which the crocodile is located
* @param initialColumn - the column at which the crocodile is located
* @param initialSimulation - the simulation that the catfish belongs to
*/
public Crocodile(
int initialRow,
int initialColumn,
Simulation initialSimulation) {
name = SPECIES + nCrocodileCreated;
simulation = initialSimulation;
deadOrAlive = ALIVE;
row = initialRow;
column = initialColumn;
minEnergy = BABY_MIN_ENERGY;
maxEnergy = BABY_MAX_ENERGY;
age = 0;
direction = RIGHT;
do{
energy = (nextInt(BABY_MIN_ENERGY)*2)+100;
}while(energy<BABY_MIN_ENERGY || energy>BABY_MAX_ENERGY);
++nCrocodileCreated;
}
/**
* Get the row at which the crocodile is located
*
* @return - the row of the crocodile's location.
*/
public int getRow() {
return row;
}
/**
* Get the column at which the crocodile is located
*
* @return - the column of the crocodile's location.
*/
public int getColumn() {
return column;
}
/**
* Get the crocodile's age
*
* @return the age of the crocodile expressed in blocks of time
*/
public int getAge() {
return age;
}
/**
* Color of the crocodile expressed in hex notation.
* For example, the "green-est" color is "#00FF00",
* "blue-est" is "#0000FF", the "red-est" is "#FF0000".
*
* @return the rgb color in hex notation. preceded by a pound character '#'
*/
public String getColor() {
return "#FFFFFF"; // default is white.
}
/**
* Get the name of this crocodile
*
* @return the name of the crocodile.
*/
public String getName() {
return name;
}
/**
* Get the minimum energy needed to live.
*
* @return the minimum energy needed for the crocodile to live.
*/
private int getMinEnergy() {
return minEnergy;
}
/**
* get the maximum energy that the crocodile can carry.
*
* @return the maximum energy the crocodile can carry.
*/
private int getMaxEnergy() {
return maxEnergy;
}
/**
* Get the energy currently carried by the crocodile.
*
* @return current energy level of the organism
*/
public int getEnergy() {
return energy;
}
/**
* Sets energy level.
* If new energy level is less than minimum energy level, the organism dies.
* New energy level is capped at maximum energy level.
*/
private void setEnergy(int newEnergy) {
if (newEnergy<minEnergy)
{
die();
}
else
{
if(newEnergy>=maxEnergy)
{
energy = maxEnergy;
}
else
energy = newEnergy;
}
energy = newEnergy;
}
/**
* Die: Change the deadOrAlive to DEAD.
*/
public void die() {
deadOrAlive = DEAD;
}
/**
* Is the crocodile dead?
*
* @return <code>true</code> if dead. <code>false</code>, otherwise.
*/
public boolean isDead() {
return (deadOrAlive == DEAD);
}
/**
* Get the direction faced by the crocodile.
*
* @return the facing direction.
*/
private String getDirection() {
return direction;
}
/**
* Is the crocodile hungry?
*
* @return True, if hungry. False, otherwise.
*/
private boolean isHungry() {
// Hungry, if current energy level is less than twice the
// amount needed for survival.
if(energy >= minEnergy*2)
return false;
else{
return true;
}
}
/**
* Move the crocodile to a new row, if new row is within lake bounds.
*
* @param newRow - the row to move to.
* @return the row moved to. Lake boundary limits movement. -1, if dead.
*/
private int moveToRow(int newRow) {
if (newRow < row) direction = LEFT;
if (newRow > row) direction = RIGHT;
row = newRow;
return row;
}
/**
* Move the crocodile to a new column, if new column is within lake bounds.
*
* @param newColumn - the column to move to.
* @return the column moved to. Lake boundary limits movement.
*/
private int moveToColumn(int newColumn) {
if (newColumn < column) direction = DOWN;
if (newColumn > column) direction = UP;
column = newColumn;
return column;
}
/**
* This individual belongs to the crocodile species.
*
* @return The string indicating the species
*/
public String getSpecies() {
return SPECIES;
}
/**
* crocodile should be displayed as an image.
*
* @return a constant defined in {@link Simulation#IMAGE Simulation} class
*/
public String getDisplayMechanism() {
return Simulation.IMAGE;
}
/**
* Get the image of the crocodile
*
* @return filename of Crocodile image
*/
public String getImage() {
if (direction == LEFT) return "/Crocodile-left.gif";
if (direction == RIGHT) return "/Crocodile-right.gif";
if (direction == UP) return "/Crocodile-up.gif";
if (direction == DOWN) return "/Crocodile-down.gif";
return "/Crocodile-right.gif";
}
/**
* Look for food in the neighborhood. Consume some energy in the process.
*
* @return a neighboring algae that is food.
*/
private Crocodile lookForFoodInNeighborhood() {
int neighborIndex;
// Looking for food consumes energy.
setEnergy(getEnergy() - ENERGY_TO_LOOK_FOR_FOOD);
if (isDead()) {
return null;
}
Vector neighbors =
simulation.getNeighbors(getRow(), getColumn(), 1);
for (neighborIndex = 0;
neighborIndex < neighbors.size();
++neighborIndex) {
if (neighbors.get(neighborIndex) instanceof Catfish) {
return (Crocodile) neighbors.get(neighborIndex);
}
}
return null;
}
/**
* Crocodile lives its life. It may lose or gain energy.
*/
public void liveALittle() {
if (energy<=minEnergy){
die();
}
++age;
minEnergy += nextInt(10);
maxEnergy += nextInt(10);
swimIfPossible();
}
/**
* Swim to a new location if possible.
* Consumes some energy.
*/
private void swimIfPossible() {
if (energy>=0){
energy = energy - ENERGY_TO_SWIM;
}
moveToColumn(nextInt(10));
moveToRow(nextInt(10));
}
public int nextInt(int w){
int a;
a = (int)((double) Math.random()*w);
return a;
}
}
1)catfish.java
import java.util.Vector;
/**
* Catfish - simulates a catfish - can swim, eat, and consume
* energy in the process.
*/
public class Catfish extends LivingBeing {
/**
* The catfish is born "alive".
* Then it dies, becoming a corpse.
*/
private static final String ALIVE = "alive";
/**
* Energy needed to swim in a block of time.
*/
private static final int ENERGY_TO_SWIM = 2;
/**
* The catfish is born "alive".
* Then it dies, becoming a "dead" corpse.
*/
private static final String DEAD = "dead";
/**
* Lowest possible energy needed for a baby to survive.
*/
private static final int BABY_MIN_ENERGY = 15;
/**
* Maximum energy that a baby can store.
*/
private static final int BABY_MAX_ENERGY = 100;
/**
* Energy needed to look for food once.
*/
private static final int ENERGY_TO_LOOK_FOR_FOOD = 1;
/**
* Energy expended to eat once.
*/
private static final int ENERGY_TO_EAT = 1;
// Concept example: final. since it is a constant
// Concept example: static. since only one value is needed
// irrespective of number of object instances
/**
* String constant - used to indicate the direction catfish is facing.
*/
private static final String RIGHT = "right";
/**
* String constant - used to indicate the direction catfish is facing.
*/
private static final String LEFT = "left";
/**
* String constant - used to indicate the direction catfish is facing.
*/
private static final String UP = "up";
/**
* String constant - used to indicate the direction catfish is facing.
*/
private static final String DOWN = "down";
/**
* Name of species
*/
private static final String SPECIES = "Catfish";
/**
* Row-wise location of the catfish
*/
private int row;
/**
* Column-wise location of the catfish
*/
private int column;
/**
* Is the catfish dead or alive?
*/
private String deadOrAlive;
/**
* Amount of energy the catfish has.
*/
private int energy;
/**
* Age expressed as blocks of time lived
*/
private int age = 0;
/**
* Name of this catfish.
*/
private final String name;
/**
* The simulation to which this catfish belongs.
* This is needed so the catfish can send a message
* to simulation and ask
* for prey (or predator) in the neighboring locations.
* Prey is food. Food is good!
*/
private Simulation simulation;
/**
* Minimum energy level needed to survive.
* The minimum could increase as the individual grows.
*/
private int minEnergy;
/**
* Maximum energy level that the catfish could carry.
* The maximum could change as the individual grows.
*/
private int maxEnergy;
/**
* Which direction am I facing.
*/
private String direction;
/**
*
* Number of Catfish created
*/
private static int nCatfishCreated = 0;
/**
* Constructor. Initialize an catfish to start life at a specified
* location with a specified energy. If location is out of bounds,
* locate the catfish at the nearest edge.
*
* @param initialRow - the row at which the catfish is located
* @param initialColumn - the column at which the catfish is located
* @param initialSimulation - the simulation that the catfish belongs to
*/
public Catfish(
int initialRow,
int initialColumn,
Simulation initialSimulation) {
name = SPECIES + nCatfishCreated;
simulation = initialSimulation;
deadOrAlive = ALIVE;
row = initialRow;
column = initialColumn;
minEnergy = BABY_MIN_ENERGY;
maxEnergy = BABY_MAX_ENERGY;
age = 0;
direction = RIGHT;
do{
energy = nextInt(BABY_MAX_ENERGY);
}while(energy<BABY_MIN_ENERGY || energy>BABY_MAX_ENERGY);
++nCatfishCreated;
}
/**
* Get the row at which the catfish is located
*
* @return - the row of the catfish's location.
*/
public int getRow() {
return row;
}
/**
* Get the column at which the catfish is located
*
* @return - the column of the catfish's location.
*/
public int getColumn() {
return column;
}
/**
* Get the catfish's age
*
* @return the age of the catfish expressed in blocks of time
*/
public int getAge() {
return age;
}
/**
* Color of the catfish expressed in hex notation.
* For example, the "green-est" color is "#00FF00",
* "blue-est" is "#0000FF", the "red-est" is "#FF0000".
*
* @return the rgb color in hex notation. preceded by a pound character '#'
*/
public String getColor() {
return "#FFFFFF"; // default is white.
}
/**
* Get the name of this catfish
*
* @return the name of the catfish.
*/
public String getName() {
return name;
}
/**
* Get the minimum energy needed to live.
*
* @return the minimum energy needed for the catfish to live.
*/
private int getMinEnergy() {
return minEnergy;
}
/**
* get the maximum energy that the catfish can carry.
*
* @return the maximum energy the catfish can carry.
*/
private int getMaxEnergy() {
return maxEnergy;
}
/**
* Get the energy currently carried by the catfish.
*
* @return current energy level of the organism
*/
public int getEnergy() {
return energy;
}
/**
* Sets energy level.
* If new energy level is less than minimum energy level, the organism dies.
* New energy level is capped at maximum energy level.
*/
private void setEnergy(int newEnergy) {
if (newEnergy<minEnergy)
{
die();
}
else
{
if(newEnergy>=maxEnergy)
{
energy = maxEnergy;
}
else
energy = newEnergy;
}
energy = newEnergy;
}
/**
* Die: Change the deadOrAlive to DEAD.
*/
public void die() {
deadOrAlive = DEAD;
}
/**
* Is the catfish dead?
*
* @return <code>true</code> if dead. <code>false</code>, otherwise.
*/
public boolean isDead() {
return (deadOrAlive == DEAD);
}
/**
* Get the direction faced by the catfish.
*
* @return the facing direction.
*/
private String getDirection() {
return direction;
}
/**
* Is the catfish hungry?
*
* @return True, if hungry. False, otherwise.
*/
private boolean isHungry() {
// Hungry, if current energy level is less than twice the
// amount needed for survival.
if(energy >= minEnergy*2)
return false;
else{
return true;
}
}
/**
* Move the catfish to a new row, if new row is within lake bounds.
*
* @param newRow - the row to move to.
* @return the row moved to. Lake boundary limits movement. -1, if dead.
*/
private int moveToRow(int newRow) {
if (newRow < row) direction = LEFT;
if (newRow > row) direction = RIGHT;
row = newRow;
return row;
}
/**
* Move the catfish to a new column, if new column is within lake bounds.
*
* @param newColumn - the column to move to.
* @return the column moved to. Lake boundary limits movement.
*/
private int moveToColumn(int newColumn) {
if (newColumn < column) direction = DOWN;
if (newColumn > column) direction = UP;
column = newColumn;
return column;
}
/**
* This individual belongs to the Catfish species.
*
* @return The string indicating the species
*/
public String getSpecies() {
return SPECIES;
}
/**
* Catfish should be displayed as an image.
*
* @return a constant defined in {@link Simulation#IMAGE Simulation} class
*/
public String getDisplayMechanism() {
return Simulation.IMAGE;
}
/**
* Get the image of the catfish
*
* @return filename of Catfish image
*/
public String getImage() {
if (direction == LEFT) return "/Catfish-left.gif";
if (direction == RIGHT) return "/Catfish-right.gif";
if (direction == UP) return "/Catfish-up.gif";
if (direction == DOWN) return "/Catfish-down.gif";
return "/Carfish-right.gif";
}
/**
* Look for food in the neighborhood. Consume some energy in the process.
*
* @return a neighboring algae that is food.
*/
private AlgaeColony lookForFoodInNeighborhood() {
int neighborIndex;
// Looking for food consumes energy.
setEnergy(getEnergy() - ENERGY_TO_LOOK_FOR_FOOD);
if (isDead()) {
return null;
}
Vector neighbors =
simulation.getNeighbors(getRow(), getColumn(), 1);
for (neighborIndex = 0;
neighborIndex < neighbors.size();
++neighborIndex) {
if (neighbors.get(neighborIndex) instanceof AlgaeColony) {
return (AlgaeColony) neighbors.get(neighborIndex);
}
}
return null;
}
/**
* Catfish lives its life. It may lose or gain energy.
*/
public void liveALittle() {
if (energy<=minEnergy){
die();
}
++age;
minEnergy += nextInt(5);
maxEnergy += nextInt(5);
swimIfPossible();
}
/**
* Swim to a new location if possible.
* Consumes some energy.
*/
private void swimIfPossible() {
if (energy>=0){
energy = energy - ENERGY_TO_SWIM;
}
moveToColumn(nextInt(10));
moveToRow(nextInt(10));
}
public int nextInt(int limit){
int a;
a = (int)((double) Math.random()*limit);
return a;
}
}
/**
* Catfish - simulates a catfish - can swim, eat, and consume
* energy in the process.
*/
public class Catfish extends LivingBeing {
/**
* The catfish is born "alive".
* Then it dies, becoming a corpse.
*/
private static final String ALIVE = "alive";
/**
* Energy needed to swim in a block of time.
*/
private static final int ENERGY_TO_SWIM = 2;
/**
* The catfish is born "alive".
* Then it dies, becoming a "dead" corpse.
*/
private static final String DEAD = "dead";
/**
* Lowest possible energy needed for a baby to survive.
*/
private static final int BABY_MIN_ENERGY = 15;
/**
* Maximum energy that a baby can store.
*/
private static final int BABY_MAX_ENERGY = 100;
/**
* Energy needed to look for food once.
*/
private static final int ENERGY_TO_LOOK_FOR_FOOD = 1;
/**
* Energy expended to eat once.
*/
private static final int ENERGY_TO_EAT = 1;
// Concept example: final. since it is a constant
// Concept example: static. since only one value is needed
// irrespective of number of object instances
/**
* String constant - used to indicate the direction catfish is facing.
*/
private static final String RIGHT = "right";
/**
* String constant - used to indicate the direction catfish is facing.
*/
private static final String LEFT = "left";
/**
* String constant - used to indicate the direction catfish is facing.
*/
private static final String UP = "up";
/**
* String constant - used to indicate the direction catfish is facing.
*/
private static final String DOWN = "down";
/**
* Name of species
*/
private static final String SPECIES = "Catfish";
/**
* Row-wise location of the catfish
*/
private int row;
/**
* Column-wise location of the catfish
*/
private int column;
/**
* Is the catfish dead or alive?
*/
private String deadOrAlive;
/**
* Amount of energy the catfish has.
*/
private int energy;
/**
* Age expressed as blocks of time lived
*/
private int age = 0;
/**
* Name of this catfish.
*/
private final String name;
/**
* The simulation to which this catfish belongs.
* This is needed so the catfish can send a message
* to simulation and ask
* for prey (or predator) in the neighboring locations.
* Prey is food. Food is good!
*/
private Simulation simulation;
/**
* Minimum energy level needed to survive.
* The minimum could increase as the individual grows.
*/
private int minEnergy;
/**
* Maximum energy level that the catfish could carry.
* The maximum could change as the individual grows.
*/
private int maxEnergy;
/**
* Which direction am I facing.
*/
private String direction;
/**
*
* Number of Catfish created
*/
private static int nCatfishCreated = 0;
/**
* Constructor. Initialize an catfish to start life at a specified
* location with a specified energy. If location is out of bounds,
* locate the catfish at the nearest edge.
*
* @param initialRow - the row at which the catfish is located
* @param initialColumn - the column at which the catfish is located
* @param initialSimulation - the simulation that the catfish belongs to
*/
public Catfish(
int initialRow,
int initialColumn,
Simulation initialSimulation) {
name = SPECIES + nCatfishCreated;
simulation = initialSimulation;
deadOrAlive = ALIVE;
row = initialRow;
column = initialColumn;
minEnergy = BABY_MIN_ENERGY;
maxEnergy = BABY_MAX_ENERGY;
age = 0;
direction = RIGHT;
do{
energy = nextInt(BABY_MAX_ENERGY);
}while(energy<BABY_MIN_ENERGY || energy>BABY_MAX_ENERGY);
++nCatfishCreated;
}
/**
* Get the row at which the catfish is located
*
* @return - the row of the catfish's location.
*/
public int getRow() {
return row;
}
/**
* Get the column at which the catfish is located
*
* @return - the column of the catfish's location.
*/
public int getColumn() {
return column;
}
/**
* Get the catfish's age
*
* @return the age of the catfish expressed in blocks of time
*/
public int getAge() {
return age;
}
/**
* Color of the catfish expressed in hex notation.
* For example, the "green-est" color is "#00FF00",
* "blue-est" is "#0000FF", the "red-est" is "#FF0000".
*
* @return the rgb color in hex notation. preceded by a pound character '#'
*/
public String getColor() {
return "#FFFFFF"; // default is white.
}
/**
* Get the name of this catfish
*
* @return the name of the catfish.
*/
public String getName() {
return name;
}
/**
* Get the minimum energy needed to live.
*
* @return the minimum energy needed for the catfish to live.
*/
private int getMinEnergy() {
return minEnergy;
}
/**
* get the maximum energy that the catfish can carry.
*
* @return the maximum energy the catfish can carry.
*/
private int getMaxEnergy() {
return maxEnergy;
}
/**
* Get the energy currently carried by the catfish.
*
* @return current energy level of the organism
*/
public int getEnergy() {
return energy;
}
/**
* Sets energy level.
* If new energy level is less than minimum energy level, the organism dies.
* New energy level is capped at maximum energy level.
*/
private void setEnergy(int newEnergy) {
if (newEnergy<minEnergy)
{
die();
}
else
{
if(newEnergy>=maxEnergy)
{
energy = maxEnergy;
}
else
energy = newEnergy;
}
energy = newEnergy;
}
/**
* Die: Change the deadOrAlive to DEAD.
*/
public void die() {
deadOrAlive = DEAD;
}
/**
* Is the catfish dead?
*
* @return <code>true</code> if dead. <code>false</code>, otherwise.
*/
public boolean isDead() {
return (deadOrAlive == DEAD);
}
/**
* Get the direction faced by the catfish.
*
* @return the facing direction.
*/
private String getDirection() {
return direction;
}
/**
* Is the catfish hungry?
*
* @return True, if hungry. False, otherwise.
*/
private boolean isHungry() {
// Hungry, if current energy level is less than twice the
// amount needed for survival.
if(energy >= minEnergy*2)
return false;
else{
return true;
}
}
/**
* Move the catfish to a new row, if new row is within lake bounds.
*
* @param newRow - the row to move to.
* @return the row moved to. Lake boundary limits movement. -1, if dead.
*/
private int moveToRow(int newRow) {
if (newRow < row) direction = LEFT;
if (newRow > row) direction = RIGHT;
row = newRow;
return row;
}
/**
* Move the catfish to a new column, if new column is within lake bounds.
*
* @param newColumn - the column to move to.
* @return the column moved to. Lake boundary limits movement.
*/
private int moveToColumn(int newColumn) {
if (newColumn < column) direction = DOWN;
if (newColumn > column) direction = UP;
column = newColumn;
return column;
}
/**
* This individual belongs to the Catfish species.
*
* @return The string indicating the species
*/
public String getSpecies() {
return SPECIES;
}
/**
* Catfish should be displayed as an image.
*
* @return a constant defined in {@link Simulation#IMAGE Simulation} class
*/
public String getDisplayMechanism() {
return Simulation.IMAGE;
}
/**
* Get the image of the catfish
*
* @return filename of Catfish image
*/
public String getImage() {
if (direction == LEFT) return "/Catfish-left.gif";
if (direction == RIGHT) return "/Catfish-right.gif";
if (direction == UP) return "/Catfish-up.gif";
if (direction == DOWN) return "/Catfish-down.gif";
return "/Carfish-right.gif";
}
/**
* Look for food in the neighborhood. Consume some energy in the process.
*
* @return a neighboring algae that is food.
*/
private AlgaeColony lookForFoodInNeighborhood() {
int neighborIndex;
// Looking for food consumes energy.
setEnergy(getEnergy() - ENERGY_TO_LOOK_FOR_FOOD);
if (isDead()) {
return null;
}
Vector neighbors =
simulation.getNeighbors(getRow(), getColumn(), 1);
for (neighborIndex = 0;
neighborIndex < neighbors.size();
++neighborIndex) {
if (neighbors.get(neighborIndex) instanceof AlgaeColony) {
return (AlgaeColony) neighbors.get(neighborIndex);
}
}
return null;
}
/**
* Catfish lives its life. It may lose or gain energy.
*/
public void liveALittle() {
if (energy<=minEnergy){
die();
}
++age;
minEnergy += nextInt(5);
maxEnergy += nextInt(5);
swimIfPossible();
}
/**
* Swim to a new location if possible.
* Consumes some energy.
*/
private void swimIfPossible() {
if (energy>=0){
energy = energy - ENERGY_TO_SWIM;
}
moveToColumn(nextInt(10));
moveToRow(nextInt(10));
}
public int nextInt(int limit){
int a;
a = (int)((double) Math.random()*limit);
return a;
}
}
==============================================
2) crocodile.java
import java.util.Vector;
/**
* Crocodile - simulates a crocodile - can swim, eat, and consume
* energy in the process.
*/
public class Crocodile extends LivingBeing {
/**
* The crocodile is born "alive".
* Then it dies, becoming a corpse.
*/
private static final String ALIVE = "alive";
/**
* Energy needed to swim in a block of time.
*/
private static final int ENERGY_TO_SWIM = 2;
/**
* The crocodile is born "alive".
* Then it dies, becoming a "dead" corpse.
*/
private static final String DEAD = "dead";
/**
* Lowest possible energy needed for a baby to survive.
*/
private static final int BABY_MIN_ENERGY = 700;
/**
* Maximum energy that a baby can store.
*/
private static final int BABY_MAX_ENERGY = 2000;
/**
* Energy needed to look for food once.
*/
private static final int ENERGY_TO_LOOK_FOR_FOOD = 1;
/**
* Energy expended to eat once.
*/
private static final int ENERGY_TO_EAT = 1;
// Concept example: final. since it is a constant
// Concept example: static. since only one value is needed
// irrespective of number of object instances
/**
* String constant - used to indicate the direction crocodile is facing.
*/
private static final String RIGHT = "right";
/**
* String constant - used to indicate the direction crocodile is facing.
*/
private static final String LEFT = "left";
/**
* String constant - used to indicate the direction crocodile is facing.
*/
private static final String UP = "up";
/**
* String constant - used to indicate the direction crocodile is facing.
*/
private static final String DOWN = "down";
/**
* Name of species
*/
private static final String SPECIES = "Crocodile";
/**
* Row-wise location of the crocodile
*/
private int row;
/**
* Column-wise location of the crocodile
*/
private int column;
/**
* Is the catfish dead or alive?
*/
private String deadOrAlive;
/**
* Amount of energy the crocodile has.
*/
private int energy;
/**
* Age expressed as blocks of time lived
*/
private int age = 0;
/**
* Name of this crocodile.
*/
private final String name;
/**
* The simulation to which this crocodile belongs.
* This is needed so the crocodile can send a message
* to simulation and ask
* for prey (or predator) in the neighboring locations.
* Prey is food. Food is good!
*/
private Simulation simulation;
/**
* Minimum energy level needed to survive.
* The minimum could increase as the individual grows.
*/
private int minEnergy;
/**
* Maximum energy level that the crocodile could carry.
* The maximum could change as the individual grows.
*/
private int maxEnergy;
/**
* Which direction am I facing.
*/
private String direction;
/**
*
* Number of crocodile created
*/
private static int nCrocodileCreated = 0;
/**
* Constructor. Initialize an crocodile to start life at a specified
* location with a specified energy. If location is out of bounds,
* locate the catfish at the nearest edge.
*
* @param initialRow - the row at which the crocodile is located
* @param initialColumn - the column at which the crocodile is located
* @param initialSimulation - the simulation that the catfish belongs to
*/
public Crocodile(
int initialRow,
int initialColumn,
Simulation initialSimulation) {
name = SPECIES + nCrocodileCreated;
simulation = initialSimulation;
deadOrAlive = ALIVE;
row = initialRow;
column = initialColumn;
minEnergy = BABY_MIN_ENERGY;
maxEnergy = BABY_MAX_ENERGY;
age = 0;
direction = RIGHT;
do{
energy = (nextInt(BABY_MIN_ENERGY)*2)+100;
}while(energy<BABY_MIN_ENERGY || energy>BABY_MAX_ENERGY);
++nCrocodileCreated;
}
/**
* Get the row at which the crocodile is located
*
* @return - the row of the crocodile's location.
*/
public int getRow() {
return row;
}
/**
* Get the column at which the crocodile is located
*
* @return - the column of the crocodile's location.
*/
public int getColumn() {
return column;
}
/**
* Get the crocodile's age
*
* @return the age of the crocodile expressed in blocks of time
*/
public int getAge() {
return age;
}
/**
* Color of the crocodile expressed in hex notation.
* For example, the "green-est" color is "#00FF00",
* "blue-est" is "#0000FF", the "red-est" is "#FF0000".
*
* @return the rgb color in hex notation. preceded by a pound character '#'
*/
public String getColor() {
return "#FFFFFF"; // default is white.
}
/**
* Get the name of this crocodile
*
* @return the name of the crocodile.
*/
public String getName() {
return name;
}
/**
* Get the minimum energy needed to live.
*
* @return the minimum energy needed for the crocodile to live.
*/
private int getMinEnergy() {
return minEnergy;
}
/**
* get the maximum energy that the crocodile can carry.
*
* @return the maximum energy the crocodile can carry.
*/
private int getMaxEnergy() {
return maxEnergy;
}
/**
* Get the energy currently carried by the crocodile.
*
* @return current energy level of the organism
*/
public int getEnergy() {
return energy;
}
/**
* Sets energy level.
* If new energy level is less than minimum energy level, the organism dies.
* New energy level is capped at maximum energy level.
*/
private void setEnergy(int newEnergy) {
if (newEnergy<minEnergy)
{
die();
}
else
{
if(newEnergy>=maxEnergy)
{
energy = maxEnergy;
}
else
energy = newEnergy;
}
energy = newEnergy;
}
/**
* Die: Change the deadOrAlive to DEAD.
*/
public void die() {
deadOrAlive = DEAD;
}
/**
* Is the crocodile dead?
*
* @return <code>true</code> if dead. <code>false</code>, otherwise.
*/
public boolean isDead() {
return (deadOrAlive == DEAD);
}
/**
* Get the direction faced by the crocodile.
*
* @return the facing direction.
*/
private String getDirection() {
return direction;
}
/**
* Is the crocodile hungry?
*
* @return True, if hungry. False, otherwise.
*/
private boolean isHungry() {
// Hungry, if current energy level is less than twice the
// amount needed for survival.
if(energy >= minEnergy*2)
return false;
else{
return true;
}
}
/**
* Move the crocodile to a new row, if new row is within lake bounds.
*
* @param newRow - the row to move to.
* @return the row moved to. Lake boundary limits movement. -1, if dead.
*/
private int moveToRow(int newRow) {
if (newRow < row) direction = LEFT;
if (newRow > row) direction = RIGHT;
row = newRow;
return row;
}
/**
* Move the crocodile to a new column, if new column is within lake bounds.
*
* @param newColumn - the column to move to.
* @return the column moved to. Lake boundary limits movement.
*/
private int moveToColumn(int newColumn) {
if (newColumn < column) direction = DOWN;
if (newColumn > column) direction = UP;
column = newColumn;
return column;
}
/**
* This individual belongs to the crocodile species.
*
* @return The string indicating the species
*/
public String getSpecies() {
return SPECIES;
}
/**
* crocodile should be displayed as an image.
*
* @return a constant defined in {@link Simulation#IMAGE Simulation} class
*/
public String getDisplayMechanism() {
return Simulation.IMAGE;
}
/**
* Get the image of the crocodile
*
* @return filename of Crocodile image
*/
public String getImage() {
if (direction == LEFT) return "/Crocodile-left.gif";
if (direction == RIGHT) return "/Crocodile-right.gif";
if (direction == UP) return "/Crocodile-up.gif";
if (direction == DOWN) return "/Crocodile-down.gif";
return "/Crocodile-right.gif";
}
/**
* Look for food in the neighborhood. Consume some energy in the process.
*
* @return a neighboring algae that is food.
*/
private Crocodile lookForFoodInNeighborhood() {
int neighborIndex;
// Looking for food consumes energy.
setEnergy(getEnergy() - ENERGY_TO_LOOK_FOR_FOOD);
if (isDead()) {
return null;
}
Vector neighbors =
simulation.getNeighbors(getRow(), getColumn(), 1);
for (neighborIndex = 0;
neighborIndex < neighbors.size();
++neighborIndex) {
if (neighbors.get(neighborIndex) instanceof Catfish) {
return (Crocodile) neighbors.get(neighborIndex);
}
}
return null;
}
/**
* Crocodile lives its life. It may lose or gain energy.
*/
public void liveALittle() {
if (energy<=minEnergy){
die();
}
++age;
minEnergy += nextInt(10);
maxEnergy += nextInt(10);
swimIfPossible();
}
/**
* Swim to a new location if possible.
* Consumes some energy.
*/
private void swimIfPossible() {
if (energy>=0){
energy = energy - ENERGY_TO_SWIM;
}
moveToColumn(nextInt(10));
moveToRow(nextInt(10));
}
public int nextInt(int w){
int a;
a = (int)((double) Math.random()*w);
return a;
}
}
No comments:
Post a Comment