Thread: Langton's Ant. Can anybody complete it?

package langton;

public class LangtonAnt{

import simulation.Ant;
import simulation.Grid;
import simulation.Simulation;
import core.Direction;


/**
* Main method.
*
* You do not need to modify this method. It will not be part of the
* automated or hand marking
*
*/
public static void main(String[] args) {
// create a simulation with given parameters



Simulation sim = new Simulation(10, 10, 5, 5, Direction.NORTH, 10);
// while the simulation is not finished

while (!sim.isCompleted()) {
// get current board

Grid board = sim.cloneCurrentGrid();
// get current ant

Ant ant = sim.cloneCurrentAnt();

// print out the ant and board
System.out.print("+");
for (int j = 0; j < board.getWidth(); ++j) {
System.out.print("-");
}
System.out.println("+");

for (int i = 0; i < board.getHeight(); ++i) {
System.out.print("|");
for (int j = 0; j < board.getWidth(); ++j) {
if (i == ant.getIPos() && j == ant.getJPos()) {

switch (ant.getDirection()) {
case NORTH:
System.out.print("^");
break;
case SOUTH:
System.out.print("V");
break;
case EAST:
System.out.print(">");
break;
case WEST:
System.out.print("<");
break;
}
} else {
if (board.isWhite(i, j)) {
System.out.print(" ");
} else {
System.out.print("*");
}
}
}
System.out.println("|");
}

System.out.print("+");
for (int j = 0; j < board.getWidth(); ++j) {
System.out.print("-");
}
System.out.println("+");

/*
* make the computer wait 150 ms to make it easier to view the ant's
* progression
*/
try {
Thread.sleep(150);
} catch (InterruptedException e) {
// do nothing
}

// execute a step
sim.executeStep();
// buffer to make it easier to read
System.out.println();
}
}
}

}

package simulation;

/**
*
* Grid class
*
* @author _________
*
*/
public class Grid {

boolean[][] grid;

/**
* Constructor for the grid.
*
* Initial state is that the every cell in the grid is white
*
* @param height - height of the grid
* @param width - width of the grid
*/
public Grid(int height, int width) {
// TODO fill in this constructor
}

public int getHeight() {
// TODO fill in this method
}

public int getWidth() {
// TODO fill in this method

}

public boolean isWhite(int i, int j) {
// TODO fill in this method
}

protected void setWhite(int i, int j) {
// TODO fill in this method
}

protected void setBlack(int i, int j) {
// TODO fill in this method
}
}

package simulation;

/**
*
* Simulation class
*
* @author _________
*
*/
public class Simulation {

/**
* Initialize instance variables in this constructor
*
* @param height - the height of the grid
* @param width - the width of the grid
* @param antStartI - the original I coordinate of the ant
* @param antStartJ - the original J coordinate of the ant
* @param originalDirection - the original direction the ant is facing
*/
public Simulation(int height, int width, int antStartI, int antStartJ,
Direction originalDirection, int maxTimeSteps) {
// TODO fill in this constructor
}

/**
* Execute a time step for the simulation.
*
* The ant must:
* * move forward 1 space
* - if this movement would cause it to move off the grid,
* the simulation is completed.
* * rotate depending on the state of the cell the ant is occupying
* - if the cell is white, rotate left
* - otherwise, rotate right
* * change the state of the cell the ant is currently occupying
* - if the cell is white, it becomes black
* - otherwise, it becomes white
*
* NOTE: this method should do nothing if the simulation is completed.
*/
public void executeStep() {
// TODO fill in this method
}

/**
* Method to check if the simulation is completed.
*
* The simulation is completed if and only if:
* * it has reached the maximum time steps allowed
* * the ant has moved off the grid
*
* @return true - the simulation is completed
* @return false - the simulation is not completed
*/
public boolean isCompleted() {
// TODO fill in this method
}

/**
* Method to return a copy of the current grid.
*
* You should always return a copy of an object if you do not
* want your base object to be changed by any code calling this method.
*
* @return a clone of the grid.
*/
public Grid cloneCurrentGrid() {
// TODO fill in this method
}

/**
* Method to return a copy of the current ant.
*
* You should always return a copy of an object if you do not
* want your base object to be changed by any code calling this method.
*
* NOTE: Do not canche this value, return a new object for every call.
*
* @return a clone of the ant.
*/
public Ant cloneCurrentAnt() {
// TODO fill in this method
}
}

package core;

public enum Direction {
NORTH, SOUTH, EAST, WEST;
}

--- Update ---

package simulation;


/**
*
* Ant class
*
* @author _________
*
*/
public class Ant {

public Ant(int iPos, int jPos, Direction direction){
// TODO fill in this constructor
}

public int getIPos() {
// TODO fill in this method
}
protected void setIPos(int iPos) {
// TODO fill in this method
}
public int getJPos() {
// TODO fill in this method
}
protected void setJPos(int jPos) {
// TODO fill in this method
}
public Direction getDirection() {
// TODO fill in this method
}
protected void setDirection(Direction direction) {
// TODO fill in this method
}

}

