//Michael Chang
//Motion
//my brain works in angles not PIs
float mx = 00;                  //Controlling Variable
float mx2=0;                     //inverse of controlling variable
cell[] subject;                  //list of all cells
float sinwave=0;
int wrapBuffer=50;               //determines how far out the world is which we can't see
int numCells=25;                //default number of cells
float ambientEnergy=18000;        //the life force which all cells recieve
void setup()
{
  size(600,600);
  cursor(CROSS);
  numCells=int(random(15,45));
  generateCells(numCells);
// noSmooth();
  smooth();
  //  framerate(10);
  background(0);

}
void loop()
{
  translate(0,0,-250);
//  background(0);
  mx2=width-mx;
//  drawBG();
  colorMode(RGB,255,255,255);
  updateCells(numCells);
  sinwave+=0.01;
  ambientEnergy+=(10*(width-mx2/width))+0;                //regenerate ambience every turn
  ambientEnergy=constrain(ambientEnergy,0,1000); 
//--------------------------------Display marker for mx
/*  colorMode(RGB,255,255,255);
  float dif = mouseX - mx;
  if(abs(dif) > 1.0) {
    mx = mx + dif/8.0;
  }
  mx = constrain(mx, 1, width-1);
  noStroke();
  fill(255);
  rect(0, height-5, width, 5);
  // Draw bottom positional marker
  fill(204, 102, 0);
  rect(mx-2, height-5, 4, 5);*/
  //--------------------------------End display code
/*  if(mousePressed)
  {
    g.depthTest=false;
    noStroke();
    fill(0,5);
    rect(0,0,width,height);   
  }*/
}

