you will use cellular automata to create a 2D predator–prey simulati.pdf

you will use cellular automata to create a 2D predator–prey simulation in your program. The
preys are ants and the predators are doodlebugs. These critters live in a 20 * 20 grid of cells.
Only one critter may occupy a cell at a time. The grid is enclosed and no critter may move off
the grid. Time is simulated in steps. Each critter performs some action every time step. The ants
behave according to the following model: Move: For every time step, the ants randomly try to
move up, down, left, or right. If the neighboring cell in the selected direction is occupied or
would move the ant off the grid, then the ant stays in the current cell. Breed: If an ant survives
for three time steps (not been eaten by doodlebugs), at the end of the time step (i.e., after
moving) the ant will breed. This is simulated by creating a new ant in an adjacent (up, down, left,
or right) cell that is empty randomly. If there is no empty cell available, no breeding occurs.
Once an offspring is produced, an ant cannot produce an offspring again until it has survived
three more time steps.
The doodlebugs behave according to the following model:
Move: For every time step, the doodlebug will firstly try to move to an adjacent cell containing
an ant and eat the ant (you can decide if there are several ants in the adjacent cells, how the
doodlebug will choose to move). If there are no ants in adjacent cells, the doodlebug moves
according to the same rules as the ant. Note that a doodlebug cannot eat other doodlebugs.
Breed: If a doodlebug survives for eight time steps, at the end of the time step, it will spawn off a
new doodlebug in the same manner as the ant.
Starve: If a doodlebug has not eaten an ant within three time steps, at the end of the third time
step it will starve and die. The doodlebug should then be removed from the grid of cells.
Initialize the world with 5 doodlebugs and 100 ants. You will randomly place them. You should
see a cyclical pattern between the population of predators and prey, although random
perturbations may lead to the elimination of one or both species. You will prompt the user to
enter the number of time steps to run.
Create a class named Critter that contains data and functions common to ants and doodlebugs.
This class should have a virtual function named move that is defined in the derived classes of
Ant and Doodlebug. Each class will be in its own source file.
For each time step, do the following in your program: after moves, when breeding, eating, and
starving are resolved, display the resulting grid. Draw the world using ASCII characters of “O”
for an ant, “X” for a doodlebug and “E” for an empty space (the characters should be arranged to
look like a grid). The doodlebugs will move before the ants in each time step. When you reach
the time steps entered by the user, ask them to enter another number and start to run the
simulation again or to exit the program. You must maintain the state of the current grid while
creating the next display. You will use a dynamic array to represent the grid. Each array element

