class Agent
{

  Raster raster;    // Raster in dem der sich der Agent bewegt
  int number;       // Nummer des Agenten
  int direction;    // Richtung des Agenten
  int x;            // x-position Agent
  int y;            // y-position Agent
  int PosMx;        // x-position Matrix
  int PosMy;        // y-position Matrix
  int [][] mU;      // Array mit Information welche Matrizen angewendet werden
  
  ArrayList rulesList;  //Liste aller vorhandenen Matrizen


  // CONSTRUCTOR
  
  Agent(int nr, int x, int y, Raster raster)
  {
    this.raster = raster;
    setNumber(nr);
    setPosition(x, y);
    setRandomDirection();  //zufällige  Richtung beim erstellen eines Agenten
    //setDirection(UP);    //gewünschte Richtung beim erstellen eines Agenten
  }


  // METHODEN
  
  
  void checkAllMatrices()          
  {
    x= getX();
    y= getY();
    
     if (direction==RIGHT)                      //abchecken der Agentenrichtung und Ausrichtung der Matrix
       {
        int PosMx = x+1;
        int PosMy = y-1;
        setPositionMatrix(PosMx, PosMy);
       } else if (direction==LEFT)
         {
          int PosMx = x-3;
          int PosMy = y-1;
          setPositionMatrix(PosMx, PosMy);
         } else if (direction==UP)
           {
            int PosMx = x-1;
            int PosMy = y-3;
            setPositionMatrix(PosMx, PosMy);
            } else 
               {
                int PosMx = x-1;
                int PosMy = y+1;
                setPositionMatrix(PosMx, PosMy);
               } 
   
    for (int i=0; i<rulesList.size(); i++)              //durchgehen aller matrizen, die an rulesList übergeben wurden
    {
      Matrix matrix = (Matrix) rulesList.get(i);
      
      if ( matrix.matches( raster, PosMx, PosMy ) )     //Ausführen der Methode matrix.matches()
      {
                 
        if         (matrix.nameIs("rule"+mU[0][0])){
                   showMatchingMatrix(1, mU[0][0]);
    
                      showUsedMatrix (1, mU[0][1]);
               writeMatrix(PosMx, PosMy, mU[0][1]);
             
             
        }  else if (matrix.nameIs("rule"+mU[1][0])){
                   showMatchingMatrix(2, mU[1][0]);
    
                      showUsedMatrix (2, mU[1][1]);
               writeMatrix(PosMx, PosMy, mU[1][1]);     
             
             
        }  else if (matrix.nameIs("rule"+mU[2][0])){
                   showMatchingMatrix(3, mU[2][0]);
    
                      showUsedMatrix (3, mU[2][1]);
               writeMatrix(PosMx, PosMy, mU[2][1]); 
               
               
        }  else if (matrix.nameIs("rule"+mU[3][0])){
                   showMatchingMatrix(4, mU[3][0]);
    
                      showUsedMatrix (4, mU[3][1]);
               writeMatrix(PosMx, PosMy, mU[3][1]); 
        
        }  else if (matrix.nameIs("rule"+mU[4][0])){
                   showMatchingMatrix(5, mU[4][0]);
    
                      showUsedMatrix (5, mU[4][1]);
               writeMatrix(PosMx, PosMy, mU[4][1]); 
               
        }  else if (matrix.nameIs("rule"+mU[5][0])){
                   showMatchingMatrix(6, mU[5][0]);
    
                      showUsedMatrix (6, mU[5][1]);
               writeMatrix(PosMx, PosMy, mU[5][1]);        
        
        }  else if (matrix.nameIs("rule"+mU[6][0])){
                   showMatchingMatrix(7, mU[6][0]);
    
                      showUsedMatrix (7, mU[6][1]);
               writeMatrix(PosMx, PosMy, mU[6][1]); 
               
        }  else if (matrix.nameIs("rule"+mU[7][0])){
                   showMatchingMatrix(8, mU[7][0]);
    
                      showUsedMatrix (8, mU[7][1]);
               writeMatrix(PosMx, PosMy, mU[7][1]);        
               
        } 
      }
    }
   if (NOPRINTLN) println ("check finished"); 
}
  
  
/////////////////////////////////////////////////////////// 

