class Vogel
{
  //properties
  int number; //birds name or number
  int feldX; //current feld colum
  int feldY; //current feld row
  float posX; 
  float posY;
  float dirAngle;  //direction in degree
  float speed;     // speed
  color farbe;
  int vogelSize; //strokeWeight
  boolean closeToDebugBird;
  
  //contructor
  Vogel(int n)
  {
    setNumber(n);
    setPosition( random(width), random(height) );
    setFeld();
    setDirection( random(360) );
    setSpeed(random(1,3));
    setColor(200);
    vogelSize=3;
  }
  Vogel(int numb, float minSpeed, float maxSpeed, int birdSize, color c)
  {
    setNumber(numb);
    setPosition( random(width), random(height) );
    setFeld();
    setDirection( random(360) );
    setSpeed(random(minSpeed,maxSpeed));
    setColor(c);
    vogelSize=birdSize;
  }
    
  
  //methods
  void setNumber(int n)
  {
    number = n;
  }
  int getNumber()
  {
    return number;
  }
  boolean getCloseToDebugBird()
  {
    return closeToDebugBird;
  }
  void setCloseToDebugBird(boolean b)
  {
    closeToDebugBird = b;
  }
  void setVogelSize(int s)
  {
    vogelSize = s;
  }
  void setColor(color f)
  {
    farbe = f;
  }
  color getColor()
  {
    return farbe;
  }
  
  void setFeld()
  {
    feldX = floor (colums *getPositionX() /width);
    feldY = floor (  rows *getPositionY() /height);
  }
  int getFeldX()
  {
    return feldX;
  }
  int getFeldY()
  {
    return feldY;
  }
  void setPosition(float x, float y)
  {
    posX = x;
    posY = y;
  }
  float getPositionX()
  {
    return posX;
  }
  float getPositionY()
  {
    return posY;
  }
  void setDirection(float angle)
  {
    dirAngle = angle;
  }
  float getDirection()
  {
    return dirAngle;
  }
  void setSpeed(float s)
  {
    speed = s;
  }
  float getSpeed()
  {
    return speed;
  }
  
  void drawVogel()
  {
    stroke(getColor());
    strokeWeight(vogelSize);
    point( getPositionX(), getPositionY() );
  }
  
  int[] getClosestNeighbours() //return an int array of all birds in the neighbourhood (numbers)
  {
    int myX = getFeldX();
    int myY = getFeldY();
    int minX = myX -1;
    int maxX = myX +1;
    int minY = myY -1;
    int maxY = myY +1;  
    int[] tempListe = new int[0];
    
    if (minX<0) minX = 0;
    if (maxX>colums-1) maxX = colums-1;
    if (minY<0) minY = 0;
    if (maxY>rows-1) maxY = rows-1;
    for (int i=minX; i<=maxX; i++)
    {
      for (int k=minY; k<=maxY; k++)
      {
        tempListe = concat(tempListe, feld[i][k].getVogelliste());
      }
    }
    
    return tempListe;
  }
  void adaptDirection(int[] neighbours)
  {

    float[][] distList = new float[neighbours.length][2];  //collection list of neigbours and their distance

    float myX = getPositionX();
    float myY = getPositionY();

    for (int i=0; i<neighbours.length; i++)
    {
      float thisX = vogel[neighbours[i]].getPositionX();
      float thisY = vogel[neighbours[i]].getPositionY();
      distList[i][0] = pow(thisX -myX, 2) + pow(thisY -myY, 2); //Abstand Quadrat
      distList[i][1] = neighbours[i];                           //vogelNummer
    }
    arrayQuickSort(distList, 0, distList.length -1); //sortiert das array auf der erstem dimension
    int laufweite = 3; //number of intresting neighbours, others are ignored
    if (laufweite > distList.length) laufweite = distList.length;
    float avDirAngle = 0;
    float avSpeed = 0;
    for (int i=0; i<laufweite; i++)
    {
      int vNum = (int)distList[i][1];
//      if (vNum==1) println("Vogel1 Direction: " +vogel[vNum].getDirection() + "  nachbarn: " +laufweite);
      avDirAngle += vogel[vNum].getDirection();
      avSpeed += vogel[vNum].getSpeed();
    }
    avDirAngle = (avDirAngle /laufweite+360) % 360;
    avSpeed = avSpeed /laufweite;
    setDirection(getDirection() + (avDirAngle -getDirection()) *dirAdap);
    setSpeed(getSpeed() + (avSpeed -getSpeed() ) *speedAdap) ;
  }
  
  void arrayQuickSort(float[][] a, //dim#1 ist liste, dim#2 0:dist, 1:vogelNo
                      int unten, int oben)
  {
    int i = unten;
    int j = oben;
    int mitte = (unten + oben) /2; //position des pivot elements
    float x = a[mitte][0]; //pivot element
    do
    {
      while (a[i][0] < x) i++; //springe vor, bis element grösser als pivot
      while (a[j][0] > x) j--; //springr zurück, bis element kleiner als pivot
      if (i<=j) 
      {
        float tmp=a[i][0]; a[i][0]=a[j][0]; a[j][0]=tmp; //tausche element i gegebn j
              tmp=a[i][1]; a[i][1]=a[j][1]; a[j][1]=tmp; //tausche element i gegebn j
        i++;
        j--;
      }
    } while (i<=j);
    if (unten < j) arrayQuickSort(a, unten, j); //rekursiv 'unterer' rest
    if (i < oben) arrayQuickSort(a, i, oben); //rekursiv 'oberer' rest
  }

  void fly()
  {
    float rad = radians(getDirection());
    float x = getPositionX() +sin(rad) * getSpeed();
    float y = getPositionY() +cos(rad) * getSpeed();
    x = (x+width) % (float)width;
    y = (y+height) % (float) height;
    setPosition(x, y);
  }
}