/* implementation of Culture Model in Java
   Richard Ian Taylor
   MSc EASy (Full time)
   Artificial Life Project
   Autumn 98
   Tutor: Greg Werner */

import java.util.*;
import java.lang.*;
import java.io.*;

class Agent{
    /* set the control constants of the class Agent */
    static final int geneMax = 5;        // number of features in a culture
    static final int alleleMax = 10;     // number of alternative traits per feature
    
    int feature [] = new int[geneMax];
    Vector neighbours = new Vector();
    
    Agent(){
	for( int i=0; i<geneMax; i++)
	    feature[i] =(int) Math.floor(Math.random()*alleleMax);
    }
 
    public void WriteAgentCulture(PrintWriter output) throws IOException{
	for(int i=0; i<geneMax; i++)
	    output.print(feature[i]);
    }

    public boolean TestforInteraction(Agent eventNeighbour){
	boolean match = false;
	/* select a feature between 1 and geneMax to test for match */
	int testfeature = (int) Math.floor(Math.random()*geneMax);
	/* if they match, return true, otherwise return false */
	if(feature[testfeature]==eventNeighbour.feature[testfeature])
	    match = true;
	return match;
    }

    public void Interact(Agent eventNeighbour){
	
	int tryfeature = (int) Math.floor(Math.random()*geneMax);
	int count = 0;
	boolean  same = true;
	
	while( same == true && count < geneMax){
	    /* if the traits are not the same then we can change this trait in the 
	       active agent and exit the loop. Otherwise try the next feature in the 
	       genome until all have been tried */
	    if(eventNeighbour.feature[tryfeature] != feature[tryfeature]){
		feature[tryfeature] = eventNeighbour.feature[tryfeature];
		same = false;
	    }
	    else{
		count++;
		tryfeature++;
	    }
	    if(tryfeature == geneMax)tryfeature=0;
	}
    }
	
    /* This method prints the culture of the agent to the screen */
    public void PrintAgentCulture(){
	for(int i=0; i<geneMax; i++)
	    System.out.print(feature[i]);
    }

    /* print the culture of agents neigbours to the screen */
    public void PrintNeighboursCulture(){
	for(int i=0; i<neighbours.size(); i++){
	    Agent currentNeighbour = (Agent) neighbours.elementAt(i);
	    currentNeighbour.PrintAgentCulture();
	    System.out.print(" ");
	}
    }

    /* select an agent from the neighbours vector at random */
    public Agent SelectNeighbour(){
	/* index of the randomly selected neighbour agent */ 
	int number  = (int) Math.floor(Math.random()*neighbours.size());
	return (Agent) neighbours.elementAt(number);
    }
}

class CultureModel{
    /* version number of this program. Future versions should add more features to the model.
       possible extensions are discussed in the documentation */ 
    static final int version = 1;       

    /* set the control constants of the CultureModel class */
    static final int xMax = 10;          // size of territory
    static final int yMax = 10;
    static final int cycleMax = 10000;     // number of cycles in each reporting period
    static final int periodMax = 10;     // number of periods of cycleMax events
    static final long seed = 0;          // seed for pseudo random number generator

    /* name of the file to which the results are printed */
    static String filename = new String("CultureModel.data");

    /* append to the file on every call to WriteCulture or overwrite */
    static boolean append = true;
	
    static final Agent[][] agent = new Agent[xMax][yMax];

    public static void main(String [] args) throws IOException{
	int period=0;
	int cycle=0;

	/* initialise territory */
	for(int i=0; i<xMax; i++){
	    for(int j=0; j<yMax; j++)
		agent[i][j] = new Agent();
	}
	/* have four neighbours with no territory wrap for this run. There are many other 
	   possibilities, each of which can be written as a method of CultureModel. */
	FourNeighbours();

	/* print initial set of cultures to screen */
	ReportCulture();

	/* label the output file before writing to it with initial random cultures */
	LabelOutput();
	WriteCulture(0, 0);

	/* print sets of neigbours of first two rows to screen to test */
	//ReportNeighboursCulture(2, yMax);

	for(period=0; period<periodMax; period++){
	    for(cycle=0; cycle<cycleMax; cycle++){
		/* select active agent */
		Agent activeAgent = SelectAgent();
		/* select neighbour of active agent at random */
		Agent eventNeighbour = activeAgent.SelectNeighbour();
		/* select a feature at random and test for match. Method returns a boolean*/
		boolean match = activeAgent.TestforInteraction(eventNeighbour);
		/* if true then have them interact */
		if(match==true)activeAgent.Interact(eventNeighbour);
	    }
	   
	    /* display the set of cultures after every cycleMax events */
	    ReportCulture();
	    WriteCulture(period +1, cycle);
	}

    }

    /* construct a vector array of neighbours. Agents on the edge of the
       territory will have only three neighbours. Agents at the corners
       only two. */
    public static void FourNeighbours(){
       for(int i=0; i<xMax; i++){
	   for(int j=0; j<yMax; j++){
	       if(i!= 0)agent[i][j].neighbours.addElement(agent[i-1][j]);
	       if(i!= xMax-1)agent[i][j].neighbours.addElement(agent[i+1][j]);
	       if(j!= 0)agent[i][j].neighbours.addElement(agent[i][j-1]);
	       if(j!= yMax-1)agent[i][j].neighbours.addElement(agent[i][j+1]);
	   }
       }
    }
    
    /* method selects active agent at random and returns this agent */
    public static Agent SelectAgent(){
	int x = (int) Math.floor(Math.random()*xMax);
	int y = (int) Math.floor(Math.random()*yMax);
	return agent[x][y];
    }

    /* print set of neighbours cultures for first nRows by  nCols agents */
    public static void ReportNeighboursCulture(int nRows, int nCols){
	for(int i=0; i<nRows; i++){
	    for(int j=0; j<nCols; j++){
		agent[i][j].PrintNeighboursCulture();
		System.out.println();
	    }
	}
    }

    /* print complete set of cultures over the territory */
    public static void ReportCulture(){
	for(int i=0; i<xMax; i++){
	    for(int j=0; j<yMax; j++){
		agent[i][j].PrintAgentCulture();
		System.out.print(" ");
	    }
	    System.out.println();
	}
	System.out.println();
    }

    /* this method labels output to the file */
    public static void LabelOutput() throws IOException{
	FileWriter outputFile = new FileWriter(filename, append);
	PrintWriter output = new PrintWriter(outputFile);

    	output.println("Culture Model Version " + version);
	output.println("Parameters for this run of the Culture Model:");
	output.println("Random seed for this run   : " + seed);
	output.println("Size of territory          : " + xMax + " X " + yMax);
	output.println("No. of features per culture: " + Agent.geneMax);
	output.println("No. of traits per feature  : " + Agent.alleleMax);

	outputFile.close();
    }

    /* prints the entire culture to the file labeled with the number of events */
    public static void WriteCulture(int period, int cycle) throws IOException{
	FileWriter outputFile = new FileWriter(filename, append);
	PrintWriter output = new PrintWriter(outputFile);

	output.println("Number of events so far    : " + cycleMax * period);
System.out.println("search");
	for(int i=0; i<xMax; i++){
	    for(int j=0; j<yMax; j++){
		agent[i][j].WriteAgentCulture(output);
		output.print(" ");
	    }
	    output.println();
	}
	output.println();
	outputFile.close();
    }
}