import noc.*;

class boingy {
  mass[] m;
  mass[] mm;
  spring[][] body;
  spring[][] head;
  spring[][] neck;
  int num;
  
  int bsize = 50; //body size
  int hsize = 20; //head size
  
  Vector3D loc;
  Vector3D vel;
  Vector3D acc;
  
 // boingy(int n, Vector3D a, Vector3D v, Vector3D l) {
  boingy(int n) {
   
   /* 
    acc = a.copy();
    vel = v.copy();
    loc = l.copy();
    */
    
    //create masses and springs for body
    m = new mass[n];
    for (int i = 0; i < n; i++) {
      
      m[i] = new mass();
      m[i].px = width/2 + sin((float)i/(float)n * TWO_PI) * bsize;
      m[i].py = height/2 + cos((float)i/(float)n * TWO_PI) * bsize;
      m[i].vx = m[i].vy = m[i].ax = m[i].ay = m[i].fx = m[i].fy = 0;
      m[i].mass = const_mass; 
    }
    body = new spring[n][n];
    for (int i = 1; i < n; i++) {
      for (int j = 0; j < i; j++) {
        if (true)
        {
          body[i][j] = new spring();
          body[i][j].k = const_k;
          body[i][j].d = sqrt(sq(m[i].px - m[j].px) + sq(m[i].py - m[j].py));
        }
        else
          body[i][j] = null;
      }
    num = n;
    }
    
    //create masses and springs for head
    mm = new mass[n];
    for (int i = 0; i < n; i++) {
      mm[i] = new mass();
      
      mm[i].px = m[1].px + sin((float)i/(float)n * TWO_PI) * hsize;
      mm[i].py = m[1].py + cos((float)i/(float)n * TWO_PI) * hsize;
      mm[i].vx = mm[i].vy = m[i].ax = mm[i].ay = mm[i].fx = mm[i].fy = 0;
      mm[i].mass = const_mass; 
    }
    head = new spring[n][n];
    for (int i = 1; i < n; i++) {
      for (int j = 0; j < i; j++) {
        if (true)
        {
          head[i][j] = new spring();
          head[i][j].k = const_k;
          head[i][j].d = sqrt(sq(mm[i].px - mm[j].px) + sq(mm[i].py - mm[j].py));
        }
        else
          head[i][j] = null;
      }
    num = n;
    }
    // create springs to connect body and head
    neck = new spring[2][2];
    neck[0][0] = new spring();
    neck[0][0].k = const_k;
    neck[0][0].d = sqrt(sq(mm[0].px - m[0].px) + sq(mm[0].py - m[0].py));
    neck[0][1] = new spring();
    neck[0][1].k = const_k;
    neck[0][1].d = sqrt(sq(mm[1].px - m[0].px) + sq(mm[1].py - m[0].py));  
    neck[1][0] = new spring();
    neck[1][0].k = const_k;
    neck[1][0].d = sqrt(sq(mm[0].px - m[1].px) + sq(mm[0].py - m[1].py));
    neck[1][1] = new spring();
    neck[1][1].k = const_k;
    neck[1][1].d = sqrt(sq(mm[1].px - m[1].px) + sq(mm[1].py - m[1].py));    
  }
  
  // main method
  void go() {
  //update();
  draw();
  step();
  
    
  }
  
  
  void draw() {
   // main body lines and spokes
    stroke(0, 115, 0, 215);
    for (int i = 1; i < num; i++){
      for (int j = 0; j < i; j++){
        if (body[i][j] != null) {
          line(m[i].px, m[i].py, m[j].px, m[j].py);
        }
      }
    }
    // main body cirlce ends
    stroke(0, 64, 0);
    fill(128, 255, 80);
    for (int i = 0; i < num; i++){
      ellipse(m[i].px, m[i].py, 8, 8);
    }
    // head lines and spokes
    stroke(0, 0, 115, 215);
    for (int i = 1; i < num; i++){
      for (int j = 0; j < i; j++){
        if (head[i][j] != null) {
          line(mm[i].px, mm[i].py, mm[j].px, mm[j].py);
        }
      }
    }
    // head cirlce ends
    stroke(0, 0, 64);
    fill(128, 80, 255);
    for (int i = 0; i < num; i++){
      ellipse(mm[i].px, mm[i].py, 8, 8);
    }
    // neck lines connecting body and head
    stroke(0, 64, 64);
    line(mm[0].px, mm[0].py, m[1].px, m[1].py);
    line(mm[1].px, mm[1].py, m[1].px, m[1].py);
  }
  
  // step thru all the forces
  void step() {
    assess_forces();
    apply_forces();
  }
  
  // Method to update location
 /*
  void update() {
    vel.add(acc);
    vel.limit(max_vel);
    loc.add(vel);
    acc.setXYZ(0.0f,0.0f, 0.0f);
  }
  */
  
  void assess_forces() {
    for (int i = 1; i < num; i++) {
      for (int j = 0; j < i; j++) {
        if (body[i][j] != null) {
          float k = body[i][j].k;
          float dist_offset = sqrt(sq(m[i].px - m[j].px) + sq(m[i].py - m[j].py)) - body[i][j].d;
          float angle = atan2(m[i].px - m[j].px, m[i].py - m[j].py);
          m[i].fx -= sin(angle) * k * dist_offset;
          m[i].fy -= cos(angle) * k * dist_offset;
          m[j].fx += sin(angle) * k * dist_offset;
          m[j].fy += cos(angle) * k * dist_offset;
        }
        if (head[i][j] != null) {
          float k = head[i][j].k;
          float dist_offset = sqrt(sq(mm[i].px - mm[j].px) + sq(mm[i].py - mm[j].py)) - head[i][j].d;
          float angle = atan2(mm[i].px - mm[j].px, mm[i].py - mm[j].py);
          mm[i].fx -= sin(angle) * k * dist_offset;
          mm[i].fy -= cos(angle) * k * dist_offset;
          mm[j].fx += sin(angle) * k * dist_offset;
          mm[j].fy += cos(angle) * k * dist_offset;
        }
        // ???
        mm[1].fy = m[1].fy;
        mm[1].fx = m[1].fx;
                
      }
    }
  }
  
  void apply_forces() {
    for (int i = 0; i < num; i++) {
      m[i].update();
      mm[i].update();
    }
  }
  
  void moveUp() {
     for (int i = 0; i < num; i++) {
        m[i].py--;
        mm[i].py--;
      }
  }
  
  void moveDown() {
    for (int i = 0; i < num; i++) {
        m[i].py++;
        mm[i].py++;
      }
  }
  
  void moveRight() {
    for (int i = 0; i < num; i++) {
        m[i].px++;
        mm[i].px++;
      }
  }
  
  void moveLeft() {
    for (int i = 0; i < num; i++) {
        m[i].px--;
        mm[i].px--;
      }
  }
  
  
}