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

int idxCircle =-1; 
Circle[] circles= new Circle[10]; 

void AddCircle(int x, int y, int r, float dx, float dy){ 
  
  idxCircle ++;

  circles[idxCircle] = new Circle(x, y,r, dx, dy, idxCircle);
}   
  
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

  
  
  AddCircle(400, 400,70, 0.25, 0);
  AddCircle(500, 400,30, -0.25, 0);
  AddCircle(450, 450,50, -0.01, -0.25);
  
  AddCircle(200, 200,40, 0.25, 0);
  AddCircle(300, 200,40, -0.25, 0);
  AddCircle(250, 250,40, -0.01, -0.1);
  
  


  ellipseMode(CENTER_RADIUS); 
  background(255); 
} 


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

  stroke(0, 10); 

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

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


  //Movimento delle bolle
  for(int i=0; i<circles.length; i++) { 
    if(circles[i] != null){   
      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; 
  
  float g1 = 0, a1;
  float g2 = 0, a2;

  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;
    
    g1 =0;
    g2=0;
    
  } 

  void update() { 

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

  } 

  void calc_g1(){
    
    float a1;
    
    g1 = (atan2((y-ay),(x-ax)));        
    a1 = g1*180/PI;
    
  }  

  void calc_g2(){
    
    float a2;
    
      g2 = (atan2((y-by),(x-bx)));      
      a2 = g2*180/PI;
      
  }  

  void draw(){ 

    

    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) {


      arc(x, y, r, r, PI+g2,PI+g1);
      
      

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

  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; 
      } 
    } 
  } 
} 
   //questo mi serve per avere l'equazione della retta che passa per il
   //centro del cerchio e il punto di intersezione, cioè quella
   //su cui sta il raggio
   float r(float m, float p, float x) {
    return (x*m) + p;
  }
  
  
float equ_rect_m(float x1,float y1, float x2, float y2){

    return (y2 - y1) / (x2 - x1); 
 }   

float equ_rect_p(float x1,float y1, float x2, float y2){
return ((x2 * y1) - (x1 * y2) ) / (x2 - x1);
 }   


  
void intersect( Circle cA, Circle cB ) 
//se i due cerchi sono fermi, esci con return
{ 
  float dx = cA.x - cB.x; 
  float dy = cA.y - cB.y; 
  float d2 = dx*dx + dy*dy; 
  float d = sqrt( d2 ); 

  
  Circle C,cX;

  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; 

  
  //Le bolle che sono intersecate si fermano
  //Le bolle si fermano e fanno l'intersezione quando l'angolo fra i due archi è di 120°.
  //qui calcolo il valore di d quando l'angolo è 120° sapendo i raggi e che si forma un 
  //triangolo con angoli di 60° tra i centri e il punto di intersezione. Uso il coseno dell'angolo di 60°
  
  float rapporto = (cA.r*cA.r+cB.r*cB.r) - 2*cA.r*cB.r*cos(PI/3);
  float rapporto2 = sqrt (rapporto);
  if (d < rapporto2) {  

    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(255,0,0);
    line(paX, paY, pbX, pbY); 
    //cA.draw();
    //cB.draw();
    
    
    
    //***********************
    
    //PEZZO NUOVO PER FARE L'ARCO DI CERCHIO!!!!
    //qui calcolo quanto vale l'angolo nel centro di uno dei due cerchi, poi trovo BD
    //cioè la distanza dall'altro centro al centro del cerchio che è l'intersezione delle due bolle
    //quindi una volta trovate le coordinate di D mi manca solo di disegnarlo
    
    float coseno;
    float angolo_alpha;
    float BD;
    float cD_x, cD_y;
    
   
    coseno = (cA.r*cA.r + rapporto - cB.r*cB.r)/ (2 * cA.r * rapporto2);
    angolo_alpha = acos (coseno);
    
    
    BD = (rapporto2 * sin(angolo_alpha)) / sin(PI/3 - angolo_alpha);
    
    //una volta trovata la distanza BD, come faccio a trovare le coordinate di D?
    //so solo che sta sulla stessa retta che contiene i due centri e la sua distanza da B
    
    //Retta passante per i due centri dei cerchi
    float m2,p2;
      
    m2 = equ_rect_m(cA.x,cA.y,cB.x,cB.y);
    p2 = equ_rect_p(cA.x,cA.y,cB.x,cB.y);
    
    stroke(0,255,0);
    
    
    float delta_x;
    
    float C_x, C_y, C_r;

    if (cA.r < cB.r) {
      C_x = cA.x;
      C_y = cA.y;
      C_r = cA.r;
    } 
    else{
      C_x = cB.x;
      C_y = cB.y;
      C_r = cB.r;
    }
    
    
    
    delta_x = cos (atan (m2)) * BD;
    
    
    cD_x = C_x - delta_x;
    cD_y = r(m2, p2,cD_x);
    
    stroke (255,0,0);
    
   
    
    //con questo dovrei poter calcolare la distanza da D al punto d'intersez dei due cerchi,
    //cioè il raggio del mio arco di cerchio che fa l'intersezione
    float raggio_x = cA.ax - cD_x; 
    float raggio_y = cA.ay - cD_y; 
    float raggio2 = raggio_x*raggio_x + raggio_y*raggio_y; 
    float raggio = sqrt( raggio2 );
    
    
    cA.calc_g1();
    cA.calc_g2();    

    cB.calc_g1();
    cB.calc_g2();    
    
    //Cerchio D e suo disegno

    
    if (cA.r < cB.r) {        
      C = new Circle(cD_x,cD_y,raggio,0,0,0);
      C.ax = cA.ax;
      C.ay = cA.ay;
    
      C.bx = cA.bx;
      C.by = cA.by;
          
      C.calc_g1();
      C.calc_g2();
      
      
      
      arc (C.x, C.y, C.r, C.r, PI + C.g1,PI + C.g2);      
      
    } 
    

    

     //***********************
    
    
    
    
    float m,p;

    //Retta passante per centro e punto intersezione A    
    stroke(0,255,0);

    m = equ_rect_m(cA.x,cA.y,paX,paY);
    p = equ_rect_p(cA.x,cA.y,paX,paY);

   
    
    m = -tan(atan(m)+30);
    
    stroke(0,0,255);
    //line(paX,r(m,p,paX),600,r(m,p,600));
  }
  

}