Print

Print


Here is the code for controller and model.

package sim.algs.alg2;
/*
This is the primary simulation with reproduction of each agent by a single child.
age is to determine death and survival.
Need to introduce Death, survival probability and colour change due to age.
/*

Copyright 2006 by Sean Luke and George Mason University
Licensed under the Academic Free License version 3.0
See the file "LICENSE" for more information
*/

import ec.util.MersenneTwisterFast;
//import sim.alg1.Agent;
import sim.engine.Schedule;
import sim.engine.Sequence;
import sim.engine.SimState;
import sim.engine.Steppable;
import sim.field.grid.ObjectGrid2D;
import sim.util.Bag;

import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Comparator;

public class SimEnviro2  extends SimState {

    private static final long serialVersionUID = 1L;
    private ObjectGrid2D mySpace;
    public static final int gridWidth = 5;
    public static final int gridHeight = 6;    
    private Bag agents;
    private int initNumberOfAgents = 1;

    public SimEnviro2(long seed) {
        super(new MersenneTwisterFast(seed), new Schedule());
    }

    public void start() {
        super.start();
        buildModel();
        buildSchedule();
    }
    public void buildModel() {
        mySpace = new ObjectGrid2D(gridWidth, gridHeight);
        agents = new Bag();
        for (int i=0; i<initNumberOfAgents; i++) {
            agents.add(new Agent2(this));
        }
    }

    public void buildSchedule() {
        // build a sequence that makes all the agents
        // replicate
        Sequence agentReplicateSeq = new Sequence(agents) {
            public void step(SimState state) {
                super.step(state);
                for (int i=0; i<steps.length; i++)
                    ((Agent2)steps[i]).replicate(state);
            }
        };
        schedule.scheduleRepeating(0,0,agentReplicateSeq);
        // build a sequence that makes all the agents
        // steps is the instance variable in a Sequence
        //  that stores the Steppable objects

    }
    
    public int getgridWidth() {
    	return gridWidth;
    }
    
    public int getgridHeight() {
    	return gridHeight;
    }
    public ObjectGrid2D getMySpace() {
        return mySpace;
    }

    public  int getInitNumberOfAgents(){
        return initNumberOfAgents;
    }

    public void setInitNumberOfAgents(int initNumberOfAgents) {
        this.initNumberOfAgents = initNumberOfAgents;
    }

    public Bag getAgents() {
        return agents;
    }
}

--------------------------------------------------------------------------------------------
package sim.algs.alg2;

import sim.engine.SimState;
import sim.engine.Steppable;
import sim.field.grid.Grid2D;
import sim.field.grid.ObjectGrid2D;
import sim.util.Bag;
import sim.util.IntBag;
import ec.util.*;

/**
 * Created by Your PC on 14/05/2015.
 * Revised 15/03/2018
 */
public class Agent2 implements Steppable {
	
	private static final long serialVersionUID = 1L;
	public MersenneTwisterFast random;
	private static final int Width = SimEnviro2.gridWidth;
	private static final int Height = SimEnviro2.gridHeight;

    private int myX, myY, nextX, nextY;
    private double age;
    private int counter = 1;

    // This constructor for offspring
    public Agent2(){
        age = 0.0;
    }

    public Agent2(SimEnviro2 theModel) {
        placeFirstAgent(theModel);
        age = 1.0;
    }

    public void placeFirstAgent(SimEnviro2 theModel) {
        ObjectGrid2D mySpace = theModel.getMySpace();

        // 2 options either direct placement.
        do {
            myX = 0;
            myY = 0;
        }

		// or randomly place agent into grid
/*		do {
			myX = theModel.random.nextInt(Width);
			myY = theModel.random.nextInt(Height);
		}
*/		
        while (mySpace.field[myX][myY] != null);
        mySpace.field[myX][myY] = this;
    }
    
    public void finish() {
    	
	}

    public void step(SimState state) {
        // this would make an agent move and grow, then the
        // next agent move and replicate...  not what we want
/*		move();
		replicate();  */
    }
    // Don't need this method as there is not a requirement
    // of random movement except for the first placement.
    // each subsequent placement is from the von Neumann neighbours
    // found by the built-in method.

    public void replicate(SimState state) {
        SimEnviro2 theModel = (SimEnviro2) state;
        Bag theAgents = theModel.getAgents();

        ObjectGrid2D mySpace = theModel.getMySpace();
//        int newX, newY;
        
        int hop = 8;
        Bag result = new Bag();
        IntBag xNeighbors = new IntBag();
        IntBag yNeighbors = new IntBag();

//   		mySpace.getVonNeumannNeighbors(myX, myY, hop, Grid2D.BOUNDED, false, null, xNeighbors, yNeighbors);
   		mySpace.getVonNeumannNeighbors(myX, myY, hop, Grid2D.BOUNDED, false, result, xNeighbors, yNeighbors);
   		
        int len = xNeighbors.size();
        int loc = result.size();
/*        
        int j;
        for ( j = 0; j < len-3; j++) {
        	System.out.println(" Bag size " + len);}
        	
        /*            System.out.print(" x = " + xNeighbors.get(j));
            System.out.println(" : y = " + yNeighbors.get(j));
        
*//*   		
   		System.out.print(" myX = " + myX);
        System.out.println(" : myY = " + myY);
 */  		
        for (int i=0; i<len; i++) {
            Agent2 child = new Agent2();
            int total = ( Width * Height );
            	if (len == loc) {
            		state.finish();
            	}
                nextX = mySpace.tx(xNeighbors.get(i));
                nextY = mySpace.tx(yNeighbors.get(i));
                if (mySpace.field[nextX][nextY]== null) {
  //              	System.out.print(" nextX = " + nextX);
  //              	System.out.println(" : NextY = " + nextY);
                	System.out.println(" : counter = " + counter);
                    mySpace.field[nextX][nextY] = child;
                    child.myX = nextX;
                    child.myY = nextY;
                    theAgents.add(child);
                    
//                    System.out.println("Final :" + ((total - counter) - 1));
                    
                    counter++;
                    break;
                }
        } 
        
        myX = nextX; myY = nextY;
        if ( counter  == ( Width * Height )) {  
        	state.finish();
        }
    }
}