package sim.app.sugarscape;
   import sim.engine.*;
   import sim.field.grid.*;
   import sim.util.*;
   import ec.util.*;
   import java.io.*;

    public class SugarScape2 extends SimState
   {
   
      public double growthRate = 0.1;
      public double maxSugar = 4.0;
		public static final int maxVision = 4; 
      public double randomMovementProbability = 0.1;
   
      public int gridHeight;
      public int gridWidth;
      public int agentCount;
      Agent2[] agents;
    
       public double getGrowthRate() { 
         return growthRate; }
       public void setGrowthConstant( double temp ) { growthRate = temp; }
   
       public double getRandomMovementProbability() { 
         return randomMovementProbability; }
       public void setRandomMovementProbability( double t )
      {
         if (t >= 0 && t <= 1)
         {
            randomMovementProbability = t;
            for( int i = 0 ; i < agentCount ; i++ )
               if (agents[i]!=null)
                  agents[i].setRandomMovementProbability( randomMovementProbability );
         }
      }
       public Object domRandomMovementProbability() { 
         return new Interval(0.0, 1.0); }
		 public Object domMaximumSugar() {
		   return new Interval(0.0, 4.0); }
        
       public double getMaximumSugar() { 
         return maxSugar; }
		 public void setMaximumSugar(double val) {
		 if (val > 0) maxSugar = val; }
		 	
       public int getGridHeight() { 
         return gridHeight; }
       public void setGridHeight(int val) { 
         if (val > 0) gridHeight = val; }
       public int getGridWidth() { 
         return gridWidth; }
       public void setGridWidth(int val) { 
         if (val > 0) gridWidth = val; }
       public int getAgentCount() { 
         return agentCount; }
       public void setAgentCount(int val) { 
         if (val >= 0) agentCount = val; }
    
      public DoubleGrid2D valgrid;
      public SparseGrid2D agentgrid;
    
   
   
       public SugarScape2(long seed)
      {
         this(seed, 100, 100, 50);
      }
        
       public SugarScape2(long seed, int width, int height, int count)
      {
         super(new MersenneTwisterFast(seed), new Schedule(2));
         gridWidth = width; gridHeight = height; agentCount = count;
         createGrids();
      }
       public double[][] sugarfield()
      { 	
         double temp ;
         final double[][] sugarMax = new double[50][50];
         try{  
            FileReader fileReader = new FileReader("sim/app/sugarscape/sugarfield.txt");
            BufferedReader sugarfield = new BufferedReader(fileReader);
                 
            for(int x=0;x<50;x++)
            {
            
               String temp2 = new String();
               if((temp2 = sugarfield.readLine())!= null)
               {
                  StringReader temp3 = new StringReader(temp2);
                  for(int y=0;y<50;y++)
                  {
                     if((temp = 1.0*(temp3.read()))!=-1)
                        sugarMax[x][y] = temp-48;
                  }
               }
            }
         }
             catch(Exception e){
               e.printStackTrace();
            }
         return sugarMax;
      }
       protected void createGrids()
      {
         agents = new Agent2[agentCount];
         valgrid = new DoubleGrid2D(gridWidth, gridHeight,0);
         double[][] sugarfield = new double[50][50];
         sugarfield = sugarfield();
         for(int y =0; y<gridHeight; y++)
            for(int x=0; x<gridWidth; x++)
            {
               //System.out.print(""+(int)(sugarfield[(x/2)][(x/2)]-48));
               valgrid.set(x, y, sugarfield[(x/2)][(y/2)]);
            }
         //System.out.println();
         agentgrid = new SparseGrid2D(gridWidth, gridHeight);      
      }
    
    
       public void start()
      {
         super.start(); 
      
         createGrids();
      
         for(int x=0;x<agentCount;x++)
         {
            agents[x] = new Agent2(random.nextDouble() * (maxSugar),
                                  random.nextDouble(),
               						 random.nextInt(maxVision),
                                  randomMovementProbability);
            agentgrid.setObjectLocation(agents[x],random.nextInt(gridWidth),random.nextInt(gridHeight));
            schedule.scheduleRepeating(agents[x]);
         }
         schedule.scheduleRepeating(Schedule.EPOCH,1,new RuleG2(),1);
      }
    
       public static void main(String[] args)
      {
         doLoop(SugarScape2.class, args);
         System.exit(0);
      }    
   }