creature rawr;

void setup()
{
  size(500,500);
  ellipseMode(CENTER_DIAMETER);
  rawr=new creature();
//  rawr.debug();
}

void loop()
{
  background(105);
  renderCreature(rawr);
  
//  rawr.update();
//  rawr.draw();  
  
}
void mouseReleased()
{
  setup();
}

void renderCreature(creature c)
{
  position central=c.centralCell.posGlobal;
  
  //draw central axis
  stroke(190,190,190);
  line(central.x,150,central.x,height-150);
  line(central.x-30,central.y,central.x+30,central.y);
  
  //draw central cell
  noStroke();
  fill(130,205,195);
  ellipse(central.x,central.y,6,6);
  
  //draw cells
  for(int i=0;i<c.amount;i++)
  {
    position p=c.container[i].posGlobal;
    
    fill(150+(p.y/height)*200,180,250);      
    ellipse(p.x,p.y,6,6);
  }
  
  //draw connections
  for(int s=0;s<c.amount;s++)
  {
    position cellPos=c.container[s].posGlobal;
    int list[]=c.container[s].connections;
    if(list!=null)
    {
      for(int v=0;v<list.length;v++)
      {
      
        float distance=dist(cellPos,c.container[list[v]].posGlobal);        
        stroke(190,240,254,(250-distance)*300/255);      
        
        line(cellPos.x,cellPos.y,c.container[list[v]].posGlobal.x,c.container[list[v]].posGlobal.y);
      }
    }
  }
}

class cell
{
  position posLocal;
  position posGlobal;
  float heading;
  float distance;
  vector force;
  int connections[];
  cell()
  {}
  cell(position p)
  {
    posGlobal=new position(p);
  }
  cell(cell c)
  {
    posLocal=new position(c.posLocal);
    posGlobal=new position(c.posGlobal);
    heading=c.heading;
    distance=c.distance;
    connections=new int[c.connections.length];
    for(int i=0;i<connections.length;i++)
    {
      connections[i]=c.connections[i];
    }
  }
  cell(position central,float h,float d)
  {
    position origin=new position(0,0);
    heading=h;
    distance=d;
    posGlobal=new position(central.displace(heading,distance));
    posLocal=new position(origin.displace(heading,distance));
  }
  cell mirror(position central,int half)
  {
    position origin=new position(0,0);    
    
    cell newCell=new cell(this);
    newCell.heading=180-newCell.heading;
    newCell.posGlobal=new position(central.displace(newCell.heading,newCell.distance));
    newCell.posLocal=new position(origin.displace(newCell.heading,newCell.distance));
    if(newCell.connections!=null)
    {
      for(int i=0;i<newCell.connections.length;i++)
      {
        newCell.connections[i]=newCell.connections[i]+half;
      }
    }
    return newCell;
  }
}
class creature
{
  cell container[];
  cell centralCell;
  int amount=40; //this must be an even number for now
  float centerThreshold;
  creature()
  {
    centralCell=new cell(new position(width/2,height/2));
    container=new cell[amount];
    for(int i=0;i<int(amount/2);i++)
    {
      container[i]=new cell(centralCell.posGlobal,random(90,270),random(5,250));
    }
    createConnections();    
    int s=0;
    for(int v=int(amount/2);v<amount;v++)
    {
      //container[v]=new cell(centralCell.posGlobal,180-container[s].heading,container[s].distance);
      container[v]=new cell(container[s].mirror(centralCell.posGlobal,int(amount/2)));
      s++;
    }
  }
  void createConnections()
  {
    for(int i=0;i<int(amount/2);i++)
    {
      int connectionAmount=int(random(1,10));
      container[i].connections=new int[connectionAmount];
      for(int s=0;s<connectionAmount;s++)
      {
        int connector;
        do
        {
          connector=int(random(amount/2));
        }
        while(connector==i);
        
        container[i].connections[s]=connector;
      }
    }
  }
  void debug()
  {
    for(int i=0;i<container.length;i++)
    {
      if(container[i]!=null)
      {
        int list[]=container[i].connections;
        print("cell: ");
        print(i);  
        print(" list: ");    
        for(int s=0;s<list.length;s++)
        {
          print(list[s]);
        }
        println(" ");      
      }
    }
  }
//          vector f=getSpringForce(nodes[i],nodes[s],125,.7);
//          nodes[i]=nodes[i].displace(f.a,0.15*f.m);        
}



