/* 
 
 bubbleBubble 
 
 Due bolle si scontrano e si intersecano 
 
 September 2007 
 Processing v.0124 <http://processing.org> 
 
 */

//parametrizzare i raggi delle bolle x decidere a che distanza devono unirsi 


int numCircle =7; 
Circle[] circles = new Circle[numCircle]; 

void setup() 
{ 
  size(800, 600); 
  frameRate(30); 


  //Creazione delle bolle
  //Le bolle andrebbero create in modo tale da non essere sovrapposte 
  //Il movimento dovrebbe essere verso il centro dello schermo

  
  //Due bolle 
  circles[0] = new Circle(100, 100,20,  0.25,0, 0); 
  circles[1] = new Circle(200, 100,5, -0.25, 0, 1); 
  
                          //x   y  r  dx     dy id   
  circles[2] = new Circle(100, 200,40, 0.25, 0, 2); 
  circles[3] = new Circle(200, 200,40, -0.25, 0, 3); 

  circles[4] = new Circle(100, 300,20, 0.01, 0, 4); 
  circles[5] = new Circle(150, 350,20, -0.25, -0.25, 5); 

  circles[6] = new Circle(180, 150,10, -0.25, -0.25, 6); 


  /*circles[0] = new Circle(100, 100,20,  0.01,0, 0); 
  circles[1] = new Circle(200, 200,20, -0.25, -0.25, 1); */


  /*for(int i=0; i<numCircle; i++) { 
   circles[i] = new Circle(random(width), 
   	      (float)height/(float)numCircle * i, 
   	      int(random(2, 6))*10, random(-0.25, 0.25), 
   	      random(-0.25, 0.25), i); 
   }*/


  ellipseMode(CENTER_RADIUS); 
  background(255); 
} 


void draw() 
{ 
  //Pulizia dello schermo
  background(255); 

  stroke(0, 10); 

  for(int i=0; i<numCircle; i++) { 
    circles[i].update(); //Calcolo intersezione
  } 

  //Aggiunto disegno delle bolle
  for(int i=0; i<numCircle; i++) { 
    circles[i].draw(); 
  }    


  //Movimento delle bolle
  for(int i=0; i<numCircle; i++) { 
    circles[i].move(); 
  } 
} 


class Circle 
{ 
  float x, y, r, r2, sp, ysp; 
  float ax, ay;
  float bx, by; //Coordinate punti intersezione A B
  int p;
  int id; 

  Circle( float px, float py, float pr, float psp, float pysp, int pid ) { 
    x = px; 
    y = py; 
    r = pr; 
    r2 = r*r; 
    id = pid; 
    sp = psp; 
    ysp = pysp; 

    ax = 0;
    ay = 0;

    bx = 0;
    by = 0;

    p = 1;
  } 

  void update() { 

    for(int i=0; i<numCircle; i++) { 
      if(i != id) { 
        intersect( this, circles[i] ); 
      } 
    } 

  } 

  void draw(){ 

    float g1 = 0, a1;
    float g2 = 0, a2;

    stroke(100,100,100);

    //finchè le coordinate della corda non sono valorizzate disegno il cerchio completo
    //altrimenti si calcola per ciascun punto della corda l'angolo formato sul cerchio 
    //in modo tale da determinare il grado di inizio e di fine dell'arco di cerchio

    //if (p!= 0){
    if (sp == 0) {

      //quando calcolo l'angolo che si forma unendo il centro e il punto di intersezione 
      //dei due cerchi, normalizzo le coordinate del cerchio riportandole a zero, cioè faccio la
      //differenza tra le coordinate del punto a e quelle del centro del cerchio

      println("");
      println("id:" + id);

      g1 = (atan2((y-ay),(x-ax)));      
      println("x-ax " + (x-ax) + " y-ay " + (y-ay) );
      a1 = g1*180/PI;
      println("g1:" + g1 + " gradi:" + a1);

      g2 = (atan2((y-by),(x-bx)));      
      println("x-bx " + (x-bx) + " y-by " + (y-by) );
      a2 = g2*180/PI;
      println("g2:" + g2 + " gradi:" + a2);

      
      //Per il cerchio di sinistra, l'arco deve andare da g a 2*PI-g
     //Per il cerchio di destra invece l'arco deve andare da PI+g a PI-g
      arc(x, y, r, r, PI+g2,PI+g1);
      
      //stroke(255,0,0);

      //line(ax, ay, bx, by); 

      
      p = 0;
    }
    else {
      arc(x, y, r, r, 0, 2*PI);
    }

  }

  void move() { 
    x += sp; 
    y += ysp; 
    if(sp > 0) { 
      if(x > width+r) { 
        x = -r; 
      }   
    } 
    else { 
      if(x < -r) { 
        x = width+r; 
      } 
    } 
    if(ysp > 0) { 
      if(y > height+r) { 
        y = -r; 
      } 
    } 
    else { 
      if(y < -r) { 
        y = height+r; 
      } 
    } 
  } 
} 


void intersect( Circle cA, Circle cB ) 
{ 
  float dx = cA.x - cB.x; 
  float dy = cA.y - cB.y; 
  float d2 = dx*dx + dy*dy; 
  float d = sqrt( d2 ); 

  if ( d>cA.r+cB.r || d<abs(cA.r-cB.r) ) { 
    return; // no solution 
  } 

  float a = (cA.r2 - cB.r2 + d2) / (2*d); 
  float h = sqrt( cA.r2 - a*a ); 
  float x2 = cA.x + a*(cB.x - cA.x)/d; 
  float y2 = cA.y + a*(cB.y - cA.y)/d; 

  float paX = x2 + h*(cB.y - cA.y)/d; 
  float paY = y2 - h*(cB.x - cA.x)/d; 
  float pbX = x2 - h*(cB.y - cA.y)/d; 
  float pbY = y2 + h*(cB.x - cA.x)/d; 

  //stroke(dist(paX, paY, pbX, pbY)*4, 12); 

  stroke(100,100,100);
  line(paX, paY, pbX, pbY); 

  //Le bolle che sono intersecate si fermano
  //In realtà si dovrebbero fermare quando il valore d è > di xx% rispetto ai raggi delle bolle
  if (d < 20) {  

    cA.ax = paX;
    cA.ay = paY;

    cA.bx = pbX;
    cA.by = pbY;

    //***************
    
    //anche se sembra sbagliato è giusto 
   //Specchio dei punti di intersezione  
    cB.ax = pbX;
    cB.ay = pbY;

    cB.bx = paX;
    cB.by = paY;

    //***********

    cA.sp = 0;
    cA.ysp = 0;

    cB.sp = 0;
    cB.ysp = 0;

    stroke(100,100,100);
    line(paX, paY, pbX, pbY); 

    //cA.draw();
    //cB.draw();

  }
}