// http://herselfsai.com


// Very simple demo of an ai that learns where the food is and whose children evolve with
// similar characteristics
// This ai has lines of food drawn on a grid and they learn and evolve to remain on the lines
//  and to follow the food lines
// 

import java.awt.*; 
import java.awt.event.*; 
import java.util.*;


//Main
public class Bugs extends Frame implements Runnable, WindowListener 
{ 

    int dim = 530;											// window size
	int max = 500;											// allow for title bars and margins
		
	
    Thread animThread;										// to continuously call repaint();
    long delay = 0L;										// speed up or slow down animation here ( 0-1000L )
	
	int days = 0;											// how many loops have we done so far
	
	int food[][] = new int[dim][dim];						// location of food
	
	int amount_of_bugs = max;								// bugs initial count
	ArrayList bugs = new ArrayList();						// data structure to store the bugs
	
	int energy_per_food = 1000;								// amount of energy per food unit starting value
	Random r = new Random ( System.currentTimeMillis() );	 // jump start random number generator
	
	int max_lifespan = 330;									// max days to live if don't breed or starve
	int energy_to_breed = 600;								// how many units of energy needed to divide and reproduce

	boolean world_created = false;							// don't start drawing loop till we get ourselves setup
	
    public static void main(String[] args) 
    { 
		new Bugs(); 
    } 
    
    
    //set up window, initial food and bugs and start animation
    public Bugs() 
    { 	
		//create a window ---------------------------------------------------------------
		super ( "  Bugs  " ); 
		setBounds ( 0, 0, dim, dim ); 
		setVisible ( true ); 
		addWindowListener ( this ); 
		animThread = new Thread ( this ); 
		animThread.start();

		
		// Create food supply for bugs to eat---------------------------------------------
		for ( int i=0; i<max; i++){
			for ( int j=0; j<max; j++){
				food[i][j] = 0;
			}
		}	


		// Create starting bugs -------------------------------------------------------
		for ( int i=0; i<amount_of_bugs; i++){
			bugs.add( new Bug( max, r, energy_per_food ));
		}
		
		
		// let animation loop know we are ready ----------------------------------------
		world_created = true;

    
	
    } 
    
    
    //***********************************************************************************************************
    //update here
    void updateBoard() 
    {
		if ( world_created ){		// get null pointers if remove this test...
		
			//initialize a few things for each loop
			int current_bug_count = bugs.size();
			
			// javac Bugs from a command line to see bugs/days elapsed/ energy value for food and energy needed to breed
			if ( days%100 == 0 ){
				System.out.println ( "Bugs: " + current_bug_count + "  Days: " + days + "   Energy per food: " + energy_per_food + "  Breeding energy: " + energy_to_breed );
			}
			
			days++;		// loop counter
			
			
			//replenish food supply **if you put this in a separate function it slows down program too much about a second per day!!!
			// try different setups and bugs should evolve in different ways
			for ( int i=0; i<max; i+=2){
				food[i][100] = 1;
				food[i][120] = 1;
				food[i][140] = 1;
				food[i][160] = 1;
				food[i][180] = 1;
			
				for ( int j=0; j<max; j+=2){
					food[400][j] = 1;
					food[420][j] = 1;
					food[440][j] = 1;
					food[460][j] = 1;
					food[480][j] = 1;
				
				}
			}
			// end replenish food supply
			

			//let's try stablizing the population by adjusting food's nutritional value and breeding energy
			//  This keeps population from dying off or over populating the place
			if (( current_bug_count < amount_of_bugs )&&( energy_per_food < 1000 )){ 
				energy_per_food *= 2;
				if ( energy_to_breed > 100 ) { energy_to_breed /=2; }
			}else if (( current_bug_count > amount_of_bugs * 2 )&&( energy_per_food > 10)){ 
				energy_per_food /= 2;
				if ( energy_to_breed < 100 ) { energy_to_breed *= 2; } 
			}  
			



			// for each bug
			for (  int i=0; i<current_bug_count; i++ ){
			
			
			// move bugs
				int move = r.nextInt(100);
				int direction = 0;
				Bug b = (Bug) bugs.get(i);
				int d = b.distance;
								
				//check gene array to see what direction this random number sends us into 
				while (( move > b.genes[direction] )&&(direction < 7)){
					direction++;
				}
				
		
				if ( direction == 0 ){	// lowest possible position
					if ( b.x > d ){ b.x -= d; }
					if ( b.y > d ){ b.y -= d; }
				}else if ( direction == 1 ){
					if ( b.y > d ) { b.y -= d; }
				}else if ( direction == 2 ){
					if ( b.x < (max-d) ) { b.x += d; }
					if ( b.y > d ) { b.y -= d; }
				}else if ( direction == 3 ){
					if ( b.x < (max-d) ) { b.x += d; }
				}else if ( direction == 4 ){
					if ( b.x < (max-d) ){ b.x += d; }
					if ( b.y < (max-d) ){ b.y += d; }
				}else if ( direction == 5 ){
					if ( b.y < (max-d) ){ b.y += d; }
				}else if ( direction == 6 ){
					if ( b.x > d ){ b.x -= d; }
					if ( b.y < (max-d) ){ b.y += d; }
				}else if ( direction == 7 ){ 
					if ( b.x > d ){ b.x -= d; }
				}else{}						// no move -- top is sometimes less than 100 makes for a lazy bug

		

		
			// eat if food available eat it and update energy
			// then increase the upper range or lower range of that particular direction
				b.energy -= (d); 				// remove 1 existing energy unit per move
				
				if ( food[b.x][b.y] == 1 ){		//found food 
					b.energy += energy_per_food;
					food[b.x][b.y] = 0;
					
					if( r.nextInt()%2 == 0 ){		// learn what works and adjust our genetics
						b.genes[direction]--;       //  yes gene values may overlap but no harm done
					} else {
						b.genes[direction]++;
					}
				}
			
			
			// update age 
				b.lifetime += 1;
				
			// die if energy == 0 or age > ?
				if (( b.energy <= 0 )||( b.lifetime > max_lifespan )){
					bugs.remove( i );
					current_bug_count--;
				}
				
			
			// have child by splitting into 2 and deleting original
				if ( b.energy >= energy_to_breed ) {
					bugs.add( new Bug( b, r ));
					bugs.add( new Bug( b, r ));
					current_bug_count += 1;
					bugs.remove( i );
				}
				
			
		}
		
		
		
		
		}// end if world created
		
    } 
    //***************************************************************************************************************
    

	
	