//-----------------------------------------SPRINGS LIBRARY
//Written by Michael Chang with help by Chaim Gingold from MAXIS
//last revision 02/03/05

vector getSpringForce(position from,position to,float desiredLength,float constant)
{
  vector force=new vector(from,to);
  
  if(dist(from,to)!=0)
  {
    vector deltaLength=new vector(force);
    position targetPos=new position(to.displace(getHeading(to,from),desiredLength));
    deltaLength=new vector(from,targetPos);
//    fill(255,0,0);
//    ellipse(targetPos.x,targetPos.y,5,5);
    force=new vector(deltaLength);
    force.m*=constant;
  }
  return force;
}

float getSpringForceScalar(float from,float to,float desiredLength,float constant)
{
  float force=to;
  force-=from;
  if(force!=0)
  {
    float deltaLength=force;
    float targetLength=desiredLength;
    deltaLength=deltaLength-targetLength;
    force=deltaLength;
    force*=constant;
  }

  return force;
}


//-----------------------------------------VECTOR/COORDINATE LIBRARY
//Written by Michael Chang
//last revision 11/30/03
static float conversionArc=180.0/PI;                              //180/PI used for many calculations
class position                                           //position class that stores 2 values x and y
{
  float x,y;
  position(){}
  position(float tx,float ty)
  {
    x=(tx);
    y=(ty);
  }
  position(position p)
  {
    if(p!=null)
    {
      x=p.x;
      y=p.y;
    }
  }
  position displace(float angle,float magnitude)         //returns the position displaced by an angle and distance
  {
    float ra=radians(angle);
    /*
    code optimization:
    ra is used for calculating radian conversion only once instead
    of once per line.
    */

    position newP=new position(x,y);
    newP.x+=(cos(ra)*magnitude);
    newP.y-=(sin(ra)*magnitude);
    return newP;
  }
  void set(float tx,float ty)                            //sets a new coordinate
  {
    x=(tx);
    y=(ty);
  }
  void set(position p)
  {
    x=p.x;
    y=p.y;
  }
}
class vector                                            //vector class that stores a position, angle, and magnitude
{
  float a,m;
  position p;

vector(){}
  vector(float tx,float ty,float angle,float magnitude)
  {
    p=new position(tx,ty);
    a=angle;
    m=magnitude;
  }
  vector(position start,position end)
  {
    p=new position(start);
    a=getHeading(start,end);
    m=dist(start,end);
  }
  vector(position pos,float angle,float magnitude)
  {
    p=new position(pos);
    a=angle;
    m=magnitude;
  }
  vector(vector v)
  {
    p=new position(v.p);
    a=v.a;
    m=v.m;
  }
  position endPoint()                                    //returns the endpoint of the vector as type position
  {
    return displace(p,a,m);
  }
  position ep()
  {
    return endPoint();
  }
  vector add(vector v)                                   //returns a vector addition
  {
    position newEnd=new position(endPoint().displace(v.a,v.m));
    float newAngle=getHeading(p,newEnd);
    vector newVector=new vector(p,newAngle,dist(p.x,p.y,newEnd.x,newEnd.y));
    return newVector;
  }
  vector add(float angle,float magnitude)                //returns a vector addition
  {
    vector v=new vector(p,angle,magnitude);
    position newEnd=new position(endPoint().displace(v.a,v.m));
    float newAngle=getHeading(p,newEnd);
    vector newVector=new vector(p,newAngle,dist(p.x,p.y,newEnd.x,newEnd.y));
    return newVector;
  }
  vector sub(vector v)                                   //returns a vector subration (unimplemented)
  {
    return v;
  }
  void set(vector v)
  {
    p.set(v.p);
    a=v.a;
    m=v.m;
  }
  void set(position np,float na,float nm)
  {
    p.set(np);
    a=na;
    m=nm;
  }
  void setStart(position np)                             //sets a new starting point for the vector
  {
    p=np;
  }
  void setEnd(position np)                               //sets a new ending point for the vector
  {
    a=getHeading(p,np);
    m=dist(p,np);
  }
  void setEnd(float px,float py)                         //sets a new ending point for the vector
  {
    position np=new position(px,py);
    a=getHeading(p,np);
    m=dist(p.x,p.y,np.x,np.y);
  }
  float x()
  {
    return p.x;
  }
  float y()
  {
    return p.y;
  }
  int isUnder(position s)
  {
    if(a==90||a==270)
    return 0;
    position e=new position(endPoint());
    float slope=(p.y-e.y)/(p.x-e.x);
    float yIntercept=p.y-(slope*p.x);
    float testY=(slope*s.x)+yIntercept;
    //    if(slope>0)
    //    {
      if(s.y>testY)
      return 1;
      else
      return -1;
    /*    }
    else
    {
      if(s.y>testY)
      return -1;
      else
      return 1;
    }*/
  }
}