will be a pointer to a Critter. Get your program running and tested. For debugging your program,
you should save the random placement until you have everything else working properly. In
general, “random” is bad for testing and debugging.
Solution
World.java
import java.util.*;
import java.awt.*;
public class World{ private static Random r= new Random(); private int doodlebugs; private int
ants; private static final int SIZE = 20; private Critter[][] oGrid; World(int d,int a){ oGrid = new
Critter[SIZE][SIZE]; doodlebugs = d; ants = a; for(int i = 0; i < d; i++){ boolean isOccupied =
true; while(isOccupied){ int potX = r.nextInt(SIZE); int potY = r.nextInt(SIZE);
if(oGrid[potX][potY] == null) { isOccupied = false; oGrid[potX][potY] = new
Doodlebug(this,potX,potY); } } } for(int i = 0; i < a; i++){ boolean isOccupied = true;
while(isOccupied){ int potX = r.nextInt(SIZE); int potY = r.nextInt(SIZE); if(oGrid[potX][potY]
== null) { isOccupied = false; oGrid[potX][potY] = new Ant(this,potX,potY); } } } } public int
getdoodlebugs(){ return doodlebugs; } public int getants(){ return ants; } public char[][]
getCGrid(){ char[][] grid = new char[SIZE][SIZE]; for(int i = 0; i < SIZE; i++){ for(int j = 0;j <
SIZE; j++){ if(oGrid[j][i]!=null) if(oGrid[j][i].getClass().getName().equals("Ant")) Grid[j][i] =
'o'; else if(oGrid[j][i].getClass().getName().equals("Doodlebug")) grid[j][i] = 'x'; else
if(oGrid[j][i].getClass().getName().equals("Empty"))
grid[j][i] = 'e';
else
grid[j][i] = ' ';
}
}
return grid;
}
public void increasedoodlebugs(){
doodlebugs++;
}
public void decreasedoodlebugs(){
doodlebugs--;
}
public void increaseants(){

ants++;
}
public void decreaseants(){
ants--;
}
public void moveAll(){
for(int i = 0; i < SIZE; i++){
for(int j = 0;j < SIZE; j++){
if(oGrid[j][i] !=null)
oGrid[j][i].move();
}
}
if(oGrid[j][i] !=null)
oGrid[j][i].moved=false;
}
}
}
public void breedAll(){
if(oGrid[j][i]!=null)
oGrid[j][i].breed();
}
}
}
public void starveAll(){
if(oGrid[j][i]!=null)
oGrid[j][i].starve();
}
}
}
public boolean isEmpty(int x,int y){

boolean tbr = false;
if(oGrid[x][y]==null)
tbr = true;
return tbr;
}
public boolean isAnt(int x,int y){
boolean tbr = false;
if(oGrid[x][y] instanceof Ant)
tbr = true;
return tbr;
}
public void setCell(int x, int y, Critter O){
oGrid[x][y] = O;
}
}
Ant.java
import java.awt.*;
import java.io.*;
import java.util.*;
public class Ant extends Critter{
private static Random r = new Random();
private int untilBreed;
public Ant(World world,int _x, int _y){
super(world,_x, _y );
untilBreed = 3;
moved = false;//defaults to TRUE so that 'child' ants dont move
}
public void move(){
if(!moved){
int[] potMoves = new int[4];
int i = 1;
potMoves[0] = r.nextInt(4);
do{
do{
potMoves[i] = r.nextInt(4);
}

while(potMoves[i]!=potMoves[i-1]);
i++;
}
while(i<4);
i = 0;
boolean empty = false;
int oldx = x;
int oldy = y;
while(i<4 && !empty){
switch(potMoves[i]){
case 0:
if(x!=0){
if(world.isEmpty(x-1,y)){
empty = true;
world.setCell(x-1,y,this);
world.setCell(oldx,y,null);
moved = true;
untilBreed--;
x=x-1;
}
}
else if(world.isEmpty(19,y)){
empty = true; untilBreed--; world.setCell(19,y,this); world.setCell(oldx,y,null); moved = =19;
}
break;
case 1:
if(x!=19){
if(world.isEmpty(x+1,y)){
untilBreed--;
world.setCell(x+1,y,this);
moved = true;
empty = true;
x=x+1;
}
}

world.setCell(0,y,this);
moved = true;
empty = true;
x=0;
untilBreed--;
}
break;
case 2:
if(y!=0){
if(world.isEmpty(x,y-1)){
world.setCell(x,y-1,this);
world.setCell(x,oldy,null);
moved = true;
empty = true;
y=y-1;
untilBreed--;
}
}
else if(world.isEmpty(x,19)){
world.setCell(x,19,this);
moved = true;
empty = true;
y=19;
untilBreed--;
}
break;
case 3:
if(y!=19){
if(world.isEmpty(x,y+1)){
world.setCell(x,y+1,this);
moved = true;
empty = true;

y=y+1;
untilBreed--;
}
}
moved = true;
empty = true;
y=0;
untilBreed--;
}
break;
}
i++;
}
}
}
public void breed(){
if(untilBreed==0){
int i = 1;
do{
do{
}
i++;
}
while(i<4);
i = 0;
int oldx = x;
int oldy = y;

case 0:
if(x!=0){
world.setCell(x-1,y,new Ant(world, x-1,y));
untilBreed = 3;
empty = true;
}
}
world.setCell(19,y,new Ant(world, 19,y));
untilBreed = 3;
empty = true;
}
break;
case 1:
if(x!=19){
world.setCell(x+1,y,new Ant(world, x+1,y));
untilBreed=3;
empty = true;
}
}
world.setCell(0,y,new Ant(world, 0,y));
untilBreed=3;
empty = true;
}
break;
case 2:
if(y!=0){
world.setCell(x,y-1,new Ant(world, x,y-1));
untilBreed=3;
empty = true;

}
}
world.setCell(x,19,new Ant(world, x,19));
untilBreed=3;
empty = true;
}
break;
case 3:
if(y!=19){
world.setCell(x,y+1,new Ant(world, x,y+1));
untilBreed=3;
empty = true;
}
}
world.setCell(x,0,new Ant(world, x,0));
untilBreed=3;
empty = true;
}
break;
}
i++;
}
}
}
}
Grid.java
import javax.swing.*;
import java.awt.*;
public class Grid extends JPanel {
private int rows;
private int cols;
private JLabel[][] grid;
public Grid(int r, int c) {

rows = r;
cols = c;
grid = new JLabel[rows][cols];
setLayout (new GridLayout(rows, cols, 0, 0));
setBackground( new Color( 200,200,200 ) );
for (int i = 0; i < rows; i++ ) {
for (int j = 0; j < cols; j++ ) {
grid[i][j] = new JLabel();
grid[i][j].setBorder( BorderFactory.createLineBorder(Color.BLACK,1) );
grid[i][j].setFont( new Font("Courier", Font.BOLD, 12));
grid[i][j].setForeground(Color.WHITE);
grid[i][j].setHorizontalAlignment(SwingConstants.CENTER);
add( grid[i][j] );
}
}
setPreferredSize( new Dimension(500,500) );
}
public void setGrid(int i, int j, char value) {
if (value == '.')
value = ' ';
grid[i][j].setText( "" + value );
switch (value) {
case 'o':
grid[i][j].setBackground( Color.MAGENTA );
grid[i][j].setOpaque(true);
break;
case 'x':
grid[i][j].setBackground( Color.BLUE );
break;
case 'S':
grid[i][j].setBackground( Color.RED );
break;
default:
grid[i][j].setOpaque(false);

break;
}
}
}
DisplayFrame.Java
import javax.swing.*;
import java.util.*;
public class DisplayFrame extends JFrame {
private Grid grid;
public DisplayFrame(String title, int x, int y) {
setTitle( title );
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE );
grid = new Grid(y, x);
add( grid );
pack();
setVisible( true );
}
public void setGrid( char [][] data ) {
for (int i = 0; i < data.length; i++ ) {
for (int j = 0; j < data[i].length; j++ ) {
grid.setGrid( i, j, data[i][j] );
}
}
}
}
Prog.java
Import java.util.*;
import java.awt.*;
import java.io.*;
import java.lang.*;
public class Prog{
public static Scanner s = new Scanner(System.in);
public static void main(String[] args){
World world = new World(5,100);
DisplayFrame disp = new DisplayFrame("Pred/Prey", 20, 20 );
disp.setGrid( world.getCGrid() );

String input = "1";
int timesteps = 1;
boolean playing = true;
while(playing){
System.out.println("Options: [ENTER] Last timestep.");
System.out.println(" [Q] Quit Simulation.");
System.out.println(" [n] Enter another number.");
input = s.nextLine();
if(input.equals("Q")||input.equals("q")){
playing = false;
continue;
}
else if(input.equals("")){
timestep(timesteps,world);
}
else if(isNum(input)){
timesteps = Integer.parseInt(input);
timestep(timesteps,world);
}
else{
System.out.println("Try again!");
continue;
}
disp.setGrid( world.getCGrid() );
}
}
public static void timestep(int timesteps, World w){
for(int i = timesteps; i > 0; i--){
w.moveAll();
w.breedAll();
w.starveAll();
}
}
public static boolean isNum(String s){
try{
Integer.parseInt(s);

} catch(NumberFormatException nfe) {
return false;
}
return true;
}
}
Doodlebug.java
import java.awt.*;
import java.io.*;
import java.util.*;
public class Doodlebug extends Critter{
private static Random r = new Random();
private int untilBreed;
private int untilStarve;
public Doodlebug( World world,int _x, int _y){
super(world, _x, _y );
untilBreed = 8;
untilStarve = 3;
moved = true;
}
public void move(){
if(!moved){
int i = 1;
do{
do{
}
i++;
}
while(i<4);
i = 0;
int oldx = x;

int oldy = y;
case 0:
if(x!=0){
empty = true;
moved = true;
untilBreed--;
untilStarve--;
x=x-1;
}
}
empty = true;
untilBreed--;
untilStarve--;
moved = true;
x=19;
}
break;
case 1:
if(x!=19){
untilBreed--;
untilStarve--;
moved = true;
empty = true;
x=x+1;
}

}
moved = true;
empty = true;
x=0;
untilBreed--;
untilStarve--;
}
break;
case 2:
if(y!=0){
moved = true;
empty = true;
y=y-1;
untilBreed--;
untilStarve--;
}
}
moved = true;
empty = true;
y=19;
untilBreed--;
untilStarve--;
}
break;
case 3:
if(y!=19){

moved = true;
empty = true;
y=y+1;
untilBreed--;
untilStarve--;
}
}
moved = true;
empty = true;
y=0;
untilBreed--;
untilStarve--;
}
break;
}
i++;
}
i= 0;
case 0:
if(x!=0){
if(world.isAnt(x-1,y)){
empty = true;
moved = true;
untilBreed--;
untilStarve=3;
x=x-1;
}

}
else if(world.isAnt(19,y)){
empty = true;
untilBreed--;
untilStarve=3;
moved = true;
x=19;
}
break;
case 1:
if(x!=19){
if(world.isAnt(x+1,y)){
untilBreed--;
untilStarve=3;
moved = true;
empty = true;
x=x+1;
}
}
else if(world.isAnt(0,y)){
moved = true;
empty = true;
x=0;
untilBreed--;
untilStarve=3;
}
break;
case 2:
if(y!=0){
if(world.isAnt(x,y-1)){

moved = true;
empty = true;
y=y-1;
untilBreed--;
untilStarve=3;
}
}
else if(world.isAnt(x,19)){
moved = true;
empty = true;
y=19;
untilBreed--;
untilStarve=3;
}
break;
case 3:
if(y!=19){
if(world.isAnt(x,y+1)){
moved = true;
empty = true;
y=y+1;
untilBreed--;
untilStarve=3;
}
}
else if(world.isAnt(x,0)){
moved = true;

empty = true;
y=0;
untilBreed--;
untilStarve=3;
}
break;
}
i++;
}
}
}

you will use cellular automata to create a 2D predator–prey simulati.pdf

Recommended

Recommended

More Related Content

Similar to you will use cellular automata to create a 2D predator–prey simulati.pdf

Similar to you will use cellular automata to create a 2D predator–prey simulati.pdf (20)

More from FashionBoutiquedelhi

More from FashionBoutiquedelhi (20)

Recently uploaded

Recently uploaded (20)

you will use cellular automata to create a 2D predator–prey simulati.pdf