void mouseReleased()
{
  setup();
}
void mousePressed()
{
 
}
//drawBG draws a gradient as the background
void drawBG()
{
  colorMode(HSB,width,height,height);
  for(int y=height;y>0;y--)
  {
    stroke(240-(mx2/1.2),(y/3)+(mx2/4),(y)-50+(width-(mx2*1.5)));//(y+80)-(mx/1.1)
    line(0,400-y,width,400-y);
  }
}
//generate cells generates cells up to num inside subject[] list
void generateCells(int num)
{
  subject=new cell[num];
  for(int i=0;i<num;i++)
  {
    subject[i]=new cell(i,(width/2)+random(-20,20),(height/2)+random(-20,20));
  }
}
//update cells updates all cells up to num
void updateCells(int num)
{
  for(int i=0;i<num;i++)
  {
    if(subject[i].health>0)
    {
      subject[i].update();
      subject[i].draw();
    }
    else
    {
      subject[i].alive=false;
    }
  }
}
//normalizes any angle between 0 and 360
float normalizeHeading(float ang)
{
  while(ang >= 360)ang -= 360;
  while(ang <= 0)ang += 360;
  return ang;
}
//gets the absolute angle between two points relative to the first
float getHeading(position p1,position p2)
{
  float angle=atan2(p2.y-p1.y,p2.x-p1.x);
  angle=-1*angle*180/PI;
  if(p2.y>=p1.y)
  angle=360-(angle*-1);
  return angle;
}
//gets the absolute angle between two points relative to the first
float getHeading(float x1,float y1,float x2,float y2)
{
  float angle=atan2(y2-y1,x2-x1);
  angle=-1*angle*180/PI;
  if(y2>=y1)
  angle=360-(angle*-1);
  return angle;
}
//position class used to quickly define coordinates in 2d space X and Y
class position
{
  float x,y;
position(){}
  position(float tx,float ty)
  {
    x=(tx);
    y=(ty);
  }
  position(position p)
  {
    x=p.x;
    y=p.y;
  }
  //displace() quickly gives a displacement of a position by any angle and magnitude
  position displace(float angle,float magnitude)
  {
    position newP=new position(x,y);
    newP.x+=(cos(radians(angle))*magnitude);
    newP.y-=(sin(radians(angle))*magnitude);
    return newP;
  }
  void set(float tx,float ty)
  {
    x=(tx);
    y=(ty);
  }
}
//cell class that defines every cellular organism
class cell
{
  int id;                                //id number given to each cell
  float health;                          //health value of every cell to determine its life
  int neighbors;                         //number of immediate neighbors a cell has
  boolean alive;                         //boolean to see if a cell is alive or dead
  boolean selected;                      //boolean to see if a cell is selected
  position location;                     //cell's current location
  position selectionCenter;              //cell's visible center of position
  int componentAmount;                   //the number of components the cell has
  int selectionSize;                     //the average area taken up by a cell, expressed as a radius
  float angle;                           //current bearing of the cell
  float heading;                         //current heading of the cell
  float speed;                           //current speed of the cell
  float desiredSpeed;                    //speed at which the cell will try to obtain
  float accel;                           //cell's rate of acceleration
  float colSize;                         //size used to determine collision detection
  component[] subcomponents;             //list of all components in a cell
  //constructors
  cell()
  {
    id=0;
    defaultVal();
    setupComponents();
  }
  cell(int i,position loc)
  {
    id=i;
    location=new position(loc);
    defaultVal();
    setupComponents();
  }
  cell(int i,float x,float y)
  {
    id=i;
    location=new position(x,y);
    defaultVal();
    setupComponents();
  }
  //default values of all cells are given in defaultVal()
  void defaultVal()
  {
    health=int(random(30));
    neighbors=0;
    if(random(100)>20) 
      alive=true;
    else
      alive=false;
    //    componentAmount=int(random(15,15));    
    componentAmount=int(random(5,7));
    angle=random(0,360);
    //    heading=random(0,360);
    heading=angle+random(-80,80);
    speed=random(0,4);
    selected=false;
    selectionCenter=new position(location);
    desiredSpeed=4;
    accel=.01;
  }
  //setupComponents() builds list of components for the cell to use
  void setupComponents()
  {
    //float ang=random(0,360/componentAmount);
    float ang=360/componentAmount;
    float totalAng=0;
    subcomponents=new component[componentAmount];
    for(int i=0;i<componentAmount;i++)
    {
      subcomponents[i]=new component(location,totalAng+ang);
      totalAng+=ang;
      //ang+=random(0,360/componentAmount);
    }
  }
  //update() for every cell is run every iteration
  void update()
  {
    //    angle=normalizeHeading(angle);
    //    heading=normalizeHeading(heading);
    updateComponents();
    collision();
    absorb();    
    setSpeed();        
    move();
    turn();
//    wrapAround();
//    selection();
    reproduce();
    eat();
    setHealth();    
  }
  //absorb() determines how well a cell can absorb ambient energy
  void absorb()
  {
    if(random(100)>80)
      if(ambientEnergy>0)
      {
        ambientEnergy-=2+(.05*neighbors);
        health+=2+(3*neighbors);    
      }
  }
  //eat() is supposed to determine if a cell will eat another cell for energy instead
  void eat(){}
  //reproduce() determines when and how a cell reproduces itself. Cells make copies of themselves.
  void reproduce()
  {
    if(random(100)>(98+(2*mx/width)))
    {
      boolean emptyFound=false;
      if(health>110)
      {
        int c=0;
        for(int i=0;i<numCells;i++)
        {
          if(subject[i].alive==false)
          {
            emptyFound=true;
            c=i;          
            break;
          }
        }
        if(emptyFound)
        {
//        subject[c]=new cell(c,location.x+random(-15,15),location.y+random(-15,15));
          subject[c].alive=true;
          subject[c].health=random(50,80);
          subject[c].location.x=location.x+random(-15,15);
          subject[c].location.y=location.y+random(-15,15);        
          health-=80;
        }
      }
    }
  }
  //setHealth() updates the healt of a cell
  void setHealth()
  {
    health-=.2+(mx2/width)*4.0;
    if(random(1000)>999)
      health-=100;    
    health=constrain(health,0,120);
  }
  //setSpeed() updates the speed of a cell
  void setSpeed()
  {
    desiredSpeed=(mx2/20)+2;
    if(accel<.1)
      accel+=.005;
    //    float speedMod=angle;
    if(speed<desiredSpeed)
    speed+=accel;
    speed=constrain(speed,0,desiredSpeed);
  }
  //move() will attempt to move a cell into a desired location
  void move()
  {
    location=location.displace(angle,speed);
  }
  //turn() will attempt to rotate a cell to its desired heading
  void turn()
  {
    //    float a=angle;
    //    float h=heading;
    //    if(abs(h-a)>180)
    //    {
      //      a+=abs(a-h)/25;
      //      angle=a;
    //    }
    //    a+=(h-a)/25;
    //    angle=a;
    if(random(100)<(5+(5*(width-mx2)/width)))
      heading+=random(-20-(50*mx2/width),20+(50*mx2/width));
    angle+=(heading-angle)/22;
    //    heading+=.5;

    /*    if(abs(heading-angle)==180)
    {
      angle+=1;
    }
    else
    if(abs(heading-angle)<180)
    {
      angle-=1;
    }
    else
    if(abs(heading-angle)>180)
    {
      angle+=1;
    }    */
    /*
    float a=angle;
    float b=heading;
    if(a>b)
    {
      float temp=b;
      b=a;
      a=temp;
    }
    float dirA=abs(b-a);
    float dirB=abs(360-b+a);
    if(abs(a-b)>1)
    {
      if(dirA>dirB)
      angle-=1;
      else
      if(dirA<dirB)
      angle+=1;

    }
    */
  }
  //updateComponents() updates all components in a cell
  void updateComponents()
  {
    int avgX=0;
    int avgY=0;
    selectionSize=0;
    for(int i=0;i<componentAmount;i++)
    {
      subcomponents[i].update(health,location,angle,speed,colSize);
      avgX+=subcomponents[i].location.x;
      avgY+=subcomponents[i].location.y;
      //      if(selectionSize<subcomponents[i].getLength())
      selectionSize+=int(subcomponents[i].getLength());
    }
    avgX=avgX/componentAmount;
    avgY=avgY/componentAmount;
    selectionCenter.x=avgX;
    selectionCenter.y=avgY;
    selectionSize=selectionSize/componentAmount;
  }
  //wrapAround() forces any cell off the world border to be teleported to the opposite side using a buffer
  void wrapAround()
  {
    if(location.x>width+wrapBuffer)
    {
      location.x=0-wrapBuffer;
    }
    if(location.x<0-wrapBuffer)
    {
      location.x=width+wrapBuffer;
    }
    if(location.y>height+wrapBuffer)
    {
      location.y=0-wrapBuffer;
    }
    if(location.y<0-wrapBuffer)
    {
      location.y=height+wrapBuffer;
    }
  }
  //collision() will determine collisions for a cell, count its neighbors, deccelerate a cell, and displace a cell if nessecary
  void collision()
  {
    neighbors=0;
    colSize=health/10;
    for(int i=0;i<subject.length;i++)
    {
      if(id!=i&&subject[i].alive)
      {
        if(dist(location.x,location.y,subject[i].location.x,subject[i].location.y)<(120))
        {
          //          stroke(255);
          //          line(location.x,location.y,subject[i].location.x,subject[i].location.y);
          for(int s=0;s<componentAmount;s++)
          {
            subcomponents[s].collision(i,angle,speed);
          }
          neighbors++;

          //          if(abs(heading-getHeading(location,subject[i].location))<180)
          //          {
            //            heading=getHeading(location,subject[i].location);
          //          }
          //          angle+=random(-5,5);
          if(dist(location.x,location.y,subject[i].location.x,subject[i].location.y)<(colSize*2))
          {
            location=location.displace(getHeading(location.x,location.y,subject[i].location.x,subject[i].location.y),-1-1*(mx2/300)*(speed/2+1));
            speed-=.05+(1*(mx2/width));
            accel=0;
          }
        }
      }
    }
  }
  //selection() will highlight a cell if it is under the mouse, and will display information if it is enabled
  void selection()
  {
    if(dist(mouseX,mouseY,location.x,location.y)<selectionSize)
    {
      selected=true;
    }
    else
    selected=false;
  }
  //draw() draws the cell's body and any displaying data, as well as all its components
  void draw()
  {
    noStroke();
    fill(50);
    ellipseMode(CENTER_DIAMETER);
    ellipse(location.x,location.y,4,4);
    stroke(0);
    noFill();
    ellipse(location.x,location.y,speed*5*(health/100),speed*5*(health/100));
    drawSubcomponents();
    drawCreatureCurve();
    //    drawMotionVector();
    if(selected)
    drawSelection();
  }
  //drawSubcomponents() draws the cell's subcomponents, called by draw()
  void drawSubcomponents()
  {
    for(int i=0;i<componentAmount;i++)
    {
      subcomponents[i].draw();
    }
  }
  //drawCreatureCurve() draws the cell's outline
  void drawCreatureCurve()
  {
    stroke(180*mx2/width,health/100,health/100,health);
//    noStroke();
//    fill(180,180,50);
    beginShape(POLYGON); 
    curveVertex(subcomponents[0].location.x,subcomponents[0].location.y);
    for(int i=0;i<componentAmount;i++)
    {
      curveVertex(subcomponents[i].location.x,subcomponents[i].location.y);
    }
//    stroke(255,50,50);
    curveVertex(subcomponents[0].location.x,subcomponents[0].location.y);
    curveVertex(subcomponents[1].location.x,subcomponents[1].location.y);
    endShape();
  }
  //drawMotionVector() is used for debugging and will draw the angle and magnitude of heading and bearing vectors
  void drawMotionVector()
  {
    position h=location.displace(heading,desiredSpeed*4);
    position a=location.displace(angle,speed*4);
    //    fill(0);
    //    ellipse(a.x,a.y,3,3);
    stroke(0,0,255,10);
    line(location.x,location.y,h.x,h.y);
    stroke(255,0,0,10);
    line(location.x,location.y,a.x,a.y);

  }
  //drawSelection() draws the selection circle and any requested info 
  void drawSelection()
  {
    drawMotionVector();
    //    fill(200,150,50,10);
    //    noStroke();
//    noFill();
    stroke(30,230,50,20);
    ellipseMode(CENTER_DIAMETER);
    ellipse(selectionCenter.x,selectionCenter.y,selectionSize*2,selectionSize*2);
    //    fill(255);
    //    textFont(selectionFont,55);
    //    text("RAWR",100,100);
  }
}
//the component class defines components for all cells. they are the what defines their shape
class component
{
  position parentLocation;          //the actual cell's current position
  position location;                //the component's location
  float distance;                   //the distance between the component and the cell
  float desiredDistance;            //the desired distance the component tries to keep away from its parent
  float parentAngle;                //the component's parent angle
  float angle;                      //the component's angle versus the parent
  float collideAngle;               //any collision recieved will be saved as an angle
  float offsetDistance;             //sinwave data is saved in offset to give the cell a pulsating look
  //constructors
  component()
  {
    defaultVal();
  }
  component(position loc,float a)
  {
    parentLocation=new position(loc);
    location=new position(loc);
    defaultVal();
    angle=a;
  }
  component(float x,float y)
  {
    parentLocation=new position(x,y);
    location=new position(x,y);
    defaultVal();
  }
  //defautVal() sets default values for the component
  void defaultVal()
  {
    distance=random(10,80);
    angle=random(0,360);
//    offsetDistance=random(1.5);
    offsetDistance=random(1);
    collideAngle=0;
    desiredDistance=distance;
  }
  //update() updates the component and moves it according to the cell's motion
  void update(float h,position loc,float ang,float speed,float colSize)
  {
    float dd=20+desiredDistance*(width-mx)/width*.8;
    if(distance<dd)
      distance+=.7;  
    distance=constrain(distance,0,dd);
//    float d=distance*(h/100);      
    collideAngle=collideAngle*.9;
    parentAngle=ang;
    //    float diff=abs(parentAngle-angle);
    //    angle=(diff);
    float angMod=parentAngle+angle+collideAngle;
    parentLocation=loc;
    float modDist=distance*h/100*sin(sinwave+offsetDistance);
    location=loc.displace(angMod,abs(modDist)+(colSize));
    position rLoc=location.displace(parentAngle,-speed*2);
    //    rLoc=rLoc.displace(ang,10);
    //    rLoc=rLoc.displace(180-ang,25);
    location=rLoc;
    //    position newposition=new position(location);
    //    location=newposition.displace(angle,distance);
  }
  //collision() will detect collision against all other components when its parent is within range, and attempt to shrink the component until there is no more collision
  void collision(int cid,float ang,float speed)
  {
    for(int i=0;i<subject[cid].subcomponents.length;i++)
    {
      float l=dist(subject[cid].subcomponents[i].location.x,subject[cid].subcomponents[i].location.y,location.x,location.y);
      if(l<20)
      {
        stroke(((mx2/width)*255)+10,255-(width-mx2),width-mx2,100*(20-l)/20);
        line(subject[cid].subcomponents[i].location.x,subject[cid].subcomponents[i].location.y,location.x,location.y);
        //location=location.displace(ang,speed*2);

        //        if(subject[cid].subcomponents[i].location.y>location.y)
        //          collideAngle-=(180-getHeading(location,subject[cid].subcomponents[i].location))/10;
        //        else
        //          collideAngle+=(180-getHeading(location,subject[cid].subcomponents[i].location))/10;
        //          location=location.displace(getHeading(location.x,location.y,subject[cid].subcomponents[i].location.x,subject[cid].subcomponents[i].location.y),-1*(5));

        distance-=1;
      }
      //      if(dist(subject[cid].location.x,subject[cid].location.y,location.x,location.y)<subject[cid].selectionSize*2)
      //      {

      //      }
    }
    if(dist(subject[cid].location.x,subject[cid].location.y,location.x,location.y)<20)
    {
      distance-=1;
    }
    //    for(int i=0;i<subject.length,i++)
    //    {
      //      if(i!=id)
      //      {
      //      }
    //    }
  }
  //draw() draws the component (displayed as a line)
  void draw()
  {
    //    fill(50);
    //    ellipseMode(CENTER_DIAMETER);
    //    ellipse(location.x,location.y,3,3);
//        stroke(255-(100*(desiredDistance-distance)/desiredDistance),40);
    stroke(mx2/width*20,50,50,100*(distance/desiredDistance+1));
        line(parentLocation.x,parentLocation.y,location.x,location.y);
  }
  //getLength() will return the current lengt of a component
  float getLength()
  {
    return dist(location.x,location.y,parentLocation.x,parentLocation.y);
  }
}