genome gene;
float mx;
void setup()
{
  size(300,300);
  ellipseMode(CENTER_DIAMETER);
  gene=new genome();
//  gene.printGenome();
}
void loop()
{
  background(80);
  mx=mx+getSpringForceScalar(mx,constrain(mouseX,0,200),0,.2);
  translate(0,0,constrain(mx,0,300));
  drawPhenome(gene);
}
void mouseReleased()
{
  setup();
}
void drawPhenome(genome g)
{
  noStroke();
  fill(208,25,15);

  position rootPos=new position(width/2,height/2);
  ellipse(rootPos.x,rootPos.y,3,3);
  for(int v=0;v<g.tracker.length;v++)
  {
    g.tracker[v]=g.nodes[v].maximum;
  }
  drawNode(g,g.root,rootPos);
}
void drawNode(genome g,gNode node,position p)
{
  gNode select=node;
  position pos=new position(p);
  if(g.tracker[select.id]>0)
  {
    for(int i=0;i<node.next.length;i++)
    {  
      position prevPos=new position(pos);           
      for(int s=0;s<node.next[i].quantity;s++)
      {
        select=new gNode(g.nodes[node.next[i].type],g.nodes[node.next[i].type].id);
        g.tracker[select.id]--;   
        pos=pos.displace(select.angle,mx*.1);    
        stroke(180,200,252,90);
        noFill();
        ellipse(pos.x,pos.y,5,5);
        noStroke();
        fill(60+select.id*7,250-select.id*15,40+select.id*5,150);
        ellipse(pos.x,pos.y,2,2);         
        stroke(60);
        line(prevPos.x,prevPos.y,pos.x,pos.y);        
        //println("rawr");
        drawNode(g,select,pos);              
        pos=prevPos;
      }
           
  
    }
     
  }
  else
    return;
}
class typeQuantity
{
  int type;
  int quantity=0;
  typeQuantity(int t,int q)
  {
    type=t;
    quantity=q;
  }
}
class gNode
{
  int id;
  float angle;
  int amount;
  int maximum=6;
  typeQuantity next[];
  gNode()
  {}
  gNode(gNode g,int tid)
  {
    id=tid;
    angle=g.angle;
    amount=g.amount;
    maximum=g.maximum;
    next=new typeQuantity[g.next.length];
    for(int i=0;i<next.length;i++)
    {
      next[i]=new typeQuantity(g.next[i].type,g.next[i].quantity);
    }
  }
  void printThis()
  {
    println("---(node type "+id+")-------------------------");  
    printFloat("angle",angle);
    printFloat("amount",amount);
    printFloat("max",maximum);
    print("next: ");
    for(int i=0;i<next.length;i++)
    {
      print("("+next[i].type+","+next[i].quantity+") ");
    }
    println();
  }
}
class genome
{
  gNode nodes[];
  gNode root;
  int tracker[];
  
  int variations=25;
  float angleMax=360;
  int maxRepeats=10;
  int childVariations=5;
  genome()
  {
    nodes=new gNode[variations];
    for(int i=0;i<nodes.length;i++)
    {
      nodes[i]=new gNode();
      nodes[i].id=i;      
      nodes[i].angle=random(0,angleMax);
      nodes[i].maximum=int(ceil(random(1,maxRepeats)));
      nodes[i].amount=nodes[i].maximum;
      int quantity=int(ceil(random(1,childVariations)));
      nodes[i].next=new typeQuantity[quantity]; 
      for(int s=0;s<nodes[i].next.length;s++)
      {  
//        if(int(random(nodes.length))==nodes[i-1].next[s].type)
//            s--;
        nodes[i].next[s]=new typeQuantity(int(random(nodes.length)),int(ceil(random(maxRepeats))));             
      }    
    }
    gNode rootID=nodes[int(random(nodes.length))];    
    root=new gNode(rootID,rootID.id);
    tracker=new int[nodes.length];
    for(int v=0;v<tracker.length;v++)
    {
      tracker[v]=nodes[v].maximum;
    }
  }
  void printGenome()
  {
    print("-----root");
    root.printThis();
    for(int i=0;i<nodes.length;i++)
    {
      nodes[i].printThis();
    }
  }  
}

//-----------------------------------------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);
}
void printFloat(String s, float z)
{
  print(s);
  print(": ");
  println(z);
  return;
}
void printPos(String s,position p)
{
  print(s+" coordinates (x:");
  println(p.x+","+p.y+")");
  return;
}