    //animation loop
    public synchronized void run() 
    { 
		while ( true ) {					//keep animating forever!!! 
			try { 
				updateBoard();				// calc location 
				repaint( 0L );				// request redraw 
				wait();						// wait for redraw 
				Thread.sleep( delay );		// after if happens, wait a bit
		
			} catch( Exception ex ) { System.err.println( "Error: " + ex ); } 
		} 
    } 



    public void update(Graphics g) { paint(g); } 
    
    
    
    //repaint the scene
    public synchronized void paint(Graphics g) 
    { 
		//draw background
		g.setColor( Color.white ); 
		g.fillRect( 0, 0, dim, dim ); 
	
		// if you don't mind slowing down simulation just adjust colors by lifetime or by generation to see the evolution
		Color background = new Color( 240, 240, 240 );
		Color food_color = new Color ( 0, 200, 0 );
		Color bug_color_10 = new Color ( 250, 0, 0 );
			
		//draw food on board ( allow for margin and title bar )
		for ( int i=0; i<dim; i++){
			for ( int j=0; j<dim; j++ ){
			
				if ( food[i][j] == 0 ){			// background
					g.setColor ( background ); 
					g.fillRect ( i+15, j+25, 1, 1 );
			
				}else if ( food[i][j] > 0 ) {		// food
					g.setColor ( food_color ); 
					g.fillRect ( i+15, j+25, 1, 1 ); 
					
				}
				
			}
		}

		// draw bugs
		int current_bug_count = bugs.size();
		g.setColor ( bug_color_10);
		for ( int i=0; i<current_bug_count; i++){
			Bug b = (Bug)bugs.get(i);
			g.fillRect( b.x+15, b.y+25, 2, 2 );
					
		}
	
		notifyAll(); 
    } 
    
    
    
    public void windowOpened( WindowEvent ev ) {} 
    public void windowActivated( WindowEvent ev ) {} 
    public void windowIconified( WindowEvent ev ) {} 
    public void windowDeiconified( WindowEvent ev ) {} 
    public void windowDeactivated( WindowEvent ev ) {} 
    public void windowClosed( WindowEvent ev ) {} 
    
    
    public void windowClosing(WindowEvent ev) 
    { 
		animThread = null; 
		setVisible(false); 
		dispose(); 
		System.exit(0); 
    } 

    
} 


class Bug
{
	
	int genes[] = new int[8];					// 8 possible directions to move
	int energy;									// one unit of energy allows us one move
	int lifetime;								// how old are we
	int	generation;								// what generation are we?
	int x, y;									// position on board
	double gene_calculation[] = new double[8];  // only used in initial calculation of genes
	int distance;
	
	// new bugs
	Bug( int max_position, Random r, int e  )
	{
		
		
			lifetime = 0;
			generation = 0;
			distance = r.nextInt(3) + 1;
			energy = e * distance * 4;

			//genes represent likely hood of moving in one of 8 directions ( nw/n/ne/e/se/s/sw/w )
			int sum = 0;
			
			//fetch random number between 1-100
			for ( int i=0; i<8; i++){
				gene_calculation[i] = r.nextInt(100);
				sum += gene_calculation[i];
			}
			
			//convert numbers to probablilities then convert probablilties to a number between 1-100
			for ( int i=0; i<8; i++){
				gene_calculation[i] = gene_calculation[i]/sum * 100;
				genes[i] = (int)(gene_calculation[i]);
			}
			
			
			// we are going to now convert numbers to total probabilities so we can pick a random number
			// between 1-100 and use that as our direction
			for ( int i=1; i<8; i++){
				genes[i] = genes[i] + genes[i-1];
			}
			
			x = r.nextInt( max_position );
			y = r.nextInt( max_position );
	
				
	}
	
	
	//baby bugs
	Bug ( Bug b, Random r )
	{
		energy = b.energy/3;
		lifetime = 0;
		generation = b.generation + 1;
		distance = b.distance;
		
		x = b.x;
		y = b.y;
		
		for ( int i=0; i<8; i++){
			genes[i] = b.genes[i];
		}
	
		// slightly increase one gene
		int gene_to_change = r.nextInt( 8 );
		genes[gene_to_change] += 2;
		if ( genes[gene_to_change] > 100 ){ genes[gene_to_change] = 100; }
		
		//slightly decrease one gene
		gene_to_change = r.nextInt(8);
		genes[gene_to_change] -= 2;
		if ( genes[gene_to_change] < 0 ){ genes[gene_to_change] = 0; }
		
		//slightly increase or decrease distance
		int distance_change = r.nextInt();
		if ( distance_change%2 == 0 ){
			if ( ( distance - distance_change ) > 0 ){ distance = distance - distance_change; }
			else { distance = 1; }
		}else{
			distance++;
		}
		
	
	}
		

}