{声明:不得转载}
当时好像使用DJ Java Decompiler反编译iCarnegie给的.class文件,然后抄了一点代码,我给出的代码好像不能编译,各位仔细咯
Catfish.java
import java.util.Vector;
import java.util.Random;
/**
* 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";
/**
* 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;
// 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;
private int energy_Gain_From_Meal;
private static final int energy_Expend_to_Eat=2;
private static final int energy_Expend_to_Swim=2;
private static final int energy_Expend_to_Look_for_Food=2;
private static final int minEnergy_Increases_In_a_Time_Block=5;
private static final int maxEnergy_Increases_In_a_Time_Block=10;
/**
* 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) {
simulation = initialSimulation;
nCatfishCreated=nCatfishCreated+1;
name = SPECIES + nCatfishCreated;
minEnergy = 10;
maxEnergy = 100;
energy = simulation.getRand().nextInt(maxEnergy - minEnergy) + minEnergy;
direction=RIGHT;
if(initialRow<=0){
row=1;
}else if(initialRow>10){
row=10;
}else{
row=initialRow;
}
if(initialColumn<1){
column=1;
}else if(initialRow>10){
column=10;
}else{
column=initialColumn;
}
}
/**
* 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)
{
energy=minEnergy;
die();
}else if(newEnergy > maxEnergy){
energy=maxEnergy;
}else{
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() {
if (energy < 2*minEnergy) // Hungry, if current energy level is less than twice the
// amount needed for survival.
{
return true;
}
else
{
return false;
}
}
/**
* 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(deadOrAlive == ALIVE){
if(newRow < row){
direction = LEFT;
}else{
direction = RIGHT;
}
if (newRow < 1){
newRow = 1;
}else if(newRow >10){
newRow = 10;
}
row = newRow;
}else if(deadOrAlive == DEAD){
row=-1;
}
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(deadOrAlive == ALIVE){
if(newColumn < column){
direction = LEFT;
}else{
direction = RIGHT;
}
if (newColumn < 1){
newColumn = 1;
}else if(newColumn >10){
newColumn = 10;
}
column = newColumn;
}else if(deadOrAlive == DEAD){
column=-1;
}
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==RIGHT){
return "/Catfish-right.gif";
}
else if(direction==LEFT){
return "/Catfish-left.gif";
}
else if(direction==UP){
return "/Catfish-up.gif";
}
else{
return "/Catfish-down.gif";
}
}
/**
* Look for food in the neighborhood. Consume some energy in the process.
*
* @return a neighboring algae that is food.
*/
private AlgaeColony lookForFoodInNeighborhood() {
setEnergy(getEnergy() - energy_Expend_to_Look_for_Food);
if(isDead()){
return null;
}
Vector neighbors = simulation.getNeighbors(getRow(), getColumn(), 1);
for(int 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(isDead()){
return;
}else{
age++;
swimInTheTake();
eatAlgaeColony();
minEnergy = minEnergy + minEnergy_Increases_In_a_Time_Block;
maxEnergy = maxEnergy + maxEnergy_Increases_In_a_Time_Block;
return;
}
}
public void swimInTheTake(){
if(isDead()){
return;
}
if(isHungry()){
AlgaeColony food = lookForFoodInNeighborhood();
if(food != null)
{
setEnergy(getEnergy() - 2);
if(isDead())
return;
moveToRow(food.getRow());
moveToColumn(food.getColumn());
}
return;
}
setEnergy(getEnergy() - energy_Expend_to_Swim);
if(isDead()){
return;
}
int directionswitch = simulation.getRand().nextInt(4);
if(directionswitch == 0){
moveToRow(getRow() - 1);
}
if(directionswitch == 1){
moveToRow(getRow() + 1);
}
if(directionswitch == 2){
moveToColumn(getColumn() - 1);
}
if(directionswitch == 3){
moveToColumn(getColumn() + 1);
}
}
public void eatAlgaeColony(){
if(isDead()){
return;
}
Vector foodMaybe = simulation.getNeighbors(getRow(), getColumn(), 0);
for(int neighborIndex = 0; neighborIndex < foodMaybe.size(); neighborIndex++)
if(foodMaybe.get(neighborIndex) instanceof AlgaeColony)
{
AlgaeColony alg = (AlgaeColony)foodMaybe.get(neighborIndex);
energy_Gain_From_Meal = alg.giveUpEnergy(10);
setEnergy((getEnergy() + energy_Gain_From_Meal) - energy_Expend_to_Eat);
return;
}
}
}
Crocodile.java
import java.util.Vector;
import java.util.Random;
/**
* 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";
/**
* 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 = 15;
/**
* Maximum energy that a baby can store.
*/
private static final int BABY_MAX_ENERGY = 100;
// 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 Crocodile 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 nCrocodilesCreated = 0;
private int energy_Gain_From_Meal;
private static final int energy_Expend_to_Eat=5;
private static final int energy_Expend_to_Swim=5;
private static final int energy_Expend_to_Look_for_Food=5;
private static final int minEnergy_Increases_In_a_Time_Block=5;
private static final int maxEnergy_Increases_In_a_Time_Block=10;
/**
* Constructor. Initialize an Crocodile to start life at a specified
* location with a specified energy. If location is out of bounds,
* locate the Crocodile 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 Crocodile belongs to
*/
public Crocodile(
int initialRow,
int initialColumn,
Simulation initialSimulation) {
simulation = initialSimulation;
nCrocodilesCreated=nCrocodilesCreated+1;
name = SPECIES + nCrocodilesCreated;
minEnergy = 500;
maxEnergy = 2000;
energy = simulation.getRand().nextInt(maxEnergy - minEnergy) + minEnergy;
direction=RIGHT;
if(initialRow<=0){
row=1;
}else if(initialRow>10){
row=10;
}else{
row=initialRow;
}
if(initialColumn<1){
column=1;
}else if(initialRow>10){
column=10;
}else{
column=initialColumn;
}
}
/**
* 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)
{
energy=minEnergy;
die();
}else if(newEnergy > maxEnergy){
energy=maxEnergy;
}else{
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 Crocodile.
*/
private String getDirection() {
return direction;
}
/**
* Is the Crocodile hungry?
*
* @return True, if hungry. False, otherwise.
*/
private boolean isHungry() {
if (energy < 2*minEnergy) // Hungry, if current energy level is less than twice the
// amount needed for survival.
{
return true;
}
else
{
return false;
}
}
/**
* 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(deadOrAlive == ALIVE){
if (newRow < 1){
if(newRow < row){
direction = UP;
}else{
direction = DOWN;
}
row = 1;
}else if(newRow >= 10){
if(newRow < row){
direction = UP;
}else{
direction = DOWN;
}
row = 10;
}else{
if(newRow < row){
direction = UP;
}else{
direction = DOWN;
}
row = newRow;
}
}else if(deadOrAlive == DEAD){
row=-1;
}
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(deadOrAlive == ALIVE){
if (newColumn < 1){
if(newColumn < column){
direction = LEFT;
}else{
direction = RIGHT;
}
column = 1;
}else if(newColumn >= 10){
if(newColumn < column){
direction = LEFT;
}else{
direction = RIGHT;
}
column = 10;
}else{
if(newColumn < column){
direction = LEFT;
}else{
direction = RIGHT;
}
column = newColumn;
}
}else if(deadOrAlive == DEAD){
column=-1;
}
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==RIGHT){
return "/Crocodile-right.gif";
}
else if(direction==LEFT){
return "/Crocodile-left.gif";
}
else if(direction==UP){
return "/Crocodile-up.gif";
}
else{
return "/Crocodile-down.gif";
}
}
/**
* Crocodile lives its life. It may lose or gain energy.
*/
public void liveALittle() {
if(isDead()){
return;
}else{
age++;
swimInTheTake();
eatCatfish();
minEnergy = minEnergy + minEnergy_Increases_In_a_Time_Block;
maxEnergy = maxEnergy + maxEnergy_Increases_In_a_Time_Block;
return;
}
}
public void swimInTheTake(){
setEnergy(getEnergy() - energy_Expend_to_Swim);
if(isDead()){
return;
}
int newRow = simulation.getRand().nextInt(10)+1;
int newColumn = simulation.getRand().nextInt(10)+1;
moveToRow(newRow);
moveToColumn(newColumn);
int directionswitch = simulation.getRand().nextInt(4);
if(directionswitch == 0){
moveToRow(getRow() - 1);
}
if(directionswitch == 1){
moveToRow(getRow() + 1);
}
if(directionswitch == 2){
moveToColumn(getColumn() - 1);
}
if(directionswitch == 3){
moveToColumn(getColumn() + 1);
}
}
public void eatCatfish(){
if(isDead()){
return;
}
Vector foodMaybe = simulation.getNeighbors(getRow(), getColumn(), 0);
for(int neighborIndex = 0; neighborIndex < foodMaybe.size(); neighborIndex++)
if(foodMaybe.get(neighborIndex) instanceof Catfish)
{
Catfish fish = (Catfish)foodMaybe.get(neighborIndex);
energy_Gain_From_Meal = fish.getEnergy();
setEnergy((getEnergy() + energy_Gain_From_Meal) - energy_Expend_to_Eat);
return;
}
}
}
当时好像使用DJ Java Decompiler反编译iCarnegie给的.class文件,然后抄了一点代码,我给出的代码好像不能编译,各位仔细咯
Catfish.java
import java.util.Vector;
import java.util.Random;
/**
* 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";
/**
* 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;
// 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;
private int energy_Gain_From_Meal;
private static final int energy_Expend_to_Eat=2;
private static final int energy_Expend_to_Swim=2;
private static final int energy_Expend_to_Look_for_Food=2;
private static final int minEnergy_Increases_In_a_Time_Block=5;
private static final int maxEnergy_Increases_In_a_Time_Block=10;
/**
* 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) {
simulation = initialSimulation;
nCatfishCreated=nCatfishCreated+1;
name = SPECIES + nCatfishCreated;
minEnergy = 10;
maxEnergy = 100;
energy = simulation.getRand().nextInt(maxEnergy - minEnergy) + minEnergy;
direction=RIGHT;
if(initialRow<=0){
row=1;
}else if(initialRow>10){
row=10;
}else{
row=initialRow;
}
if(initialColumn<1){
column=1;
}else if(initialRow>10){
column=10;
}else{
column=initialColumn;
}
}
/**
* 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)
{
energy=minEnergy;
die();
}else if(newEnergy > maxEnergy){
energy=maxEnergy;
}else{
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() {
if (energy < 2*minEnergy) // Hungry, if current energy level is less than twice the
// amount needed for survival.
{
return true;
}
else
{
return false;
}
}
/**
* 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(deadOrAlive == ALIVE){
if(newRow < row){
direction = LEFT;
}else{
direction = RIGHT;
}
if (newRow < 1){
newRow = 1;
}else if(newRow >10){
newRow = 10;
}
row = newRow;
}else if(deadOrAlive == DEAD){
row=-1;
}
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(deadOrAlive == ALIVE){
if(newColumn < column){
direction = LEFT;
}else{
direction = RIGHT;
}
if (newColumn < 1){
newColumn = 1;
}else if(newColumn >10){
newColumn = 10;
}
column = newColumn;
}else if(deadOrAlive == DEAD){
column=-1;
}
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==RIGHT){
return "/Catfish-right.gif";
}
else if(direction==LEFT){
return "/Catfish-left.gif";
}
else if(direction==UP){
return "/Catfish-up.gif";
}
else{
return "/Catfish-down.gif";
}
}
/**
* Look for food in the neighborhood. Consume some energy in the process.
*
* @return a neighboring algae that is food.
*/
private AlgaeColony lookForFoodInNeighborhood() {
setEnergy(getEnergy() - energy_Expend_to_Look_for_Food);
if(isDead()){
return null;
}
Vector neighbors = simulation.getNeighbors(getRow(), getColumn(), 1);
for(int 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(isDead()){
return;
}else{
age++;
swimInTheTake();
eatAlgaeColony();
minEnergy = minEnergy + minEnergy_Increases_In_a_Time_Block;
maxEnergy = maxEnergy + maxEnergy_Increases_In_a_Time_Block;
return;
}
}
public void swimInTheTake(){
if(isDead()){
return;
}
if(isHungry()){
AlgaeColony food = lookForFoodInNeighborhood();
if(food != null)
{
setEnergy(getEnergy() - 2);
if(isDead())
return;
moveToRow(food.getRow());
moveToColumn(food.getColumn());
}
return;
}
setEnergy(getEnergy() - energy_Expend_to_Swim);
if(isDead()){
return;
}
int directionswitch = simulation.getRand().nextInt(4);
if(directionswitch == 0){
moveToRow(getRow() - 1);
}
if(directionswitch == 1){
moveToRow(getRow() + 1);
}
if(directionswitch == 2){
moveToColumn(getColumn() - 1);
}
if(directionswitch == 3){
moveToColumn(getColumn() + 1);
}
}
public void eatAlgaeColony(){
if(isDead()){
return;
}
Vector foodMaybe = simulation.getNeighbors(getRow(), getColumn(), 0);
for(int neighborIndex = 0; neighborIndex < foodMaybe.size(); neighborIndex++)
if(foodMaybe.get(neighborIndex) instanceof AlgaeColony)
{
AlgaeColony alg = (AlgaeColony)foodMaybe.get(neighborIndex);
energy_Gain_From_Meal = alg.giveUpEnergy(10);
setEnergy((getEnergy() + energy_Gain_From_Meal) - energy_Expend_to_Eat);
return;
}
}
}
Crocodile.java
import java.util.Vector;
import java.util.Random;
/**
* 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";
/**
* 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 = 15;
/**
* Maximum energy that a baby can store.
*/
private static final int BABY_MAX_ENERGY = 100;
// 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 Crocodile 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 nCrocodilesCreated = 0;
private int energy_Gain_From_Meal;
private static final int energy_Expend_to_Eat=5;
private static final int energy_Expend_to_Swim=5;
private static final int energy_Expend_to_Look_for_Food=5;
private static final int minEnergy_Increases_In_a_Time_Block=5;
private static final int maxEnergy_Increases_In_a_Time_Block=10;
/**
* Constructor. Initialize an Crocodile to start life at a specified
* location with a specified energy. If location is out of bounds,
* locate the Crocodile 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 Crocodile belongs to
*/
public Crocodile(
int initialRow,
int initialColumn,
Simulation initialSimulation) {
simulation = initialSimulation;
nCrocodilesCreated=nCrocodilesCreated+1;
name = SPECIES + nCrocodilesCreated;
minEnergy = 500;
maxEnergy = 2000;
energy = simulation.getRand().nextInt(maxEnergy - minEnergy) + minEnergy;
direction=RIGHT;
if(initialRow<=0){
row=1;
}else if(initialRow>10){
row=10;
}else{
row=initialRow;
}
if(initialColumn<1){
column=1;
}else if(initialRow>10){
column=10;
}else{
column=initialColumn;
}
}
/**
* 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)
{
energy=minEnergy;
die();
}else if(newEnergy > maxEnergy){
energy=maxEnergy;
}else{
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 Crocodile.
*/
private String getDirection() {
return direction;
}
/**
* Is the Crocodile hungry?
*
* @return True, if hungry. False, otherwise.
*/
private boolean isHungry() {
if (energy < 2*minEnergy) // Hungry, if current energy level is less than twice the
// amount needed for survival.
{
return true;
}
else
{
return false;
}
}
/**
* 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(deadOrAlive == ALIVE){
if (newRow < 1){
if(newRow < row){
direction = UP;
}else{
direction = DOWN;
}
row = 1;
}else if(newRow >= 10){
if(newRow < row){
direction = UP;
}else{
direction = DOWN;
}
row = 10;
}else{
if(newRow < row){
direction = UP;
}else{
direction = DOWN;
}
row = newRow;
}
}else if(deadOrAlive == DEAD){
row=-1;
}
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(deadOrAlive == ALIVE){
if (newColumn < 1){
if(newColumn < column){
direction = LEFT;
}else{
direction = RIGHT;
}
column = 1;
}else if(newColumn >= 10){
if(newColumn < column){
direction = LEFT;
}else{
direction = RIGHT;
}
column = 10;
}else{
if(newColumn < column){
direction = LEFT;
}else{
direction = RIGHT;
}
column = newColumn;
}
}else if(deadOrAlive == DEAD){
column=-1;
}
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==RIGHT){
return "/Crocodile-right.gif";
}
else if(direction==LEFT){
return "/Crocodile-left.gif";
}
else if(direction==UP){
return "/Crocodile-up.gif";
}
else{
return "/Crocodile-down.gif";
}
}
/**
* Crocodile lives its life. It may lose or gain energy.
*/
public void liveALittle() {
if(isDead()){
return;
}else{
age++;
swimInTheTake();
eatCatfish();
minEnergy = minEnergy + minEnergy_Increases_In_a_Time_Block;
maxEnergy = maxEnergy + maxEnergy_Increases_In_a_Time_Block;
return;
}
}
public void swimInTheTake(){
setEnergy(getEnergy() - energy_Expend_to_Swim);
if(isDead()){
return;
}
int newRow = simulation.getRand().nextInt(10)+1;
int newColumn = simulation.getRand().nextInt(10)+1;
moveToRow(newRow);
moveToColumn(newColumn);
int directionswitch = simulation.getRand().nextInt(4);
if(directionswitch == 0){
moveToRow(getRow() - 1);
}
if(directionswitch == 1){
moveToRow(getRow() + 1);
}
if(directionswitch == 2){
moveToColumn(getColumn() - 1);
}
if(directionswitch == 3){
moveToColumn(getColumn() + 1);
}
}
public void eatCatfish(){
if(isDead()){
return;
}
Vector foodMaybe = simulation.getNeighbors(getRow(), getColumn(), 0);
for(int neighborIndex = 0; neighborIndex < foodMaybe.size(); neighborIndex++)
if(foodMaybe.get(neighborIndex) instanceof Catfish)
{
Catfish fish = (Catfish)foodMaybe.get(neighborIndex);
energy_Gain_From_Meal = fish.getEnergy();
setEnergy((getEnergy() + energy_Gain_From_Meal) - energy_Expend_to_Eat);
return;
}
}
}