    void writeMatrix(int x, int y, int i)
  {
    //raster.setCellMode(getX(), getY(), 1);
               
   Matrix matrix = (Matrix) rulesList.get(i);              
   matrix.writeMatrix( raster, x, y) ;   
   //println ("Matrix '" +matrix.getName()  +"' used!");
   //println (x);                       
  }
  

  void showMatchingMatrix(int i, int r)
  {
     int y = (i-1)*5;
     int x = 0;
     int w = 0;
     
     Matrix matrix = (Matrix) rulesList.get(r);              
     matrix.writeMatchingMatrix(rasterMatrizen, x, y, w) ; 
     fill(255);
     text(""+r , rasterMatrizen.getPositionX()-(1.5)*rasterMatrizen.getCellSize(), rasterMatrizen.getPositionY()+(y+1)*rasterMatrizen.getCellSize());
     
  }
  
  
  void showUsedMatrix(int i, int r)
  {
     int y = (i-1)*5;
     int x = 6;
     int w = 1;
      
     Matrix matrix = (Matrix) rulesList.get(r);              
     matrix.writeMatchingMatrix(rasterMatrizen, x, y, w) ;
     text(""+r , rasterMatrizen.getPositionX()+10*rasterMatrizen.getCellSize(), rasterMatrizen.getPositionY()+(y+1)*rasterMatrizen.getCellSize());
     
  }
///////////////////////////////////////////////////////////

  void move()  //Bewegen des Agenten
  {
      if (direction == LEFT)
      { 
        int mode = raster.getCell(getX()-1,getY()).getMode();  //Abfrage des Modus der nächsten Zelle
        if (mode!=-1)                                          //Falls Modus ungleich -1 (nirvana Zelle) -> innerhalb des Rasters
        {
          setPosition(getX()-1,getY());                        //Bewegung ein Feld vorwärts
        }
       else
       {
         invertDirection(direction);                           //Falls Modus = -1 (nirvana Zelle) -> ausserhalb des Rasters, umkehren
        } 
         
      }

      else if (direction == RIGHT)                            //analoges verfahren für andere drei Richtungen 
      {
        int mode = raster.getCell(getX()+1,getY()).getMode();
        if (mode!=-1)
        {
          setPosition(getX()+1,getY());
        }
        else
       {
         invertDirection(direction);
        } 
      }

      else if (direction == DOWN)
      {
        int mode = raster.getCell(getX(),getY()+1).getMode();
        if (mode!=-1)
        {
          setPosition(getX(),getY()+1);
        }
        else
       {
         invertDirection(direction);
        }
      }

      else  if (direction == UP)
      {
        int mode = raster.getCell(getX(),getY()-1).getMode();
        if (mode!=-1)
        {
          setPosition(getX(),getY()-1);
        }
        else
       {
         invertDirection(direction);
        }
      }
  }


  void invertDirection(int dir)
   {
     if (dir==LEFT)
       { setDirection(RIGHT);
     }else if (dir==RIGHT)
       { setDirection(LEFT);
     }else if (dir==UP)
       { setDirection(DOWN);
     }else 
       { setDirection(UP);
     }
   }


  void probabilityToChangeDirection(int p)
  {
    if ( random(100) < p)
      {
      setRandomDirection();
      }
  }


 void setRandomDirection()
  {
    int[] possibleDir= { LEFT, RIGHT, UP, DOWN };
    int index = floor( random(4) );
    direction = possibleDir[ index ];  
  }


  //SETTER
  
  void setMatrixList(ArrayList mL)
  {
    this.rulesList = mL;
  }
  
  
  void setMatricesInUse(int[][] mU)
  {
    this.mU = mU;
  }
  
  
  void setPosition(int x, int y)
  {
    this.x = x;
    this.y = y;
  }
  
  
  void setPositionMatrix(int PosMx, int PosMy)
  {
    this.PosMx = PosMx;
    this.PosMy = PosMy;
  }


  void setNumber(int number)
  {
    this.number = number;
  }


  void setDirection(int direction)
  {
    this.direction = direction;
  }


  //GETTER  

  int getNumber()
  {
    return number;
  }


  int getDirection()
  {
    return direction;
  }


  int getX()
  {
    return x;
  }


  int getY()
  {
    return y;
  }


}