/* ----------------------------------------------
Computing Kaizen Studio
Advanced Studio VI Spring 2010
Columbia University GSAPP

Cutting Bodies
Code by Ayaz Momin
http://www.arch.columbia.edu/
http://proxyarch.com/kaizen

This work is licensed under a Creative Commons 
Attribution-Noncommercial-Share Alike 3.0 License
-----------------------------------------------*/

import traer.physics.*;

class Node {


  float x,y,z,mass;
  String name;
  Node[] connections;
  color clr;
  int reach;
  int cutDepth;


  ParticleSystem physics;
  Particle p;
  Spring[] springs;
  Attraction[] attractions;

  Node(String _name, float _mass, float _x, float _y, float _z, ParticleSystem _physics, Node[] _others){
    reach = 0;
    x = _x;
    y = _y;
    z = _z;
    cutDepth = 0;
    mass = _mass;
    name = _name;
    connections = new Node[0];

    physics = _physics;
    connections = new Node[0];
    springs = new Spring[0];
    attractions = new Attraction[0];
    p = physics.makeParticle(mass, x, y, z);	
    for(int i=0; i<_others.length; i++){
      if( p != _others[i].p &&  dist(p.position().x(), p.position().y(), p.position().z(), _others[i].p.position().x(), _others[i].p.position().y(), _others[i].p.position().z()) < spacing*5.0){
        Attraction a = physics.makeAttraction( p,_others[i].p, repulsionForce*2, minDistance );
        Attraction b = physics.makeAttraction( _others[i].p, p, repulsionForce*2, minDistance );
        attractions = (Attraction[]) append(attractions, a);
        _others[i].attractions = (Attraction[]) append(_others[i].attractions, b);
      }
    }
  }

  int recursiveReach( int maxGenerations, int currentGeneration, float lineWidth, Node _parent){

    int childCount = 1;

    if(_parent != null){
      strokeWeight(lineWidth);
      line(x, y, _parent.x, _parent.y);
    }
    if( currentGeneration < maxGenerations){
      for(int i=0; i<connections.length; i++){
        Node theNode = connections[i];
        if(theNode != _parent){
          childCount += theNode.recursiveReach( maxGenerations, currentGeneration + 1, lineWidth/2.0, this );
        }
      }
    }
    strokeWeight(1.0);
    return childCount;
  }

  void figureReach(){
    reach = 0;
    stroke(255);
    for(int i=0; i<connections.length; i++){
      Node theNode = connections[i];

      strokeWeight(10.0);
      line(x, y, theNode.x, theNode.y);
      for(int j=0; j<theNode.connections.length; j++){
        Node secondDegreeNode = theNode.connections[j];

        strokeWeight(5.0);
        line( theNode.x, theNode.y, secondDegreeNode.x, secondDegreeNode.y);
        reach++;
      }
      reach++;
    }
    strokeWeight(1.0);
  }

  void fix(){
    p.makeFixed();
  }

void unfix(){
  if(  p.isFixed()){
     p.makeFree(); 
  }
  }
  
  void connect(Node a, float _strength, float _restLength, boolean _on){
    connections = (Node[]) append(connections, a);
    Spring theSpring = physics.makeSpring(this.p, a.p, _strength, 1, _restLength );
    springs = (Spring[]) append( springs, theSpring );
    if(!_on){
      theSpring.turnOff(); 
    }
  }

  Node[] getConnections(){
    return connections; 
  }

  void plot3D(float sc){
   
    //stroke(255);
    fill(0);
    noStroke();
    ellipse(x,y, 4,4);
  }

  void plot3Dedge(float sc){
    

    stroke(20);
    for(int i=0; i<connections.length; i++){
      strokeWeight((cutDepth+connections[i].cutDepth)/2.0 + 1 );
      line(x,y,connections[i].x, connections[i].y);
    }
  }

  void update(){
    this.x =  p.position().x();
    this.y =  p.position().y();
    this.z =  p.position().z();
  }
}