here is the additional information


package core;

public enum Direction {
NORTH, SOUTH, EAST, WEST;
}

--- Update ---

package simulation;

/**
*
* Simulation class
*
* @author _________
*
*/
public class Simulation {

/**
* Initialize instance variables in this constructor
*
* @param height - the height of the grid
* @param width - the width of the grid
* @param antStartI - the original I coordinate of the ant
* @param antStartJ - the original J coordinate of the ant
* @param originalDirection - the original direction the ant is facing
*/
public Simulation(int height, int width, int antStartI, int antStartJ,
Direction originalDirection, int maxTimeSteps) {
// TODO fill in this constructor
}

/**
* Execute a time step for the simulation.
*
* The ant must:
* * move forward 1 space
* - if this movement would cause it to move off the grid,
* the simulation is completed.
* * rotate depending on the state of the cell the ant is occupying
* - if the cell is white, rotate left
* - otherwise, rotate right
* * change the state of the cell the ant is currently occupying
* - if the cell is white, it becomes black
* - otherwise, it becomes white
*
* NOTE: this method should do nothing if the simulation is completed.
*/
public void executeStep() {
// TODO fill in this method
}

/**
* Method to check if the simulation is completed.
*
* The simulation is completed if and only if:
* * it has reached the maximum time steps allowed
* * the ant has moved off the grid
*
* @return true - the simulation is completed
* @return false - the simulation is not completed
*/
public boolean isCompleted() {
// TODO fill in this method
}

/**
* Method to return a copy of the current grid.
*
* You should always return a copy of an object if you do not
* want your base object to be changed by any code calling this method.
*
* @return a clone of the grid.
*/
public Grid cloneCurrentGrid() {
// TODO fill in this method
}

/**
* Method to return a copy of the current ant.
*
* You should always return a copy of an object if you do not
* want your base object to be changed by any code calling this method.
*
* NOTE: Do not canche this value, return a new object for every call.
*
* @return a clone of the ant.
*/
public Ant cloneCurrentAnt() {
// TODO fill in this method
}
}

<package langton;
 
public class LangtonAnt{
 
import simulation.Ant;
import simulation.Grid;
import simulation.Simulation;
import core.Direction;
 
 
/**
* Main method.
*
* You do not need to modify this method. It will not be part of the
* automated or hand marking
*
*/
public static void main(String[] args) {
// create a simulation with given parameters
 
 
 
Simulation sim = new Simulation(10, 10, 5, 5, Direction.NORTH, 10);
// while the simulation is not finished
 
while (!sim.isCompleted()) {
// get current board
 
Grid board = sim.cloneCurrentGrid();
// get current ant
 
Ant ant = sim.cloneCurrentAnt();
 
// print out the ant and board
System.out.print("+");
for (int j = 0; j < board.getWidth(); ++j) {
System.out.print("-");
}
System.out.println("+");
 
for (int i = 0; i < board.getHeight(); ++i) {
System.out.print("|");
for (int j = 0; j < board.getWidth(); ++j) {
if (i == ant.getIPos() && j == ant.getJPos()) {
 
switch (ant.getDirection()) {
case NORTH:
System.out.print("^");
break;
case SOUTH:
System.out.print("V");
break;
case EAST:
System.out.print(">");
break;
case WEST:
System.out.print("<");
break;
}
} else {
if (board.isWhite(i, j)) {
System.out.print(" ");
} else {
System.out.print("*");
}
}
}
System.out.println("|");
}
 
System.out.print("+");
for (int j = 0; j < board.getWidth(); ++j) {
System.out.print("-");
}
System.out.println("+");
 
/*
* make the computer wait 150 ms to make it easier to view the ant's
* progression
*/
try {
Thread.sleep(150);
} catch (InterruptedException e) {
// do nothing
}
 
// execute a step
sim.executeStep();
// buffer to make it easier to read
System.out.println();
}
}
}
 
} >

--- Update ---

<package simulation;
 
/**
*
* Grid class
*
* @author _________
*
*/
public class Grid {
 
boolean[][] grid;
 
/**
* Constructor for the grid.
*
* Initial state is that the every cell in the grid is white
*
* @param height - height of the grid
* @param width - width of the grid
*/
public Grid(int height, int width) {
// TODO fill in this constructor
}
 
public int getHeight() {
// TODO fill in this method
}
 
public int getWidth() {
// TODO fill in this method
 
}
 
public boolean isWhite(int i, int j) {
// TODO fill in this method
}
 
protected void setWhite(int i, int j) {
// TODO fill in this method
}
 
protected void setBlack(int i, int j) {
// TODO fill in this method
}
} >

<package simulation;
 
