Dalam program ini terdapat 9 Class, yaitu:
8. Rabbit
Berikut adalah hasilnya:
Setelah dijalankan runLongSimulation.
Sekian dan terima kasih.
1. Simulator
2. Field
3. Randomizer
4. SimulatorView
5. Counter
6. FieldStats
7. Location
8. Rabbit
9. Fox
Berikut adalah tampilan hubungan tiap class di BlueJ.
Berikut adalah source code tiap classnya.
1. Simulator
1. Simulator
import java.util.Random;
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
import java.awt.Color;
/**
* A simple predator-prey simulator, based on a rectangular field
* containing rabbits and foxes.
*
* @author David J. Barnes and Michael Kolling
* @version 2008.03.30
*/
public class Simulator
{
// Constants representing configuration information for the simulation.
// The default width for the grid.
private static final int DEFAULT_WIDTH = 50;
// The default depth of the grid.
private static final int DEFAULT_DEPTH = 50;
// The probability that a fox will be created in any given grid position.
private static final double FOX_CREATION_PROBABILITY = 0.02;
// The probability that a rabbit will be created in any given grid position.
private static final double RABBIT_CREATION_PROBABILITY = 0.08;
// Lists of animals in the field. Separate lists are kept for ease of iteration.
private List<Rabbit> rabbits;
private List<Fox> foxes;
// The current state of the field.
private Field field;
// The current step of the simulation.
private int step;
// A graphical view of the simulation.
private SimulatorView view;
/**
* Construct a simulation field with default size.
*/
public Simulator()
{
this(DEFAULT_DEPTH, DEFAULT_WIDTH);
}
/**
* Create a simulation field with the given size.
* @param depth Depth of the field. Must be greater than zero.
* @param width Width of the field. Must be greater than zero.
*/
public Simulator(int depth, int width)
{
if(width <= 0 || depth <= 0) {
System.out.println("The dimensions must be greater than zero.");
System.out.println("Using default values.");
depth = DEFAULT_DEPTH;
width = DEFAULT_WIDTH;
}
rabbits = new ArrayList<Rabbit>();
foxes = new ArrayList<Fox>();
field = new Field(depth, width);
// Create a view of the state of each location in the field.
view = new SimulatorView(depth, width);
view.setColor(Rabbit.class, Color.orange);
view.setColor(Fox.class, Color.blue);
// Setup a valid starting point.
reset();
}
/**
* Run the simulation from its current state for a reasonably long period,
* e.g. 500 steps.
*/
public void runLongSimulation()
{
simulate(500);
}
/**
* Run the simulation from its current state for the given number of steps.
* Stop before the given number of steps if it ceases to be viable.
* @param numSteps The number of steps to run for.
*/
public void simulate(int numSteps)
{
for(int step = 1; step <= numSteps && view.isViable(field); step++) {
simulateOneStep();
}
}
/**
* Run the simulation from its current state for a single step.
* Iterate over the whole field updating the state of each
* fox and rabbit.
*/
public void simulateOneStep()
{
step++;
// Provide space for newborn rabbits.
List<Rabbit> newRabbits = new ArrayList<Rabbit>();
// Let all rabbits act.
for(Iterator<Rabbit> it = rabbits.iterator(); it.hasNext(); ) {
Rabbit rabbit = it.next();
rabbit.run(newRabbits);
if(! rabbit.isAlive()) {
it.remove();
}
}
// Provide space for newborn foxes.
List<Fox> newFoxes = new ArrayList<Fox>();
// Let all foxes act.
for(Iterator<Fox> it = foxes.iterator(); it.hasNext(); ) {
Fox fox = it.next();
fox.hunt(newFoxes);
if(! fox.isAlive()) {
it.remove();
}
}
// Add the newly born foxes and rabbits to the main lists.
rabbits.addAll(newRabbits);
foxes.addAll(newFoxes);
view.showStatus(step, field);
}
/**
* Reset the simulation to a starting position.
*/
public void reset()
{
step = 0;
rabbits.clear();
foxes.clear();
populate();
// Show the starting state in the view.
view.showStatus(step, field);
}
/**
* Randomly populate the field with foxes and rabbits.
*/
private void populate()
{
Random rand = Randomizer.getRandom();
field.clear();
for(int row = 0; row < field.getDepth(); row++) {
for(int col = 0; col < field.getWidth(); col++) {
if(rand.nextDouble() <= FOX_CREATION_PROBABILITY) {
Location location = new Location(row, col);
Fox fox = new Fox(true, field, location);
foxes.add(fox);
}
else if(rand.nextDouble() <= RABBIT_CREATION_PROBABILITY) {
Location location = new Location(row, col);
Rabbit rabbit = new Rabbit(true, field, location);
rabbits.add(rabbit);
}
// else leave the location empty.
}
}
}
}
2. Field
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
/**
* Represent a rectangular grid of field positions.
* Each position is able to store a single animal.
*
* @author David J. Barnes and Michael Kolling
* @version 2008.03.30
*/
public class Field
{
// A random number generator for providing random locations.
private static final Random rand = Randomizer.getRandom();
// The depth and width of the field.
private int depth, width;
// Storage for the animals.
private Object[][] field;
/**
* Represent a field of the given dimensions.
* @param depth The depth of the field.
* @param width The width of the field.
*/
public Field(int depth, int width)
{
this.depth = depth;
this.width = width;
field = new Object[depth][width];
}
/**
* Empty the field.
*/
public void clear()
{
for(int row = 0; row < depth; row++) {
for(int col = 0; col < width; col++) {
field[row][col] = null;
}
}
}
/**
* Clear the given location.
* @param location The location to clear.
*/
public void clear(Location location)
{
field[location.getRow()][location.getCol()] = null;
}
/**
* Place an animal at the given location.
* If there is already an animal at the location it will
* be lost.
* @param animal The animal to be placed.
* @param row Row coordinate of the location.
* @param col Column coordinate of the location.
*/
public void place(Object animal, int row, int col)
{
place(animal, new Location(row, col));
}
/**
* Place an animal at the given location.
* If there is already an animal at the location it will
* be lost.
* @param animal The animal to be placed.
* @param location Where to place the animal.
*/
public void place(Object animal, Location location)
{
field[location.getRow()][location.getCol()] = animal;
}
/**
* Return the animal at the given location, if any.
* @param location Where in the field.
* @return The animal at the given location, or null if there is none.
*/
public Object getObjectAt(Location location)
{
return getObjectAt(location.getRow(), location.getCol());
}
/**
* Return the animal at the given location, if any.
* @param row The desired row.
* @param col The desired column.
* @return The animal at the given location, or null if there is none.
*/
public Object getObjectAt(int row, int col)
{
return field[row][col];
}
/**
* Generate a random location that is adjacent to the
* given location, or is the same location.
* The returned location will be within the valid bounds
* of the field.
* @param location The location from which to generate an adjacency.
* @return A valid location within the grid area.
*/
public Location randomAdjacentLocation(Location location)
{
List<Location> adjacent = adjacentLocations(location);
return adjacent.get(0);
}
/**
* Get a shuffled list of the free adjacent locations.
* @param location Get locations adjacent to this.
* @return A list of free adjacent locations.
*/
public List<Location> getFreeAdjacentLocations(Location location)
{
List<Location> free = new LinkedList<Location>();
List<Location> adjacent = adjacentLocations(location);
for(Location next : adjacent) {
if(getObjectAt(next) == null) {
free.add(next);
}
}
return free;
}
/**
* Try to find a free location that is adjacent to the
* given location. If there is none, return null.
* The returned location will be within the valid bounds
* of the field.
* @param location The location from which to generate an adjacency.
* @return A valid location within the grid area.
*/
public Location freeAdjacentLocation(Location location)
{
// The available free ones.
List<Location> free = getFreeAdjacentLocations(location);
if(free.size() > 0) {
return free.get(0);
}
else {
return null;
}
}
/**
* Return a shuffled list of locations adjacent to the given one.
* The list will not include the location itself.
* All locations will lie within the grid.
* @param location The location from which to generate adjacencies.
* @return A list of locations adjacent to that given.
*/
public List<Location> adjacentLocations(Location location)
{
assert location != null : "Null location passed to adjacentLocations";
// The list of locations to be returned.
List<Location> locations = new LinkedList<Location>();
if(location != null) {
int row = location.getRow();
int col = location.getCol();
for(int roffset = -1; roffset <= 1; roffset++) {
int nextRow = row + roffset;
if(nextRow >= 0 && nextRow < depth) {
for(int coffset = -1; coffset <= 1; coffset++) {
int nextCol = col + coffset;
// Exclude invalid locations and the original location.
if(nextCol >= 0 && nextCol < width && (roffset != 0 || coffset != 0)) {
locations.add(new Location(nextRow, nextCol));
}
}
}
}
// Shuffle the list. Several other methods rely on the list
// being in a random order.
Collections.shuffle(locations, rand);
}
return locations;
}
/**
* Return the depth of the field.
* @return The depth of the field.
*/
public int getDepth()
{
return depth;
}
/**
* Return the width of the field.
* @return The width of the field.
*/
public int getWidth()
{
return width;
}
}
3. Randomizer
import java.util.Random;
/**
* Provide control over the randomization of the simulation.
*
* @author David J. Barnes and Michael Kolling
* @version 2008.03.30
*/
public class Randomizer
{
// The default seed for control of randomization.
private static final int SEED = 1111;
// A shared Random object, if required.
private static final Random rand = new Random(SEED);
// Determine whether a shared random generator is to be provided.
private static final boolean useShared = true;
/**
* Constructor for objects of class Randomizer
*/
public Randomizer()
{
}
/**
* Provide a random generator.
* @return A random object.
*/
public static Random getRandom()
{
if(useShared) {
return rand;
}
else {
return new Random();
}
}
/**
* Reset the randomization.
* This will have no effect if randomization is not through
* a shared Random generator.
*/
public static void reset()
{
if(useShared) {
rand.setSeed(SEED);
}
}
}
4. SimulatorView
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* A graphical view of the simulation grid.
* The view displays a colored rectangle for each location
* representing its contents. It uses a default background color.
* Colors for each type of species can be defined using the
* setColor method.
*
* @author David J. Barnes and Michael Kolling
* @version 2008.03.30
*/
public class SimulatorView extends JFrame
{
// Colors used for empty locations.
private static final Color EMPTY_COLOR = Color.white;
// Color used for objects that have no defined color.
private static final Color UNKNOWN_COLOR = Color.gray;
private final String STEP_PREFIX = "Step: ";
private final String POPULATION_PREFIX = "Population: ";
private JLabel stepLabel, population;
private FieldView fieldView;
// A map for storing colors for participants in the simulation
private Map<Class, Color> colors;
// A statistics object computing and storing simulation information
private FieldStats stats;
/**
* Create a view of the given width and height.
* @param height The simulation's height.
* @param width The simulation's width.
*/
public SimulatorView(int height, int width)
{
stats = new FieldStats();
colors = new LinkedHashMap<Class, Color>();
setTitle("Fox and Rabbit Simulation");
stepLabel = new JLabel(STEP_PREFIX, JLabel.CENTER);
population = new JLabel(POPULATION_PREFIX, JLabel.CENTER);
setLocation(100, 50);
fieldView = new FieldView(height, width);
Container contents = getContentPane();
contents.add(stepLabel, BorderLayout.NORTH);
contents.add(fieldView, BorderLayout.CENTER);
contents.add(population, BorderLayout.SOUTH);
pack();
setVisible(true);
}
/**
* Define a color to be used for a given class of animal.
* @param animalClass The animal's Class object.
* @param color The color to be used for the given class.
*/
public void setColor(Class animalClass, Color color)
{
colors.put(animalClass, color);
}
/**
* @return The color to be used for a given class of animal.
*/
private Color getColor(Class animalClass)
{
Color col = colors.get(animalClass);
if(col == null) {
// no color defined for this class
return UNKNOWN_COLOR;
}
else {
return col;
}
}
/**
* Show the current status of the field.
* @param step Which iteration step it is.
* @param field The field whose status is to be displayed.
*/
public void showStatus(int step, Field field)
{
if(!isVisible()) {
setVisible(true);
}
stepLabel.setText(STEP_PREFIX + step);
stats.reset();
fieldView.preparePaint();
for(int row = 0; row < field.getDepth(); row++) {
for(int col = 0; col < field.getWidth(); col++) {
Object animal = field.getObjectAt(row, col);
if(animal != null) {
stats.incrementCount(animal.getClass());
fieldView.drawMark(col, row, getColor(animal.getClass()));
}
else {
fieldView.drawMark(col, row, EMPTY_COLOR);
}
}
}
stats.countFinished();
population.setText(POPULATION_PREFIX + stats.getPopulationDetails(field));
fieldView.repaint();
}
/**
* Determine whether the simulation should continue to run.
* @return true If there is more than one species alive.
*/
public boolean isViable(Field field)
{
return stats.isViable(field);
}
/**
* Provide a graphical view of a rectangular field. This is
* a nested class (a class defined inside a class) which
* defines a custom component for the user interface. This
* component displays the field.
* This is rather advanced GUI stuff - you can ignore this
* for your project if you like.
*/
private class FieldView extends JPanel
{
private final int GRID_VIEW_SCALING_FACTOR = 6;
private int gridWidth, gridHeight;
private int xScale, yScale;
Dimension size;
private Graphics g;
private Image fieldImage;
/**
* Create a new FieldView component.
*/
public FieldView(int height, int width)
{
gridHeight = height;
gridWidth = width;
size = new Dimension(0, 0);
}
/**
* Tell the GUI manager how big we would like to be.
*/
public Dimension getPreferredSize()
{
return new Dimension(gridWidth * GRID_VIEW_SCALING_FACTOR,
gridHeight * GRID_VIEW_SCALING_FACTOR);
}
/**
* Prepare for a new round of painting. Since the component
* may be resized, compute the scaling factor again.
*/
public void preparePaint()
{
if(! size.equals(getSize())) { // if the size has changed...
size = getSize();
fieldImage = fieldView.createImage(size.width, size.height);
g = fieldImage.getGraphics();
xScale = size.width / gridWidth;
if(xScale < 1) {
xScale = GRID_VIEW_SCALING_FACTOR;
}
yScale = size.height / gridHeight;
if(yScale < 1) {
yScale = GRID_VIEW_SCALING_FACTOR;
}
}
}
/**
* Paint on grid location on this field in a given color.
*/
public void drawMark(int x, int y, Color color)
{
g.setColor(color);
g.fillRect(x * xScale, y * yScale, xScale-1, yScale-1);
}
/**
* The field view component needs to be redisplayed. Copy the
* internal image to screen.
*/
public void paintComponent(Graphics g)
{
if(fieldImage != null) {
Dimension currentSize = getSize();
if(size.equals(currentSize)) {
g.drawImage(fieldImage, 0, 0, null);
}
else {
// Rescale the previous image.
g.drawImage(fieldImage, 0, 0, currentSize.width, currentSize.height, null);
}
}
}
}
}
5. Counter
import java.awt.Color;
/**
* Provide a counter for a participant in the simulation.
* This includes an identifying string and a count of how
* many participants of this type currently exist within
* the simulation.
*
* @author David J. Barnes and Michael Kolling
* @version 2008.03.30
*/
public class Counter
{
// A name for this type of simulation participant
private String name;
// How many of this type exist in the simulation.
private int count;
/**
* Provide a name for one of the simulation types.
* @param name A name, e.g. "Fox".
*/
public Counter(String name)
{
this.name = name;
count = 0;
}
/**
* @return The short description of this type.
*/
public String getName()
{
return name;
}
/**
* @return The current count for this type.
*/
public int getCount()
{
return count;
}
/**
* Increment the current count by one.
*/
public void increment()
{
count++;
}
/**
* Reset the current count to zero.
*/
public void reset()
{
count = 0;
}
}
6. FieldStats
import java.awt.Color;
import java.util.HashMap;
/**
* This class collects and provides some statistical data on the state
* of a field. It is flexible: it will create and maintain a counter
* for any class of object that is found within the field.
*
* @author David J. Barnes and Michael Kolling
* @version 2008.03.30
*/
public class FieldStats
{
// Counters for each type of entity (fox, rabbit, etc.) in the simulation.
private HashMap<Class, Counter> counters;
// Whether the counters are currently up to date.
private boolean countsValid;
/**
* Construct a FieldStats object.
*/
public FieldStats()
{
// Set up a collection for counters for each type of animal that
// we might find
counters = new HashMap<Class, Counter>();
countsValid = true;
}
/**
* Get details of what is in the field.
* @return A string describing what is in the field.
*/
public String getPopulationDetails(Field field)
{
StringBuffer buffer = new StringBuffer();
if(!countsValid) {
generateCounts(field);
}
for(Class key : counters.keySet()) {
Counter info = counters.get(key);
buffer.append(info.getName());
buffer.append(": ");
buffer.append(info.getCount());
buffer.append(' ');
}
return buffer.toString();
}
/**
* Invalidate the current set of statistics; reset all
* counts to zero.
*/
public void reset()
{
countsValid = false;
for(Class key : counters.keySet()) {
Counter count = counters.get(key);
count.reset();
}
}
/**
* Increment the count for one class of animal.
* @param animalClass The class of animal to increment.
*/
public void incrementCount(Class animalClass)
{
Counter count = counters.get(animalClass);
if(count == null) {
// We do not have a counter for this species yet.
// Create one.
count = new Counter(animalClass.getName());
counters.put(animalClass, count);
}
count.increment();
}
/**
* Indicate that an animal count has been completed.
*/
public void countFinished()
{
countsValid = true;
}
/**
* Determine whether the simulation is still viable.
* I.e., should it continue to run.
* @return true If there is more than one species alive.
*/
public boolean isViable(Field field)
{
// How many counts are non-zero.
int nonZero = 0;
if(!countsValid) {
generateCounts(field);
}
for(Class key : counters.keySet()) {
Counter info = counters.get(key);
if(info.getCount() > 0) {
nonZero++;
}
}
return nonZero > 1;
}
/**
* Generate counts of the number of foxes and rabbits.
* These are not kept up to date as foxes and rabbits
* are placed in the field, but only when a request
* is made for the information.
* @param field The field to generate the stats for.
*/
private void generateCounts(Field field)
{
reset();
for(int row = 0; row < field.getDepth(); row++) {
for(int col = 0; col < field.getWidth(); col++) {
Object animal = field.getObjectAt(row, col);
if(animal != null) {
incrementCount(animal.getClass());
}
}
}
countsValid = true;
}
}
7. Location
/**
* Represent a location in a rectangular grid.
*
* @author David J. Barnes and Michael Kolling
* @version 2008.03.30
*/
public class Location
{
// Row and column positions.
private int row;
private int col;
/**
* Represent a row and column.
* @param row The row.
* @param col The column.
*/
public Location(int row, int col)
{
this.row = row;
this.col = col;
}
/**
* Implement content equality.
*/
public boolean equals(Object obj)
{
if(obj instanceof Location) {
Location other = (Location) obj;
return row == other.getRow() && col == other.getCol();
}
else {
return false;
}
}
/**
* Return a string of the form row,column
* @return A string representation of the location.
*/
public String toString()
{
return row + "," + col;
}
/**
* Use the top 16 bits for the row value and the bottom for
* the column. Except for very big grids, this should give a
* unique hash code for each (row, col) pair.
* @return A hashcode for the location.
*/
public int hashCode()
{
return (row << 16) + col;
}
/**
* @return The row.
*/
public int getRow()
{
return row;
}
/**
* @return The column.
*/
public int getCol()
{
return col;
}
}
8. Rabbit
import java.util.List;
import java.util.Random;
/**
* A simple model of a rabbit.
* Rabbits age, move, breed, and die.
*
* @author David J. Barnes and Michael Kolling
* @version 2008.03.30
*/
public class Rabbit
{
// Characteristics shared by all rabbits (static fields).
// The age at which a rabbit can start to breed.
private static final int BREEDING_AGE = 5;
// The age to which a rabbit can live.
private static final int MAX_AGE = 40;
// The likelihood of a rabbit breeding.
private static final double BREEDING_PROBABILITY = 0.15;
// The maximum number of births.
private static final int MAX_LITTER_SIZE = 4;
// A shared random number generator to control breeding.
private static final Random rand = Randomizer.getRandom();
// Individual characteristics (instance fields).
// The rabbit's age.
private int age;
// Whether the rabbit is alive or not.
private boolean alive;
// The rabbit's position.
private Location location;
// The field occupied.
private Field field;
/**
* Create a new rabbit. A rabbit may be created with age
* zero (a new born) or with a random age.
*
* @param randomAge If true, the rabbit will have a random age.
* @param field The field currently occupied.
* @param location The location within the field.
*/
public Rabbit(boolean randomAge, Field field, Location location)
{
age = 0;
alive = true;
this.field = field;
setLocation(location);
if(randomAge) {
age = rand.nextInt(MAX_AGE);
}
}
/**
* This is what the rabbit does most of the time - it runs
* around. Sometimes it will breed or die of old age.
* @param newRabbits A list to add newly born rabbits to.
*/
public void run(List<Rabbit> newRabbits)
{
incrementAge();
if(alive) {
giveBirth(newRabbits);
// Try to move into a free location.
Location newLocation = field.freeAdjacentLocation(location);
if(newLocation != null) {
setLocation(newLocation);
}
else {
// Overcrowding.
setDead();
}
}
}
/**
* Check whether the rabbit is alive or not.
* @return true if the rabbit is still alive.
*/
public boolean isAlive()
{
return alive;
}
/**
* Indicate that the rabbit is no longer alive.
* It is removed from the field.
*/
public void setDead()
{
alive = false;
if(location != null) {
field.clear(location);
location = null;
field = null;
}
}
/**
* Return the rabbit's location.
* @return The rabbit's location.
*/
public Location getLocation()
{
return location;
}
/**
* Place the rabbit at the new location in the given field.
* @param newLocation The rabbit's new location.
*/
private void setLocation(Location newLocation)
{
if(location != null) {
field.clear(location);
}
location = newLocation;
field.place(this, newLocation);
}
/**
* Increase the age.
* This could result in the rabbit's death.
*/
private void incrementAge()
{
age++;
if(age > MAX_AGE) {
setDead();
}
}
/**
* Check whether or not this rabbit is to give birth at this step.
* New births will be made into free adjacent locations.
* @param newRabbits A list to add newly born rabbits to.
*/
private void giveBirth(List<Rabbit> newRabbits)
{
// New rabbits are born into adjacent locations.
// Get a list of adjacent free locations.
List<Location> free = field.getFreeAdjacentLocations(location);
int births = breed();
for(int b = 0; b < births && free.size() > 0; b++) {
Location loc = free.remove(0);
Rabbit young = new Rabbit(false, field, loc);
newRabbits.add(young);
}
}
/**
* Generate a number representing the number of births,
* if it can breed.
* @return The number of births (may be zero).
*/
private int breed()
{
int births = 0;
if(canBreed() && rand.nextDouble() <= BREEDING_PROBABILITY) {
births = rand.nextInt(MAX_LITTER_SIZE) + 1;
}
return births;
}
/**
* A rabbit can breed if it has reached the breeding age.
* @return true if the rabbit can breed, false otherwise.
*/
private boolean canBreed()
{
return age >= BREEDING_AGE;
}
}
9. Fox
import java.util.List;
import java.util.Iterator;
import java.util.Random;
/**
* A simple model of a fox.
* Foxes age, move, eat rabbits, and die.
*
* @author David J. Barnes and Michael Kolling
* @version 2008.03.30
*/
public class Fox
{
// Characteristics shared by all foxes (static fields).
// The age at which a fox can start to breed.
private static final int BREEDING_AGE = 10;
// The age to which a fox can live.
private static final int MAX_AGE = 150;
// The likelihood of a fox breeding.
private static final double BREEDING_PROBABILITY = 0.35;
// The maximum number of births.
private static final int MAX_LITTER_SIZE = 5;
// The food value of a single rabbit. In effect, this is the
// number of steps a fox can go before it has to eat again.
private static final int RABBIT_FOOD_VALUE = 7;
// A shared random number generator to control breeding.
private static final Random rand = Randomizer.getRandom();
// Individual characteristics (instance fields).
// The fox's age.
private int age;
// Whether the fox is alive or not.
private boolean alive;
// The fox's position.
private Location location;
// The field occupied.
private Field field;
// The fox's food level, which is increased by eating rabbits.
private int foodLevel;
/**
* Create a fox. A fox can be created as a new born (age zero
* and not hungry) or with a random age and food level.
*
* @param randomAge If true, the fox will have random age and hunger level.
* @param field The field currently occupied.
* @param location The location within the field.
*/
public Fox(boolean randomAge, Field field, Location location)
{
age = 0;
alive = true;
this.field = field;
setLocation(location);
if(randomAge) {
age = rand.nextInt(MAX_AGE);
foodLevel = rand.nextInt(RABBIT_FOOD_VALUE);
}
else {
// leave age at 0
foodLevel = RABBIT_FOOD_VALUE;
}
}
/**
* This is what the fox does most of the time: it hunts for
* rabbits. In the process, it might breed, die of hunger,
* or die of old age.
* @param field The field currently occupied.
* @param newFoxes A list to add newly born foxes to.
*/
public void hunt(List<Fox> newFoxes)
{
incrementAge();
incrementHunger();
if(alive) {
giveBirth(newFoxes);
// Move towards a source of food if found.
Location newLocation = findFood(location);
if(newLocation == null) {
// No food found - try to move to a free location.
newLocation = field.freeAdjacentLocation(location);
}
// See if it was possible to move.
if(newLocation != null) {
setLocation(newLocation);
}
else {
// Overcrowding.
setDead();
}
}
}
/**
* Check whether the fox is alive or not.
* @return True if the fox is still alive.
*/
public boolean isAlive()
{
return alive;
}
/**
* Return the fox's location.
* @return The fox's location.
*/
public Location getLocation()
{
return location;
}
/**
* Place the fox at the new location in the given field.
* @param newLocation The fox's new location.
*/
private void setLocation(Location newLocation)
{
if(location != null) {
field.clear(location);
}
location = newLocation;
field.place(this, newLocation);
}
/**
* Increase the age. This could result in the fox's death.
*/
private void incrementAge()
{
age++;
if(age > MAX_AGE) {
setDead();
}
}
/**
* Make this fox more hungry. This could result in the fox's death.
*/
private void incrementHunger()
{
foodLevel--;
if(foodLevel <= 0) {
setDead();
}
}
/**
* Tell the fox to look for rabbits adjacent to its current location.
* Only the first live rabbit is eaten.
* @param location Where in the field it is located.
* @return Where food was found, or null if it wasn't.
*/
private Location findFood(Location location)
{
List<Location> adjacent = field.adjacentLocations(location);
Iterator<Location> it = adjacent.iterator();
while(it.hasNext()) {
Location where = it.next();
Object animal = field.getObjectAt(where);
if(animal instanceof Rabbit) {
Rabbit rabbit = (Rabbit) animal;
if(rabbit.isAlive()) {
rabbit.setDead();
foodLevel = RABBIT_FOOD_VALUE;
// Remove the dead rabbit from the field.
return where;
}
}
}
return null;
}
/**
* Check whether or not this fox is to give birth at this step.
* New births will be made into free adjacent locations.
* @param newFoxes A list to add newly born foxes to.
*/
private void giveBirth(List<Fox> newFoxes)
{
// New foxes are born into adjacent locations.
// Get a list of adjacent free locations.
List<Location> free = field.getFreeAdjacentLocations(location);
int births = breed();
for(int b = 0; b < births && free.size() > 0; b++) {
Location loc = free.remove(0);
Fox young = new Fox(false, field, loc);
newFoxes.add(young);
}
}
/**
* Generate a number representing the number of births,
* if it can breed.
* @return The number of births (may be zero).
*/
private int breed()
{
int births = 0;
if(canBreed() && rand.nextDouble() <= BREEDING_PROBABILITY) {
births = rand.nextInt(MAX_LITTER_SIZE) + 1;
}
return births;
}
/**
* A fox can breed if it has reached the breeding age.
*/
private boolean canBreed()
{
return age >= BREEDING_AGE;
}
/**
* Indicate that the fox is no longer alive.
* It is removed from the field.
*/
private void setDead()
{
alive = false;
if(location != null) {
field.clear(location);
location = null;
field = null;
}
}
}
Berikut adalah hasilnya:
Setelah dijalankan runLongSimulation.
Sekian dan terima kasih.
Komentar
Posting Komentar