position displace(position p,float angle,float magnitude) //displaces a position by an angle and a magnitude, then returns it
{
  position newP=new position(p);
  float ra=radians(angle);
  newP.x+=(cos(ra)*magnitude);
  newP.y-=(sin(ra)*magnitude);

  return newP;
}
float getHeading(position p1,position p2)                //gets the absolute heading between one position and another relative to the first
{
  if(p1.x==p2.x&&p1.y==p2.y)
  return 0;
  float xd=p2.x-p1.x;
  float yd=p2.y-p1.y;
  float angle=float(Math.atan(yd/xd));
  //  angle=degrees(angle);
  angle=angle*conversionArc;
  if(xd>0&&yd<0)
  {
    angle=-1*angle;
  }
  else
  if(xd<0&&yd<0)
  angle=180-angle;
  else
  if(xd<0&&yd>0)
  angle=180-angle;
  else
  if(xd<0&&yd==0)
  angle=180;
  else
  if(xd==0&&yd<0)
  angle=90;
  else
  angle=360-angle;
  return angle;
}
float dist(position p1,position p2)
{
  return dist(p1.x,p1.y,p2.x,p2.y);
}
float normalizeHeading(float ang)                        //normalizes a heading between 0 and 360
{
  while(ang > 360)ang -= 360;
  while(ang < 0)ang += 360;
  return ang;
}
void drawVector(vector v)                                //draws a vector in white
{
  colorMode(RGB,255,255,255);
  stroke(255);
  noFill();
  ellipseMode(CENTER_DIAMETER);
  ellipse(v.p.x,v.p.y,5,5);
  position e=v.endPoint();
  line(v.p.x,v.p.y,e.x,e.y);
}
void drawVector(vector v,float s)                           //draws a vector with a longer line for representation in white
{
  colorMode(RGB,255,255,255);
  stroke(255);
  noFill();
  ellipseMode(CENTER_DIAMETER);
  ellipse(v.p.x,v.p.y,5,5);
  vector temp=new vector(v);
  temp.m*=s;
  position e=temp.endPoint();
  line(temp.p.x,temp.p.y,e.x,e.y);
}
void drawVector(vector v,int r,int g,int b,float s)                           //draws a vector with a longer line for representation in white
{
  colorMode(RGB,255,255,255);
  stroke(r,g,b);
  noFill();
  ellipseMode(CENTER_DIAMETER);
  ellipse(v.p.x,v.p.y,5,5);
  vector temp=new vector(v);
  temp.m*=s;
  position e=temp.endPoint();
  line(temp.p.x,temp.p.y,e.x,e.y);
}
void drawVector(vector v,int r,int g,int b)              //draws a vector in RGB
{
  colorMode(RGB,255,255,255);
  stroke(r,g,b);
  noFill();
  ellipseMode(CENTER_DIAMETER);
  ellipse(v.p.x,v.p.y,5,5);
  position e=v.endPoint();
  line(v.p.x,v.p.y,e.x,e.y);
}