/**
*
* Simulation class
*
* @author _________
*
*/
public class Simulation {
 
/**
* Initialize instance variables in this constructor
*
* @param height - the height of the grid
* @param width - the width of the grid
* @param antStartI - the original I coordinate of the ant
* @param antStartJ - the original J coordinate of the ant
* @param originalDirection - the original direction the ant is facing
*/
public Simulation(int height, int width, int antStartI, int antStartJ,
Direction originalDirection, int maxTimeSteps) {
// TODO fill in this constructor
}
 
/**
* Execute a time step for the simulation.
*
* The ant must:
* * move forward 1 space
* - if this movement would cause it to move off the grid,
* the simulation is completed.
* * rotate depending on the state of the cell the ant is occupying
* - if the cell is white, rotate left
* - otherwise, rotate right
* * change the state of the cell the ant is currently occupying
* - if the cell is white, it becomes black
* - otherwise, it becomes white
*
* NOTE: this method should do nothing if the simulation is completed.
*/
public void executeStep() {
// TODO fill in this method
}
 
/**
* Method to check if the simulation is completed.
*
* The simulation is completed if and only if:
* * it has reached the maximum time steps allowed
* * the ant has moved off the grid
*
* @return true - the simulation is completed
* @return false - the simulation is not completed
*/
public boolean isCompleted() {
// TODO fill in this method
}
 
/**
* Method to return a copy of the current grid.
*
* You should always return a copy of an object if you do not
* want your base object to be changed by any code calling this method.
*
* @return a clone of the grid.
*/
public Grid cloneCurrentGrid() {
// TODO fill in this method
}
 
/**
* Method to return a copy of the current ant.
*
* You should always return a copy of an object if you do not
* want your base object to be changed by any code calling this method.
*
* NOTE: Do not canche this value, return a new object for every call.
*
* @return a clone of the ant.
*/
public Ant cloneCurrentAnt() {
// TODO fill in this method
}
} >

Basically i have been given a template for the code that i need to complete, in the end it should out put this:

Description: Write a program to simulate an “ant” moving one step at a time on a grid of coloured cells, with rules to govern at each cell which direction to turn and what colour-change to make to the cell. The rules are:
1 At each cell, swap the colour from L to R or R to L;
2 If the new colour is L then turn left; else turn right;
3 Move forward one space
4 If you reach a boundary, exit the grid
and stop.

--- Update ---

sorry, im really new at this so im not sure how to format my code according to convention :S

<package langton;
 
public class LangtonAnt{
 
	import simulation.Ant;
	import simulation.Grid;
	import simulation.Simulation;
	import core.Direction;
 
 
		/**
		 * Main method.
		 * 
		 * You do not need to modify this method. It will not be part of the
		 * automated or hand marking
		 * 
		 */
		public static void main(String[] args) {
			// create a simulation with given parameters
 
 
 
			Simulation sim = new Simulation(10, 10, 5, 5, Direction.NORTH, 10);
			// while the simulation is not finished
 
			while (!sim.isCompleted()) {
				// get current board
 
				Grid board = sim.cloneCurrentGrid();
				// get current ant
 
				Ant ant = sim.cloneCurrentAnt();
 
				// print out the ant and board
				System.out.print("+");
				for (int j = 0; j < board.getWidth(); ++j) {
					System.out.print("-");
				}
				System.out.println("+");
 
				for (int i = 0; i < board.getHeight(); ++i) {
					System.out.print("|");
					for (int j = 0; j < board.getWidth(); ++j) {
						if (i == ant.getIPos() && j == ant.getJPos()) {
 
							switch (ant.getDirection()) {
							case NORTH:
								System.out.print("^");
								break;
							case SOUTH:
								System.out.print("V");
								break;
							case EAST:
								System.out.print(">");
								break;
							case WEST:
								System.out.print("<");
								break;
							}
						} else {
							if (board.isWhite(i, j)) {
								System.out.print(" ");
							} else {
								System.out.print("*");
							}
						}
					}
					System.out.println("|");
				}
 
				System.out.print("+");
				for (int j = 0; j < board.getWidth(); ++j) {
					System.out.print("-");
				}
				System.out.println("+");
 
				/*
				 * make the computer wait 150 ms to make it easier to view the ant's
				 * progression
				 */
				try {
					Thread.sleep(150);
				} catch (InterruptedException e) {
					// do nothing
				}
 
				// execute a step
				sim.executeStep();
				// buffer to make it easier to read
				System.out.println();
			}
		}
	}
 
}>

do you know how to write the section of code under : public void executeStep() ????

i have been trying that for about the last 4 hours, i really have no idea how to do it. I honest dont understand the logic a code follows. Can you PLEASE help????
Basically
Execute a time step for the simulation.
*
* The ant must:
* * move forward 1 space
* - if this movement would cause it to move off the grid,
* the simulation is completed.
* * rotate depending on the state of the cell the ant is occupying
* - if the cell is white, rotate left
* - otherwise, rotate right
* * change the state of the cell the ant is currently occupying
* - if the cell is white, it becomes black
* - otherwise, it becomes white
*
* NOTE: this method should do nothing if the simulation is completed.
*/

I know i have to do that but i dont know how to write it out so that i dont get any errors

--- Update ---

can you please provide an example as to what my code should look like?