/*					   
	Module: 	Ant2.java
	Author: 	F. Michael O'Brien (michael@obrienm.com)
	Version:	1.10.30
	Date:		30 Oct 2000
	Documents:	_projv[nnn].doc
	Notes:		
				written for the Sun JDK 1.2.2
	History:
	26 Oct 2000 - Class started, implemented by RouterAnimApplet
				to provide a Turing machine like independent entity that will
				route the circuit board in parallel with other Ant objects
	27 Oct 2000 - using behavior genome model, instead of direct state mapping
				of 64bit genotype into 18,446,744,073,709,551,616 states!
	30 Oct 2000 - V5: completed swarm enumeration and display, next ga calculation
	04 Nov 2000 - added selection, crossover code, behavior model additions

*/

import java.util.*;			
import java.awt.*;
//import java.applet.Applet;
/*
   Class:      Ant
   Structure:  ()
   SubClasses: -
   Inherits:   Object 
   Friends:    -
*/

//----------------------------------------------------------------
// Implements:		-
// Inherits:		-
// Implementors:	RouterAnimApplet
//----------------------------------------------------------------

class Ant3
{						  
	// simple behaviors within genotype
/*  with probabilities of 0-127 in the 4bit prob field
	0: end
	1: hold
	2: move
	3: Remove Trace
	4: switch
	5: turn
	6: Write Trace
*/
	// composite behaviors within genotype

/*
	askAdjacentAntToWaitOn(right, left, around, vertical)
askAdjacentAntToHaltOn(right, left, around, vertical)
askAdjacentAntToTurnOn(right, left, around, vertical)

moveWhileAdjacentIs(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
followCorridorUntil(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
followTraceFrom
interrogateAntOn(
haltWhenAdjacentTo(empty, Device, Trace, Ant)
haltWhenNextWillBe(empty, Device, Trace, Ant)
overwriteTraceWhen(empty, Trace, Ant, self)
turnFromNextCellContainingAlienTraceOn(right, left, around, vertical)
turnTowardsNextCellContainingAlienTraceOn(right, left, around, vertical)
waitFor(steps)
waitUntilProximityWith(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
waitUntilNoProximityWith(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
Requests:
willHonourRequests()
*/
//protected int		genotypeArray[];
protected boolean	genotypeBits[];
private static int	ndir[]={9,8,11,10,5,4,7,6};
//private static int	xdir[]={1,0,0,0,-1,0,0,0};
//private static int	ydir[]={0,0,-1,0,0,0,1,0};
//private static int	xdir[]={1,1,0,0,-1,-1,0,0};
//private static int	ydir[]={0,0,-1,-1,0,0,1,1};
private static int	xdir[]={1,0,-1,0};
private static int	ydir[]={0,-1,0,1};
private static int	toxdir[]={2,1};
private static int	toydir[]={1,3};

//dirGoal,dirTwin,distGoal,distTwin
// invariant constants
protected int			netId;
protected int			nodeId;	// array index within swarm
// previous state
protected int			pDirection;
protected boolean		pHold, pWrite, pRemove, pSwitchLayer, pEnd;
// current state
protected int			cDirection;
protected boolean		cHold, cWrite, cRemove, cSwitchLayer, cEnd;
			 
// next state
//protected int 			nDirection;
//protected boolean		nHold, nWrite, nRemove, nSwitchLayer, nEnd;

// sensory inputs (set by the implementing class)
// horizontal 8 way proximity grid (exluding center cell), for both layers
// direction:				values:
// 0-11 10du swne swne		0 = empty			4 = device
//      0123 4567 8901		1 = trace other		5 = Ant other
//    p 1098 7654 3210		2 = trace twin		6 = Ant twin
//                6745		3 = x				7 = x
protected int			proxBelow[];	
protected int			proxAbove[];
// nearest goal direction gradient
protected int			dirGoal;
// nearest twin direction gradient
protected int			dirTwin;
// nearest goal distance 16=(16->infinity)
protected int			distGoal;
// nearest twin distance 16=(16->infinity)
protected int			distTwin;
// layer (self, nearest twin, nearest goal)
protected int			layer;
protected int			posx, posy;	
// src and dest grid
protected int			srcx,srcy,destx,desty;
	
// constants
protected final int		behaviorBitLength=8;
protected final int		genotypeLength=behaviorBitLength*8;		

// behavior priorities
protected int			priorityVectorValue[];
protected int			priorityVectorIndex[];
protected int			currentPriorityIndex;
	
// proximity requests

// behavior
   
// new ants are initialized in the following state
public Ant3(int aNetId) {
	netId = 		aNetId;
	pDirection = 	0;
	pHold =			false;
	pWrite =		true;
	pRemove = 		false;
	pSwitchLayer = 	false;
	pEnd = 			false;

	cDirection =	(int)(Math.floor(Math.random()*4));
//	cDirection = 	0;
	cHold =			false;
	cWrite =		true;
	cRemove = 		false;
	cSwitchLayer = 	false;
	cEnd = 			false;

	proxBelow = new int[4];
	proxAbove = new int[4];
	// initialial environment is empty
	for(int i=0;i<4;i++) {
		proxBelow[i]=0;
		proxAbove[i]=0;
	}

	//genotypeArray[] = new int[genotypeLength];
	genotypeBits = new boolean[genotypeLength];

	// generate random genotype
	for(int i=0;i<genotypeLength;i++)
		if((int)Math.floor(Math.random()*1000)<500)
			genotypeBits[i]=true;
		else
			genotypeBits[i]=false;

	// compute priorities
	priorityVectorValue = new int[behaviorBitLength];
	priorityVectorIndex = new int[behaviorBitLength];

	// enumerate priorities
	sortPriorities();
}


// new ants are initialized in the following state
public Ant3(int anetId, int apDirection, boolean apHold,	boolean apWrite, boolean apRemove, boolean apSwitchLayer, boolean apEnd, int acDirection, boolean acHold, boolean acWrite, boolean acRemove, boolean acSwitchLayer, boolean acEnd) {
	netId = 		anetId;
	pDirection = 	apDirection;
	pHold =			apHold;
	pWrite =		apWrite;
	pRemove = 		apRemove;
	pSwitchLayer = 	apSwitchLayer;
	pEnd = 			apEnd;
	
	cDirection = 	acDirection;
	cHold =			acHold;
	cWrite =		acWrite;
	cRemove = 		acRemove;
	cSwitchLayer = 	acSwitchLayer;
	cEnd = 			acEnd;

	//genotype = new short[18446744073709551616];
	proxBelow = new int[4];
	proxAbove = new int[4];

	//genotypeArray[] = new int[genotypeLength];
	genotypeBits = new boolean[genotypeLength];

	for(int i=0;i<genotypeLength;i++) {
		//genotypeArray[i]=0;
		genotypeBits[i]=false;
	}
}


	// sensory inputs (set by the implementing class)
	// horizontal 8 way proximity grid (exluding center cell), for both layers
	// direction:				values:
	// 0-11 10du swne swne		0 = empty			4 = device
	//      0123 4567 8901		1 = trace other		5 = Ant other
	//    p 1098 7654 3210		2 = trace twin		6 = Ant twin
	//                6745		3 = cell src 		7 = cell dest

//private void activateBehavior_turnBlindly
//private void activateBehavior_askAdjacentAntToWaitOn(right, left, around, vertical)
//private void activateBehavior_askAdjacentAntToHaltOn(right, left, around, vertical)
//private void activateBehavior_askAdjacentAntToTurnOn(right, left, around, vertical)


private void activateBehavior_moveWhileAdjacentIs(int proxType) {
}
//private void activateBehavior_followCorridorUntil(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)

//interrogateAntOn(
private int activateBehavior_haltWhenAdjacentTo(int proxType) {
	if(proxType==7) {
		// check if adj cell is dest
		for(int d=0;d<4;d++) {
			if((posx+xdir[d]==destx)&&(posy+ydir[d]==desty)) {
				cEnd=true;
				return 1;
			}
		}		
	}
	return 0;
}
private int activateBehavior_haltWhenNextWillBe(int proxType) {
	if(proxType==7) {
		// check if next cell is dest
		if((posx+xdir[cDirection]==destx)&&(posy+ydir[cDirection]==desty)) {
			cEnd=true;
			return 1;
		} else {
			return 0;
		}
	}

	if((proxBelow[cDirection]==7)) {
		cEnd=true;
		return 1;
	} else {
		return 0;
	}
}

//private void activateBehavior_overwriteTraceWhen(empty, Trace, Ant, self)
private void activateBehavior_turnFromNextCellContainingAlienTraceOn(int dirTypeOffset, boolean dirVertOffset) {
}
//private void activateBehavior_turnTowardsNextCellContainingAlienTraceOn(int dirType, boolean dirVertOther) {
//}
//private void activateBehavior_turnFromNextCellContainingTwinTraceOn(int dirType, boolean dirVertOther) {
//}
//private void activateBehavior_turnTowardsNextCellContainingTwinTraceOn(int dirType, boolean dirVertOther) {
//}

// non sensory
//private void activateBehavior_waitFor(steps)
//private void activateBehavior_willHonourRequests()
//private void activateBehavior_waitUntilProximityWith(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
//private void activateBehavior_waitUntilNoProximityWith(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
  
private int activateBehavior_moveUntilAdjacentIsThenTurnOffset(int proxType, int dirTypeOffset, boolean dirVertOffset) {
	// check prox ahead
	if((proxBelow[cDirection]==proxType)||(proxBelow[cDirection]==1)||(proxBelow[cDirection]==4)||(proxBelow[cDirection]==5)||(proxBelow[cDirection]==6)) {
		// dont go through devices, alien ants, or twin ants
		// turn
		//activateBehavior_haltWhenAdjacentTo(7);
		cDirection=addOffsetToDirection(cDirection, dirTypeOffset);
		return 0;
	} else {

		//activateBehavior_haltWhenNextWillBe(7);
		//activateBehavior_haltWhenAdjacentTo(7);
			//

		// check if occupied
		// move ahead
		posx+=xdir[cDirection];
		posy+=ydir[cDirection];
		// moved? so recompute for all ants
		return 1;
	} 
}

private int activateBehavior_moveUntilAdjacentIsThenTurnTo(int proxType, int dir, boolean dirVertOffset) {
	// check prox ahead
	if((proxBelow[cDirection]==proxType)||(proxBelow[cDirection]==1)||(proxBelow[cDirection]==4)||(proxBelow[cDirection]==5)||(proxBelow[cDirection]==6)) {
		// dont go through devices, alien ants, or twin ants
		// turn
		//activateBehavior_haltWhenAdjacentTo(7);
		cDirection=dir;//addOffsetToDirection(cDirection, dirTypeOffset);
		return 0;
	} else {
		// check if occupied,else move ahead
		posx+=xdir[cDirection];
		posy+=ydir[cDirection];
		// moved? so recompute for all ants
		return 1;
	} 
}
 

// computeNextState
public int computeNextState() {
	int antsMoved=0;
	// save current state to previous state
	pDirection = 	cDirection;
	pHold =			cHold;
	pWrite =		cWrite;
	pRemove = 		cRemove;
	pSwitchLayer = 	cSwitchLayer;
	pEnd = 		cEnd;
	// compute next state using the Ant genotype
	// get 64bit state vector as an integer
	long lvNextState=0;
	long lvMult=1;
	int				offset,dirToDest;

	// genotype bit schema
	// 0: [0....6][7]  end
	// 1: [8...14][15] hold
	// 2: [16..22][23] move
	// 3: [24..30][31] switch
	// 4: [32..38][39] remove trace
	// 5: [40..46][47] turn
	// 6: [48..54][55] write trace
	// 7: [56..62][63] x

	// sensory inputs (set by the implementing class)
	// horizontal 8 way proximity grid (exluding center cell), for both layers
	// direction:				values:
	// 0-11 10du swne swne		0 = empty			4 = device
	//      0123 4567 8901		1 = trace other		5 = Ant other
	//    p 1098 7654 3210		2 = trace twin		6 = Ant twin
	//                6745		3 = x				7 = x


/*	private static int	xdir[]={1,1,0,0,-1,-1,0,0};
	private static int	ydir[]={0,0,-1,-1,0,0,1,1};
*/	
	// 0: end
	//cEnd = 		false;
	// 1: hold

	// 2: move : activateBehavior_moveUntilAdjacentIsThenTurn(int proxType, int dirTypeOffset, boolean dirVertOffest) {) {
	//if(1>(int)Math.floor(Math.random()*convertBitsToInt(genotypeBits[1],genotypeBits[2],genotypeBits[3],genotypeBits[4],genotypeBits[5],genotypeBits[6],genotypeBits[7]))) {
	activateBehavior_haltWhenAdjacentTo(7);

	// escape if halted
	if(cEnd)
		return 0;

	if((int)(Math.floor(Math.random()*100+.5))>50) {
	//if(genotypeBits[2*8]) {
		//dirToDest=computeDirectionToDestination();
		offset=1-((int)(Math.floor(Math.random()*2+.5)));
		antsMoved+=activateBehavior_moveUntilAdjacentIsThenTurnOffset(4,offset, false);
		//antsMoved+=activateBehavior_moveUntilAdjacentIsThenTurnTo(4,dirToDest, false);	
			// when device turn right, dont switch layers,
	} else {
	//if(genotypeBits[3*8]) {
		dirToDest=computeDirectionToDestination();
		//offset=1-((int)(Math.floor(Math.random()*2+.5)));
		//antsMoved+=activateBehavior_moveUntilAdjacentIsThenTurnOffset(4,offset, false);
		antsMoved+=activateBehavior_moveUntilAdjacentIsThenTurnTo(4,dirToDest, false);	
			// when device turn right, dont switch layers,
	}


		// 3: switch layer

		// 4: remove trace
		cRemove = 		false;
		// 5: turn
		// compute probability from genotype
		
		// 6: write trace
		cWrite =		true;
		
		//System.out.println("_ComputeNextState: posx=" + (new Integer(posx)).toString() + ",posy=" + (new Integer(posy)).toString());
		//}
		return antsMoved;
}	        

private int computeDirectionToDestination() {
	int ddir,dx,dy;
	dx=destx-posx; dy=desty-posy;
	if(Math.abs(dx)<Math.abs(dy)) {
		// go in the y dir
		if(dy<0)
			return 1;
		else
			return 3;
	} else {
		// go in the x dir
		if(dx<0)
			return 2;
		else
			return 0;
	}
}

private int addOffsetToDirection(int dir, int offset) {
	int newDir=dir+offset;
	if(newDir<0)
		return newDir+4;
	else
		if(newDir>3)
			return newDir-4;
		else
			return newDir;
}


// perform a bubble-sort on the priority list
private void sortPriorities() {
	boolean unsorted=true;
	boolean paired=true;
	int i,j,p,t1;
	int behavior1, behavior2;
	int priority;

//	System.out.println("\n_Ant["+ (new Integer(netId)).toString() + "]:Behavior Priorities["+ (new Integer(behaviorBitLength)).toString() + "] before sorting");
	// display unsorted behaviors
	for(i=0;i<behaviorBitLength;i++) {
		priority=convertBitsToInt(genotypeBits[i*behaviorBitLength+1],
			genotypeBits[i*behaviorBitLength+2],
			genotypeBits[i*behaviorBitLength+3],
			genotypeBits[i*behaviorBitLength+4],
			genotypeBits[i*behaviorBitLength+5],
			genotypeBits[i*behaviorBitLength+6],
			genotypeBits[i*behaviorBitLength+7]);
		//System.out.println((new Integer(i)).toString() + ":" + (new Integer(convertBitsToInt(genotypeBits[i*8],false,false,false,false,false,false))).toString() + " " + (new Integer(priority)).toString());
//		System.out.print((new Integer(convertBitsToInt(genotypeBits[i*8],false,false,false,false,false,false))).toString() + ":" + (new Integer(priority)).toString() + "\t");
	}
//	System.out.println();

	// first find lowest priority and fill the array, to account for non-existent behaviors
	int highestBehavior=2 << (behaviorBitLength-1);
	int highestBehaviorIndex=0;
	int currentBehavior;//=256;
	for(i=0;i<behaviorBitLength;i++) {
		if(genotypeBits[i*behaviorBitLength]) {
			currentBehavior=convertBitsToInt(genotypeBits[i*behaviorBitLength+1],
			genotypeBits[i*behaviorBitLength+2],
			genotypeBits[i*behaviorBitLength+3],
			genotypeBits[i*behaviorBitLength+4],
			genotypeBits[i*behaviorBitLength+5],
			genotypeBits[i*behaviorBitLength+6],
			genotypeBits[i*behaviorBitLength+7]);
			if(currentBehavior < highestBehavior) {
				highestBehavior = currentBehavior;
				highestBehaviorIndex = i;
			}
		}
	}

	// prefill the array with the highest priority ie: 32103333
	for(i=0;i<behaviorBitLength;i++) {
		priorityVectorValue[i]=highestBehavior;
		priorityVectorIndex[i]=highestBehaviorIndex;
	}
	// then fill beginning with all active behaviors
	j=0;
	for(i=0;i<behaviorBitLength;i++) {
		if(genotypeBits[i*behaviorBitLength]) {
			priorityVectorIndex[j]=i;
			priorityVectorValue[j]=convertBitsToInt(genotypeBits[i*behaviorBitLength+1],
			genotypeBits[i*behaviorBitLength+2],
			genotypeBits[i*behaviorBitLength+3],
			genotypeBits[i*behaviorBitLength+4],
			genotypeBits[i*behaviorBitLength+5],
			genotypeBits[i*behaviorBitLength+6],
			genotypeBits[i*behaviorBitLength+7]);
			// increment dest vector index
			j++;
		}
	}
	//System.out.println("J:" + (new Integer(j)).toString());

//	System.out.println("_priorityVectorIndex["+ (new Integer(behaviorBitLength)).toString() + "] before sorting");
	// display unsorted behaviors
//	for(i=0;i<behaviorBitLength;i++)
//		System.out.print((new Integer(priorityVectorIndex[i])).toString()+ ":" + (new Integer(priorityVectorValue[i])).toString()+ "\t");
//	System.out.println();

	// perform sort
	unsorted=true;
	while(unsorted)	{
		unsorted=false;
		for(i=0;i<behaviorBitLength-1;i++) {
			//unsorted=false;
			behavior1=priorityVectorValue[i];
			behavior2=priorityVectorValue[i+1];
			//behavior2=convertBitsToInt(genotypeBits[p*8+1],genotypeBits[p*8+2],genotypeBits[p*8+3],genotypeBits[p*8+4],genotypeBits[p*8+5],genotypeBits[p*8+6],genotypeBits[p*8+7]); 
			if(behavior1<behavior2) {
				//System.out.println((new Integer(i)).toString() + "-" + (new Integer(i+1)).toString());
				unsorted=true;					
				priorityVectorValue[i]=behavior2;
				priorityVectorValue[i+1]=behavior1;
				t1=priorityVectorIndex[i];
				priorityVectorIndex[i]=priorityVectorIndex[i+1];
				priorityVectorIndex[i+1]=t1;
				i=0;
			}
		}
	}

//	System.out.println("_priorityVectorIndex["+ (new Integer(behaviorBitLength)).toString() + "] after sorting");
	// display unsorted behaviors
//	for(i=0;i<behaviorBitLength;i++)
//		System.out.print((new Integer(priorityVectorIndex[i])).toString()+ ":" + (new Integer(priorityVectorValue[i])).toString()+ "\t");
//	System.out.println();
}


// get/set methods
// sensory inputs (set by the implementing class)
// horizontal 8 way proximity grid (exluding center cell), for both layers
// direction:				values:
// 0-11 10du swne swne		0 = empty			4 = device
//      0123 4567 8901		1 = trace other		5 = Ant other
//    p 1098 7654 3210		2 = trace twin		6 = Ant twin
//                6745		3 = 				7 = 
public void setGenotypeBits(boolean[] anArray) { genotypeBits = anArray; }
//public void setGenotypeArray(int[] anArray) { genotypeArray = anArray; }
//public void setProxBelow(int[] anArray) { proxBelow = anArray; }
public void setProxBelow(int d0,int d1,int d2,int d3) { //,int d4,int d5,int d6,int d7) { 
	proxBelow[0]=d0;	proxBelow[1]=d1;	proxBelow[2]=d2;	proxBelow[3]=d3; 
	//proxBelow[4]=d4;	proxBelow[5]=d5;	proxBelow[6]=d6;	proxBelow[7]=d7; 
}
public void setProxAbove(int[] anArray) { proxAbove = anArray; }
// nearest goal direction gradient
public void setDirGoal(int anInput) { dirGoal = anInput; }
// nearest twin direction gradient
public void setDirTwin(int anInput) { dirTwin = anInput; }
// nearest goal distance 16=(16->infinity)
public void setDistGoal(int anInput) { distGoal = anInput; }
// nearest twin distance 16=(16->infinity)
public void setDistTwin(int anInput) { distTwin = anInput; }
// layer (self, nearest twin, nearest goal)
public void setLayer(int anInput) {	layer = anInput; }
public void setPosx(int anInput) { posx = anInput; }
public void setPosy(int anInput) { posy = anInput; }
public void setNetId(int anInput) { netId = anInput; }
public void setNodeId(int anInput) { nodeId = anInput; }
public void setSrcx(int anInput) { srcx = anInput; }
public void setSrcy(int anInput) { srcy = anInput; }
public void setDestx(int anInput) { destx = anInput; }
public void setDesty(int anInput) { desty = anInput; }

// get state info
public boolean[] getGenotypeBits() { return genotypeBits; }
//public int[] getGenotypeArray() { return genotypeArray; }
public int getProxBelow(int pos) { return proxBelow[pos]; }
public int getpDirection() { return pDirection; }
public boolean getpHold() { return pHold; }
public boolean getpWrite() { return pWrite; }
public boolean getpRemove() { return pRemove; }
public boolean getpSwitchLayer() { return pSwitchLayer; }
public boolean getpEnd() { return pEnd; }
public int getcDirection() { return cDirection; }
public boolean getcHold() { return cHold; }
public boolean getcWrite() { return cWrite; }
public boolean getcRemove() { return cRemove; }
public boolean getcSwitchLayer() { return cSwitchLayer; }
public boolean getcEnd() { return cEnd; }
//public int getnDirection() { return nDirection; }
//public boolean getnHold() { return nHold; }
//public boolean getnWrite() { return nWrite; }
//public boolean getnRemove() { return nRemove; }
//public boolean getnSwitchLayer() { return nSwitchLayer; }
//public boolean getnEnd() { return nEnd; }
public int getNetId() { return netId; }
public int getLayer() { return layer; }
public int getPosx() { return posx; }
public int getPosy() { return posy; }
public int getNodeId() { return nodeId; }
public int getSrcx() { return srcx; }
public int getSrcy() { return srcy; }
public int getDestx() { return destx; }
public int getDesty() { return desty; }

public void decodeGenotypeBits(){
// 0: end
// 1: hold
// 2: move
// 3: remove trace
// 4: switch
// 5: turn
// 6: write	trace
}

public void encodeGenotypeBits(){
}

private int convertBitsToInt(boolean b0, boolean b1, boolean b2, boolean b3,boolean b4, boolean b5, boolean b6) {
	int total=0;
	if(b0)	total+=1;
	if(b1)	total+=2;
	if(b2)	total+=4;
	if(b3)	total+=8;
	if(b4)	total+=16;
	if(b5)	total+=32;
	if(b6)	total+=64;
	return total;
}

public static void main(String args[]) {
		Ant3 a = new Ant3(0);
		int x;
//		for(int i=1;i<=10;i++) {
//			x=(int)Math.floor(Math.random()*100)+1;
//			a.insert(x);
//		}
}

/*
askAdjacentAntToWaitOn(right, left, around, vertical)
askAdjacentAntToHaltOn(right, left, around, vertical)
askAdjacentAntToTurnOn(right, left, around, vertical)

moveWhileAdjacentIs(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
followCorridorUntil(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
//interrogateAntOn(
haltWhenAdjacentTo(empty, Device, Trace, Ant)
haltWhenNextWillBe(empty, Device, Trace, Ant)
overwriteTraceWhen(empty, Trace, Ant, self)
turnFromNextCellContainingAlienTraceOn(right, left, around, vertical)
turnTowardsNextCellContainingAlienTraceOn(right, left, around, vertical)
waitFor(steps)
waitUntilProximityWith(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
waitUntilNoProximityWith(empty, Device, Trace, Ant) on (right, left, prev, next, up | down)
willHonourRequests()
*/
/*		
		ivNextState=ivNextState+=pDirection*lvMult; lvMult*=8;
		if(pHold) ivNextState=ivNextState+=pHold*lvMult; lvMult*=2;
		if(pWrite) ivNextState=ivNextState+=pWrite*lvMult; lvMult*=2;
		if(pRemove) ivNextState=ivNextState+=pRemove*lvMult; lvMult*=2;
		if(pSwitchLayer) ivNextState=ivNextState+=pSwitchLayer*lvMult; lvMult*=2;
		if(pEnd) ivNextState=ivNextState+=pEnd*lvMult; lvMult*=2;
		ivNextState=ivNextState+=cDirection*lvMult; lvMult*=8;
		if(cHold) ivNextState=ivNextState+=pHold*lvMult; lvMult*=2;
		if(cWrite) ivNextState=ivNextState+=pcWrite*lvMult; lvMult*=2;
		if(cRemove) ivNextState=ivNextState+=pRemove*lvMult; lvMult*=2;
		if(cSwitchLayer) ivNextState=ivNextState+=pSwitchLayer*lvMult; lvMult*=2;
		if(cEnd) ivNextState=ivNextState+=pEnd*lvMult; lvMult*=2;
		ivNextState=ivNextState+=proxBelow[0]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxBelow[1]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxBelow[2]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxBelow[3]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxBelow[4]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxBelow[5]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxBelow[6]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxBelow[7]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxAbove[0]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxAbove[1]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxAbove[2]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxAbove[3]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxAbove[4]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxAbove[5]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxAbove[6]*lvMult; lvMult*=8;
		ivNextState=ivNextState+=proxAbove[7]*lvMult; //lvMult*=8;
		// 2^64 = 18,446,744,073,709,551,616
		// pass 
		cDirection = 	genotype[ivNextState] & 7;
		cHold =			(genotype[ivNextState] & 8) >> 3;
		cWrite =		(genotype[ivNextState] & 16) >> 4;
		cRemove = 		(genotype[ivNextState] & 32) >> 5;
		cSwitchLayer = 	(genotype[ivNextState] & 64) >> 6;
		cEnd = 		(genotype[ivNextState] & 128) >> 7;
*/

}