/* built with Studio Sketchpad:
* https://sketchpad.cc
*
* observe the evolution of this sketch:
* https://studio.sketchpad.cc/sp/pad/view/ro.srEb4beDruN/rev.15435
*
* authors:
* Salvador Cueto
*
* license (unless otherwise specified):
* creative commons attribution-share alike 3.0 license.
* https://creativecommons.org/licenses/by-sa/3.0/
*/
// This sketch builds on a prior work, "Cercles3 "En construcció"", created by Salvador Cueto & [unnamed author]
// http://studio.sketchpad.cc/sp/pad/view/ro.9PBArJQnPrQuz/rev.11223
// This sketch builds on a prior work, "Cercles", created by Salvador Cueto
// http://studio.sketchpad.cc/sp/pad/view/ro.9STL0OqZ3s3Ty/rev.2518
// Català (Catalan)
///////////////// INSTANCIACIO /////////////////////////////
Cercles[] Cercle = new Cercles[50];
Colisions[i,j] Colisio = new Colisions[50,50];
Pantalles Pant = new Pantalles();
Disparador[] Disp = new Disparador[50];
/////////////////////////////////////////////////////////////////////
//////////////////// CLASSE DISPARADOR ///////////////////////
//////////////////////////////////////////////////////////////////////
class Disparador extends Cercles
{
}
/////////////////////////////////////////////////////////////////////
//////////////////// CLASSE CERCLES ////////////////////////
//////////////////////////////////////////////////////////////////////
class Cercles
{
float centre_x;
float centre_y;
float centrePrevi_x;
float centrePrevi_y;
float diamCercle;
float velocitat_x;
float velocitat_y;
float eCinetica_x;
float eCinetica_y;
float eCinetica;
float eCineticaPrevia;
float angleRebot1;
float angleRebot2;
int color;
/// Es porten els cercles a la posició previa a la col·lisió
void centrePrevi()
{
centre_x=centrePrevi_x;
centre_y=centrePrevi_y;
}
//// Dibuix del cercle
void dibuixa1(float x, float y, float diam)
{
ellipse (x,y,diam,diam);
centre_x=x+velocitat_x;
centre_y=y+velocitat_y;
diamCercle=diam;
}// Métode dibuixa1
//// Comprovació de col·lisió del ratolí amb el cercle
boolean intersecta_mouse_cercle (float X, float Y)
{
if (sqrt(pow(abs(X - centre_x),2) + pow(abs(Y - centre_y),2))> diamCercle/2)
{return false;}
else
{return true;}
}// Métode intersecta_mouse_cercle
//// Comprovació de col·lisió de cercle amb pantalla
void intersecta_cercle_pantalla (float X, float Y)
{
if (abs(X + diamCercle/2) >= 450)
{
velocitat_x=velocitat_x*(-1);
strokeWeight(3);
line(450, 1, 450, 300);
centrePrevi();
}
else if (abs(X - diamCercle/2) <= 50)
{ velocitat_x=velocitat_x*(-1);
strokeWeight(3);
line(50, 1, 50, 300);
centrePrevi();
}
else if (abs(Y + diamCercle/2) >= 297)
{
velocitat_y=velocitat_y*(-1);
centrePrevi();
}
else if (abs(Y - diamCercle/2) <= 3)
{
velocitat_y=velocitat_y*(-1);
centrePrevi();
}
}// Métode intersecta_cercle_pantalla
}//// Classe Cercles
/////////////////////////////////////////////////////////////////////
//////////////////// CLASSE COLISIONS ///////////////////////
/////////////////////////////////////////////////////////////////////
class Colisions
{
boolean colisio;
float proporcio;
float mitjana_x;
float mitjana_y;
float p1Cercle1_x;
float p1Cercle1_y;
float p2Cercle1_x;
float p2Cercle1_y;
float p1Cercle2_x;
float p1Cercle2_y;
float p2Cercle2_x;
float p2Cercle2_y;
float p1Cinetic_x;
float p1Cinetic_y;
float p2Cinetic_x;
float p2Cinetic_y;
float angleCinetic;
float angle1Cercle1;
float angle2Cercle1;
float angle3Cercle1;
float angle1Cercle2;
float angle2Cercle2;
float angle3Cercle2;
float angleDeriva1;
float angleDeriva2;
float angleRebot1;
float angleRebot2;
int cuadrantsAngle;
int retard;
int colisions;
//////////////////// METODE CALCULA ///////////////////////
void calculaColisio(int i, int j)
{
///////////////////// REPARTIMENT D'ENERGIA CINETICA //////////////////
// Es calcula l'energia cinètica de cada component de cada cercle abans de la col·lisió
// partint de la superficie (masa) i velocitats segons la formula Ec=1/2m*v^2
Cercle[i].eCinetica_x=abs(HALF_PI*sq(Cercle[i].diamCercle/2)
*sq(Cercle[i].velocitat_x));
Cercle[i].eCinetica_y=abs(HALF_PI*sq(Cercle[i].diamCercle/2)
*sq(Cercle[i].velocitat_y));
Cercle[j].eCinetica_x=abs(HALF_PI*sq(Cercle[j].diamCercle/2)
*sq(Cercle[j].velocitat_x));
Cercle[j].eCinetica_y=abs(HALF_PI*sq(Cercle[j].diamCercle/2)
*sq(Cercle[j].velocitat_y));
//Es calcula eCinetica total
Cercle[i].eCineticaPrevia=Cercle[i].eCinetica=
sqrt(sq(Cercle[i].eCinetica_x)+sq(Cercle[i].eCinetica_y));
Cercle[j].eCineticaPrevia=Cercle[j].eCinetica=
sqrt(sq(Cercle[j].eCinetica_x)+sq(Cercle[j].eCinetica_y));
//////////////////////// CENTRES DELS PUNTS /////////////////////////
// Es determinen les coordenades de les direccions conegudes
// Es defineix com a cercle 1 el cercle amb mes energia cinètica
if(Cercle[i].eCinetica > Cercle[j].eCinetica)
{
p2Cercle1_x=p1Cinetic_x=Cercle[i].centre_x;
p2Cercle1_y=p1Cinetic_y=Cercle[i].centre_y;
p2Cercle2_x=p2Cinetic_x=Cercle[j].centre_x;
p2Cercle2_y=p2Cinetic_y=Cercle[j].centre_y;
p1Cercle1_x=Cercle[i].centrePrevi_x ;
p1Cercle1_y=Cercle[i].centrePrevi_y ;
p1Cercle2_x=Cercle[j].centrePrevi_x ;
p1Cercle2_y=Cercle[j].centrePrevi_y ;
//// Proporcio= tant per cent del major respecte de la suma
proporcio =Cercle[i].eCinetica * 100 / (Cercle[j].eCinetica+Cercle[i].eCinetica) ;
}
else
{
p2Cercle1_x=p1Cinetic_x=Cercle[j].centre_x;
p2Cercle1_y=p1Cinetic_y=Cercle[j].centre_y;
p2Cercle2_x=p2Cinetic_x=Cercle[i].centre_x;
p2Cercle2_y=p2Cinetic_y=Cercle[i].centre_y;
p1Cercle1_x=Cercle[j].centrePrevi_x ;
p1Cercle1_y=Cercle[j].centrePrevi_y ;
p1Cercle2_x=Cercle[i].centrePrevi_x ;
p1Cercle2_y=Cercle[i].centrePrevi_y ;
//// Proporcio= tant per cent del major respecte de la suma
proporcio =Cercle[j].eCinetica * 100 / (Cercle[i].eCinetica+ Cercle[j].eCinetica);
}
// Es reparteix l'energia cinetica a parts iguals per a cada component fent la mitjana
Cercle[j].eCinetica = Cercle[i].eCinetica=(Cercle[i].eCinetica+ Cercle[j].eCinetica)/2 ;
//////////////// CRIDA CAS CINETIC /////////////////
//// Es determina el tipus de rebot segons les direccions dels cercles
casC=casCinetic(p1Cercle1_x, p1Cercle1_y, p2Cercle1_x,
p2Cercle1_y, p1Cinetic_x , p1Cinetic_y, p2Cinetic_x ,
p2Cinetic_y, p1Cercle2_x , p1Cercle2_y, p2Cercle2_x ,
p2Cercle2_y);
////////////////////////////////////////////////////////////////
////////////////// POSSIBLES CASOS DE REBOT /////////////
float a1;
float a2;
//// Execució del resultat segons cada cas o tipus de col·lisió.
//https://docs.google.com/open?id=0Bwne143nlGwRZDdjOWU4OGQtNGRiOC00MzEwLWI1OGQtN2Y0OTVlZTVjNDFj
if(casC == 1)///////////////////// CAS 1 ////////////////////////
{
///////////////////////cercle 1////////////////////////////////
// Angle inicial de rebot cercle1
a1=TWO_PI-angle1Cercle1+angleCinetic;
angle2Cercle1=angle1Cercle1-HALF_PI;
// Marge o ventall de direccións probables cercle1
angleDeriva1=angle1Cercle1-angle2Cercle1;
// Direcció definitiva del cercle 1
angleRebot1=angle2Cercle1+(proporcio *angleDeriva1/100);
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
a2=PI+HALF_PI -angle1Cercle2+angleCinetic;
angle2Cercle2=resta2Pi(angle1Cercle2+ 2*a2);
// Angle final del rebot Cercle 2
angle3Cercle2=angleCinetic;
// Marge o ventall de direccións probables cercle2
angleDeriva2=angleCinetic - angle2Cercle2;
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2+(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 2)////////////////////// CAS 2 //////////////
{
///////////////////////cercle 1////////////////////////////////
// Angle inicial de rebot cercle1
a1=HALF_PI-angle1Cercle2+angleCinetic ;
angle2Cercle1=resta2Pi(HALF_PI + angleCinetic + a1 );
// Angle final de rebot cercle 1
angle3Cercle1=resta2Pi(angle1Cercle1);
// Marge o ventall de direccións probables cercle1
angleDeriva1=resta2Pi(abs(angle2Cercle1-angle1Cercle1));
// Direcció definitiva del cercle 1
angleRebot1=resta2Pi(angle2Cercle1+(proporcio *angleDeriva1/100)) ;
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
a1=-HALF_PI+angle1Cercle2-angleCinetic;
angle2Cercle2=resta2Pi(HALF_PI + angleCinetic - a1);
// Angle final del rebot Cercle 2
angle3Cercle2=angleCinetic;
// Marge o ventall de direccións probables cercle2
angleDeriva2=resta2Pi(a2);
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2+(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 3)//////////////////////// CAS 3 ///////////////
{
///////////////////////cercle 1////////////////////////////////
// Angle inicial de rebot cercle1
a1=TWO_PI-angle1Cercle1+angleCinetic;
angle2Cercle1=angle1Cercle1-HALF_PI;
// Angle final de rebot cercle 1
angle3Cercle1=angle1Cercle1;
// Marge o ventall de direccións probables cercle1
angleDeriva1=angle3Cercle1-angle2Cercle1;
// Direcció definitiva del cercle 1
angleRebot1=angle2Cercle1+(proporcio *angleDeriva1/100);
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
a1=-HALF_PI+angle1Cercle2-angleCinetic;
angle2Cercle2=resta2Pi(HALF_PI + angleCinetic - a1);
// Angle final del rebot Cercle 2
angle3Cercle2=angleCinetic;
// Marge o ventall de direccións probables cercle2
angleDeriva2=resta2Pi(a2);
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2+(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 4)/////////////////////////////////// CAS 4
{
///////////////////////cercle 1////////////////////////////////
a1=HALF_PI-angle1Cercle2+angleCinetic ;
angle2Cercle1=resta2Pi(HALF_PI + angleCinetic + a1 );
// Angle final de rebot cercle 1
angle3Cercle1=resta2Pi(angle1Cercle1);
// Marge o ventall de direccións probables cercle1
angleDeriva1=resta2Pi(abs(angle2Cercle1-angle1Cercle1));
// Direcció definitiva del cercle 1
angleRebot1=resta2Pi(angle2Cercle1+(proporcio *angleDeriva1/100)) ;
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
a2=PI+HALF_PI -angle1Cercle2+angleCinetic;
angle2Cercle2=resta2Pi(angle1Cercle2+ 2*a2);
// Angle final del rebot Cercle 2
angle3Cercle2=angleCinetic;
// Marge o ventall de direccións probables cercle2
angleDeriva2=resta2Pi(HALF_PI-a2);
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2+(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 5)/////////////////////////////////// CAS 5
{
///////////////////////cercle 1////////////////////////////////
a1=PI-angle1Cercle1+angleCinetic;
angle2Cercle1=resta2Pi(PI+angleCinetic);
// Angle final de rebot cercle 1
angle3Cercle1=resta2Pi(angle1Cercle1);
// Marge o ventall de direccións probables cercle1
angleDeriva1=resta2Pi(a1) ;
// Direcció definitiva del cercle 1
angleRebot1=resta2Pi(angle2Cercle1-(proporcio *angleDeriva1/100) );
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
a2=PI+ HALF_PI-angle1Cercle2+angleCinetic;
angle2Cercle2=resta2Pi(PI+ HALF_PI+angleCinetic);
// Angle final del rebot Cercle 2
angle3Cercle2=resta2Pi(angle2Cercle2 + a2);
// Marge o ventall de direccións probables cercle2
angleDeriva2=resta2Pi(a2);
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2+(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 6)/////////////////////////////////// CAS 6
{
///////////////////////cercle 1////////////////////////////////
angle2Cercle1=resta2Pi(PI+angleCinetic);
// Angle final de rebot cercle 1
angle3Cercle1=resta2Pi(angle1Cercle1);
// Marge o ventall de direccións probables cercle1
angleDeriva1=resta2Pi( angle3Cercle1 - angle2Cercle1 );
// Direcció definitiva del cercle 1
angleRebot1=resta2Pi(angle2Cercle1+(proporcio *angleDeriva1/100)) ;
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
a2=PI-angle1Cercle2+angleCinetic;
angle2Cercle2=resta2Pi(HALF_PI+angleCinetic);
// Angle final del rebot Cercle 2
angle3Cercle2=resta2Pi(angleCinetic + a2);
// Marge o ventall de direccións probables cercle2
angleDeriva2=resta2Pi(HALF_PI-a2);
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2-(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 7 )////////////////////////// CAS 7
{
///////////////////////cercle 1////////////////////////////////
angle2Cercle1=resta2Pi(PI+angleCinetic);
// Angle final de rebot cercle 1
angle3Cercle1=resta2Pi(angle1Cercle1);
// Marge o ventall de direccións probables cercle1
angleDeriva1=resta2Pi( angle3Cercle1 - angle2Cercle1) ;
// Direcció definitiva del cercle 1
angleRebot1=resta2Pi(angle2Cercle1+(proporcio *angleDeriva1/100));
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
a2=PI+ HALF_PI-angle1Cercle2+angleCinetic;
angle2Cercle2=resta2Pi(PI+ HALF_PI+angleCinetic);
// Angle final del rebot Cercle 2
angle3Cercle2=resta2Pi(angle2Cercle2 + a2);
// Marge o ventall de direccións probables cercle2
angleDeriva2=resta2Pi(a2);
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2+(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 8 )///////////////////////// CAS 8
{
///////////////////////cercle 1////////////////////////////////
a1=PI-angle1Cercle1+angleCinetic;
angle2Cercle1=resta2Pi(PI+angleCinetic);
// Angle final de rebot cercle 1
angle3Cercle1=angle1Cercle1;
// Marge o ventall de direccións probables cercle1
angleDeriva1=resta2Pi(a1) ;
// Direcció definitiva del cercle 1
angleRebot1=resta2Pi(angle2Cercle1-(proporcio *angleDeriva1/100)) ;
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
a2=PI-angle1Cercle2+angleCinetic;
angle2Cercle2=resta2Pi(HALF_PI+angleCinetic);
// Angle final del rebot Cercle 2
angle3Cercle2=resta2Pi(angleCinetic + a2);
// Marge o ventall de direccións probables cercle2
angleDeriva2=resta2Pi(HALF_PI-a2);
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2-(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 9)/////////////////////// CAS 9
{
///////////////////////cercle 1////////////////////////////////
angle2Cercle1=angle1Cercle2;/// OK
// Angle final de rebot cercle 1
angle3Cercle1=angle1Cercle1;
// Marge o ventall de direccións probables cercle1
angleDeriva1=resta2Pi(angle2Cercle1 - angle3Cercle1) ;
// Direcció definitiva del cercle 1
angleRebot1=resta2Pi(angle2Cercle1-(proporcio *angleDeriva1/100)) ;
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
angle2Cercle2=angle1Cercle1 ;
// Angle final del rebot Cercle 2
angle3Cercle2=angleCinetic;
// Marge o ventall de direccións probables cercle2
angleDeriva2=resta2Pi(angle2Cercle2 -angleCinetic) ;
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2-(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 10)////////////////////// CAS 10
{
///////////////////////cercle 1////////////////////////////////
angle2Cercle1=angle1Cercle2 ;
// Angle final de rebot cercle 1
angle3Cercle1=angle1Cercle1;
// Marge o ventall de direccións probables cercle1
angleDeriva1=resta2Pi(angle2Cercle1 - angle3Cercle1) ;
// Direcció definitiva del cercle 1
angleRebot1=resta2Pi(angle2Cercle1-(proporcio *angleDeriva1/100)) ;
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
angle2Cercle2=angle1Cercle1 ;
// Angle final del rebot Cercle 2
angle3Cercle2=angleCinetic;
// Marge o ventall de direccións probables cercle2
angleDeriva2=resta2Pi(angle2Cercle2 -angleCinetic) ;
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2-(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 11)////////////////////// CAS 11
{
///////////////////////cercle 1////////////////////////////////
// Angle inicial de rebot cercle1
a1=TWO_PI-angle1Cercle1+angleCinetic;
angle2Cercle1=angle1Cercle1+PI+angleCinetic;
// Angle final de rebot cercle 1
angle3Cercle1=angle1Cercle1 ;
// Marge o ventall de direccións probables cercle1
angleDeriva1=angle3Cercle1-angle2Cercle1;
// Direcció definitiva del cercle 1
angleRebot1=angle2Cercle1+(proporcio *angleDeriva1/100);
///////////////////////cercle 2////////////////////////////////
// Angle inicial de rebot cercle2
angle2Cercle2=angle1Cercle2;
// Angle final del rebot Cercle 2
angle3Cercle2=angleCinetic;
// Marge o ventall de direccións probables cercle2
angleDeriva2=angle3Cercle2 - angle2Cercle2;
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2+(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 12)////////////////////// CAS 12
{
///////////////////////cercle 1//////////////////////////////// */
// Angle inicial de rebot cercle1
a1=HALF_PI-angle1Cercle1+angleCinetic;
angle2Cercle1=HALF_PI+a1+angleCinetic;
// Angle final de rebot cercle 1
angle3Cercle1=angle1Cercle1 ;
// Marge o ventall de direccións probables cercle1
angleDeriva1=angle3Cercle1-angle2Cercle1;
// Direcció definitiva del cercle 1
angleRebot1=angle2Cercle1+(proporcio*angleDeriva1/100);
///////////////////////cercle 2//////////////////////////////// */
// Angle inicial de rebot cercle2
angle2Cercle2=angle1Cercle2;
// Angle final del rebot Cercle 2
angle3Cercle2=angleCinetic;
// Marge o ventall de direccións probables cercle2
angleDeriva2=angle3Cercle2 - angle2Cercle2;
// Direcció definitiva del cercle 2
angleRebot2=resta2Pi(angle2Cercle2+(proporcio *angleDeriva2/100));
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 13)////////////////////// CAS 13
{
///////////////////////cercle 1////////////////////////////////
// Angle inicial de rebot cercle1
a1=TWO_PI-angle1Cercle1+angleCinetic;
angle2Cercle1=angle1Cercle1-HALF_PI;
// Marge o ventall de direccións probables cercle1
angleDeriva1=angle1Cercle1-angle2Cercle1;
// Direcció definitiva del cercle 1
angleRebot1=angle2Cercle1+(proporcio *angleDeriva1/100);
///////////////////////cercle 2////////////////////////////////
// Direcció definitiva del cercle 2
angleRebot2=angleCinetic ;
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
else if(casC == 14)////////////////////// CAS 14
{
///////////////////////cercle 1////////////////////////////////
// Angle inicial de rebot cercle1
a1=HALF_PI-angle1Cercle2+angleCinetic ;
angle2Cercle1=resta2Pi(HALF_PI + angleCinetic + a1 );
// Angle final de rebot cercle 1
angle3Cercle1=resta2Pi(angle1Cercle1);
// Marge o ventall de direccións probables cercle1
angleDeriva1=resta2Pi(abs(angle2Cercle1-angle1Cercle1));
// Direcció definitiva del cercle 1
angleRebot1=resta2Pi(angle2Cercle1+(proporcio *angleDeriva1/100)) ;
// Direcció definitiva del cercle 2
angleRebot2=angleCinetic ;
////////////////////////comuns////////////////////////////////////
// S'adjudica l'angle de rebot a cada cercle
// Cercle[i].angleRebot; Cercle[j].angleRebot
angleRebot(i,j,angleRebot1,angleRebot2);
// Energia cinètica per cada component x i y
eCinetica(i,j);
// Velocitats dels cercles
velocitats(i,j);
}
//Es porten els cercles a la posició previa a la col·lisió
Cercle[j].centrePrevi();
Cercle[i].centrePrevi();
fill(255);
rect(1, 298, 500, 550 );
fill(0);
text("tipus de xoc = "+ casC,5,310);
text("Cercle[ "+ j +" ].angleRebot = "+Cercle[j].angleRebot,5,320);
text("Cercle[ "+ i +" ].angleRebot = "+Cercle[i].angleRebot,5,330);
text("angleCinetic = "+angleCinetic,5,340);
text("Cercle[ "+ j +" ].eCinetica_x = "+Cercle[j].eCinetica_x ,5,350);
text("Cercle[ "+ j +" ].eCinetica_y = "+Cercle[j].eCinetica_y ,5,360);
text("Cercle[ "+ i +" ].eCinetica_x = "+Cercle[i].eCinetica_x ,5,370);
text("Cercle[ "+ i +" ].eCinetica_y = "+Cercle[i].eCinetica_y ,5,380);
text("Cercle[ "+ j +" ].velocitat_x = "+Cercle[j].velocitat_x ,5,390);
text("Cercle[ "+ j +" ].velocitat_y = "+Cercle[j].velocitat_y ,5,400);
text("Cercle[ "+ i +" ].velocitat_x = "+Cercle[i].velocitat_x ,5,410);
text("Cercle[ "+ i +" ].velocitat_y = "+Cercle[i].velocitat_y ,5,420);
text("quadrants angle rebot "+ j + " = "+
cuadrantsAngle(Cercle[j].angleRebot),5,430);
text("quadrants angle rebot "+ i + " = "+
cuadrantsAngle(Cercle[i].angleRebot),5,440);
text("qadrants angle cinetic = "+ cuadrantsAngle(angleCinetic),5,450);
text("quadrants angle1Cercle1 = "
+ cuadrantsAngle(restaAngleCinetic(angle1Cercle1 ,angleCinetic)) ,5,460);
text("quadrants angle1Cercle2 = "
+ cuadrantsAngle(restaAngleCinetic(angle1Cercle2, angleCinetic)) ,5,470);
//exit();
} //Metode calculaColisio()
//////////////////// METODE ANGLE ///////////////////////
//// Determinació del angle entre dos punts de una fletxa.
//// Es tetermina en sentit anti horari des de la horitzontal
void angle(float x1, float y1, float x2, float y2)
{
float angle;
if(x1 <= x2 && y1 < y2)//4Q https://docs.google.com/open?id=0Bwne143nlGwRYjZlYzhkY2MtYTY2OC00NTEwLTgzYjMtMjQ3MWJlOGViZjIy
angle= atan((x2-x1)/(y2-y1))+ HALF_PI + PI;
else if(x1 < x2 && y2 <= y1)//1Qhttps://docs.google.com/open?id=0Bwne143nlGwRMTEwOThkNDctOThkOC00MjczLTg4ODUtMmM3NWMyNmFhZTk0
angle= atan((y1-y2)/(x2-x1));
else if(x2 <= x1 && y1 > y2)//2Qhttps://docs.google.com/open?id=0Bwne143nlGwRZjYzNGY1MGMtNjJjYS00NGQ4LWFjYTgtMmIwNDcxYjZlZjUw
angle= atan((x1-x2)/(y1-y2))+ HALF_PI ;
else if(x1 > x2 && y1 <= y2)//3Qhttps://docs.google.com/open?id=0Bwne143nlGwRMWE5MDc2YzMtN2NlYS00Y2JiLWJhNzktZWQzNDU4ZjgxYmJj
angle= atan((y2-y1)/(x1-x2))+ PI;
return angle;
}// Mètode angle
//////////////////// METODE VELOCITATS ///////////////////////
void velocitats(int i, int j)
{
if(Cercle[i].eCinetica_x < 0)
{
Cercle[i].eCinetica_x *=-1;
Cercle[i].velocitat_x=sqrt(Cercle[i].eCinetica_x/(HALF_PI*sq(Cercle[i].diamCercle/2)));
Cercle[i].velocitat_x *=-1;
}
else Cercle[i].velocitat_x=sqrt(Cercle[i].eCinetica_x/(HALF_PI*sq(Cercle[i].diamCercle/2)));
///***********************************
if(Cercle[i].eCinetica_y < 0)
{
Cercle[i].eCinetica_y *=-1;
Cercle[i].velocitat_y=sqrt(Cercle[i].eCinetica_y/(HALF_PI*sq(Cercle[i].diamCercle/2)));
Cercle[i].velocitat_y *=-1;
}
else Cercle[i].velocitat_y=sqrt(Cercle[i].eCinetica_y/(HALF_PI*sq(Cercle[i].diamCercle/2)));
///***********************************
if(Cercle[j].eCinetica_x < 0)
{
Cercle[j].eCinetica_x *=-1;
Cercle[j].velocitat_x=sqrt(Cercle[j].eCinetica_x/(HALF_PI*sq(Cercle[j].diamCercle/2)));
Cercle[j].velocitat_x *=-1;
}
else Cercle[j].velocitat_x=sqrt(Cercle[j].eCinetica_x/(HALF_PI*sq(Cercle[j].diamCercle/2)));
///***********************************
if(Cercle[j].eCinetica_y < 0)
{
Cercle[j].eCinetica_y *=-1;
Cercle[j].velocitat_y=sqrt(Cercle[j].eCinetica_y/(HALF_PI*sq(Cercle[j].diamCercle/2)));
Cercle[j].velocitat_y *=-1;
}
else Cercle[j].velocitat_y=sqrt(Cercle[j].eCinetica_y/(HALF_PI*sq(Cercle[j].diamCercle/2)));
}// Metode velocitats()
//////////////////// METODE ENERGIA CINETICA ///////////////////////
//// Es reparteix l'energia cinetica per cada component segons langle de rebot
void eCinetica(int i, int j)
{
//if(cuadrantsAngle(restaAngleCinetic(Cercle[i].angleRebot, angleCinetic)) == 4)
if(cuadrantsAngle(Cercle[i].angleRebot) == 4)
{
Cercle[i].eCinetica_x=abs(sin(Cercle[i].angleRebot - HALF_PI - PI))
*Cercle[i].eCinetica;
Cercle[i].eCinetica_y=abs(cos(Cercle[i].angleRebot - HALF_PI - PI))
*Cercle[i].eCinetica;
}
else if(cuadrantsAngle(Cercle[i].angleRebot) == 3)
{
Cercle[i].eCinetica_x=abs(cos(Cercle[i].angleRebot - PI))*(-1)
*Cercle[i].eCinetica;
Cercle[i].eCinetica_y=abs(sin(Cercle[i].angleRebot - PI))
*Cercle[i].eCinetica;
}
else if(cuadrantsAngle(Cercle[i].angleRebot) == 2)
{
Cercle[i].eCinetica_x=abs(sin(Cercle[i].angleRebot - HALF_PI))*(-1)
*Cercle[i].eCinetica;
Cercle[i].eCinetica_y=abs(cos(Cercle[i].angleRebot - HALF_PI))*(-1)
*Cercle[i].eCinetica;
}
else if(cuadrantsAngle(Cercle[i].angleRebot) == 1)
{
Cercle[i].eCinetica_x=abs(cos(Cercle[i].angleRebot))
*Cercle[i].eCinetica;
Cercle[i].eCinetica_y=abs(sin(Cercle[i].angleRebot))*(-1)
*Cercle[i].eCinetica;
}
///////////////////////////////////////////////////////////////////////
if(cuadrantsAngle(Cercle[j].angleRebottic) == 4)
{
Cercle[j].eCinetica_x=abs(sin(Cercle[j].angleRebot - HALF_PI - PI))
*Cercle[j].eCinetica;
Cercle[j].eCinetica_y=abs(cos(Cercle[j].angleRebot - HALF_PI - PI))
*Cercle[j].eCinetica;
}
else if(cuadrantsAngle(Cercle[j].angleRebot) == 3)
{
Cercle[j].eCinetica_x=abs(cos(Cercle[j].angleRebot - PI))*(-1)
*Cercle[j].eCinetica;
Cercle[j].eCinetica_y=abs(sin(Cercle[j].angleRebot - PI))
*Cercle[j].eCinetica;
}
else if(cuadrantsAngle(Cercle[j].angleRebot) == 2)
{
Cercle[j].eCinetica_x=abs(sin(Cercle[j].angleRebot - HALF_PI))*(-1)
*Cercle[j].eCinetica;
Cercle[j].eCinetica_y=abs(cos(Cercle[j].angleRebot - HALF_PI))*(-1)
*Cercle[j].eCinetica;
}
else if(cuadrantsAngle(Cercle[j].angleRebot) == 1)
{
Cercle[j].eCinetica_x=abs(cos(Cercle[j].angleRebot ))
*Cercle[j].eCinetica;
Cercle[j].eCinetica_y=abs(sin(Cercle[j].angleRebot ))*(-1)
*Cercle[j].eCinetica;
}
}// Metode eCinetica()
//////////////////// METODE CAS CINETIC ///////////////////////
//// Determinació del cas cinetic o de col·lisió.
void casCinetic(float p1Cercle1_x, float p1Cercle1_y,
float p2Cercle1_x, float p2Cercle1_y,
float p1Cinetic_x, float p1Cinetic_y,
float p2Cinetic_x, float p2Cinetic_y,
float p1Cercle2_x, float p1Cercle2_y,
float p2Cercle2_x, float p2Cercle2_y
)
{
float cuadrantsAngleCinetic;
float cuadrantsAngleCercle1;
float cuadrantsAngleCercle2;
int cas;
////////////////////// CRIDA ANGLE angleCinetic ////////////////////
// Direcció de la energia cinetica
angleCinetic=angle(p1Cinetic_x, p1Cinetic_y, p2Cinetic_x, p2Cinetic_y);
cuadrantsAngleCinetic =cuadrantsAngle(angleCinetic);
////////////////////// CRIDA ANGLE angle1Cercle1 ////////////////////
// Direcció del cercle amb mes energia cinetica
angle1Cercle1=angle(p1Cercle1_x, p1Cercle1_y, p2Cercle1_x, p2Cercle1_y);
cuadrantsAngleCercle1=cuadrantsAngle(restaAngleCinetic(angle1Cercle1,angleCinetic));
////////////////////// CRIDA ANGLE angle1Cercle2 ////////////////////
// Direcció del cercle amb menys energia cinetica
angle1Cercle2=angle(p1Cercle2_x, p1Cercle2_y, p2Cercle2_x, p2Cercle2_y);
if(angle1Cercle2 == 0)cuadrantsAngleCercle2=0;
else cuadrantsAngleCercle2=cuadrantsAngle(restaAngleCinetic(angle1Cercle2,angleCinetic));
//En aquest enllaç es poden veure els possibles casos de rebot de dos cercles
//https://docs.google.com/open?id=0Bwne143nlGwRMjlkODRkMjctYTI2My00YTIxLWFmNzgtZjc0MjhkNzY3Mzkz
// Determinacio del cas cinetit //
if(cuadrantsAngleCercle1 == 4 && cuadrantsAngleCercle2 == 3 )cas=1;
else if(cuadrantsAngleCercle1 == 1 && cuadrantsAngleCercle2 == 2 )cas=2;
else if(cuadrantsAngleCercle1 == 4 && cuadrantsAngleCercle2 == 2 )cas=3;
else if(cuadrantsAngleCercle1 == 1 && cuadrantsAngleCercle2 == 3 )cas=4;
else if(cuadrantsAngleCercle1 == 2 && cuadrantsAngleCercle2 == 3 )cas=5;
else if(cuadrantsAngleCercle1 == 3 && cuadrantsAngleCercle2 == 2 )cas=6;
else if(cuadrantsAngleCercle1 == 3 && cuadrantsAngleCercle2 == 3 )cas=7;
else if(cuadrantsAngleCercle1 == 2 && cuadrantsAngleCercle2 == 2 )cas=8;
else if(cuadrantsAngleCercle1 == 1 && cuadrantsAngleCercle2 == 1 )cas=9;
else if(cuadrantsAngleCercle1 == 4 && cuadrantsAngleCercle2 == 4 )cas=10;
else if(cuadrantsAngleCercle1 == 4 && cuadrantsAngleCercle2 == 1 )cas=11;
else if(cuadrantsAngleCercle1 == 1 && cuadrantsAngleCercle2 == 4 )cas=12;
else if(cuadrantsAngleCercle1 == 4 && cuadrantsAngleCercle2 == 0 )cas=13;// El cercle 2 està inmovil
else if(cuadrantsAngleCercle1 == 1 && cuadrantsAngleCercle2 == 0 )cas=14;// El cercle 2 està inmovil
return cas;
}// Mètode casCinetic()
//////////////////// METODE RESTA ANGLE CINETIC ///////////////////////
void restaAngleCinetic(float a1 , float angC)
{
if(a1 < angC){ a1 +=TWO_PI- angC;}
else if(a1 >= angC){ a1 -=angC;}
return a1;
}//Metode restaAngleCinetic()
//////////////////// METODE RESTA PI ///////////////////////
// Vull angles positius i menors de TWO_PI
void resta2Pi(float angle)
{
int a;
a = floor(abs(angle)/TWO_PI);
if( angle >= TWO_PI)
{
angle = angle -(a*TWO_PI);
}
if( angle < 0 )
{
angle = angle +(a+1*TWO_PI);
}
return angle;
}
//////////////////// METODE ANGLE REBOT ///////////////////////
//// Assignació de l'angle de rebot calculat
void angleRebot(int i, int j, float angleRebot1, float angleRebot2)
{
if(Cercle[i].eCineticaPrevia < Cercle[j].eCineticaPrevia)
{
Cercle[j].angleRebot=angleRebot1;
Cercle[i].angleRebot=angleRebot2;
}
else
{
Cercle[i].angleRebot=angleRebot1;
Cercle[j].angleRebot=angleRebot2;
}
}// Mètode angleRebot
//////////////////// METODE QUADRANTS ANGLE ///////////////////////
void cuadrantsAngle(float angles)
{
int quads;
quads=floor(angles/HALF_PI);
return quads+1;
} // Mètode cuadrantsAngle
//////////////////// METODE DISTPUNTS ///////////////////////
//// Distancia entre dos punts o centres.
void distPunts (float X1, float Y1, float X2, float Y2)
{
return sqrt(pow(abs(X1 - X2),2) + pow(abs(Y1 - Y2),2));
}
}
/////////////////////////////////////////////////////////////////////
//////////////////// CLASSE PANTALLES ///////////////////////
/////////////////////////////////////////////////////////////////////
class Pantalles
{
int n=4;
//// Dibuix dels cercles inicials
void nouCercle()
{
for(int i=0; i<n ; i++)
{
Cercle[i]= new Cercles;
}
Cercle[0].centre_x=26;
Cercle[0].centre_y=150;
Cercle[0].diamCercle=40;
Cercle[0].velocitat_x=0;
Cercle[0].velocitat_y=0;
Cercle[0].colorR=149;
Cercle[0].colorG=24;
Cercle[0].colorB=59;
Cercle[1].centre_x=474;
Cercle[1].centre_y=150;
Cercle[1].diamCercle=40;
Cercle[1].velocitat_x=0;
Cercle[1].velocitat_y=0;
Cercle[1].colorR=220;
Cercle[1].colorG=106;
Cercle[1].colorB=39;
Cercle[2].centre_x=250;
Cercle[2].centre_y=100;
Cercle[2].diamCercle=40;
Cercle[2].velocitat_x=0;
Cercle[2].velocitat_y=0;
Cercle[2].colorR=67;
Cercle[2].colorG=34;
Cercle[2].colorB=207;
Cercle[3].centre_x=120;
Cercle[3].centre_y=80;
Cercle[3].diamCercle=90;
Cercle[3].velocitat_x=0;
Cercle[3].velocitat_y=0;
Cercle[3].colorR=148;
Cercle[3].colorG=234;
Cercle[3].colorB=125;
for(int i=0; i<n ; i++)
{
Disp[i]= new Disparador;
Disp[i].diamCercle=70;
Disp[i].velocitat_x=0;
Disp[i].velocitat_y=0;
}
} // Mètode nouCercle
//////////////////// METODE DIBUIXA ///////////////////////
//// Dibuix de la pantalla
void dibuixaPantalla()
{
strokeWeight(6);
fill(255);
//fill(233,233,158);
rect(1, 1, 498, 298);
strokeWeight(2);
line(50, 1, 50, 300);
line(450, 1, 450, 300);
for(int i=0; i<n ; i++)
{
strokeWeight(0.5);
fill(Cercle[i].colorR,Cercle[i].colorG,Cercle[i].colorB );
Cercle[i].dibuixa1(Cercle[i].centre_x,Cercle[i].centre_y
,Cercle[i].diamCercle );
line(Cercle[i].centre_x,Cercle[i].centre_y,Cercle[i].centrePrevi_x
+Cercle[i].velocitat_x*-100,Cercle[i].centrePrevi_y
+Cercle[i].velocitat_y*-100 );
}
//// S'il·lumina el cercle em presencia del ratolí */
for(int i=0; i<n ; i++)
{
if(Disp [i].intersecta_mouse_cercle(mouseX,mouseY)|| Cercle[i].intersecta_mouse_cercle(mouseX,mouseY))
{
strokeWeight(2);
fill(220)
Cercle[i].dibuixa1(Cercle[i].centre_x ,
Cercle[i].centre_y ,Cercle[i].diamCercle);
}
}
//// S'il·lumina el cercle em presencia del ratolí */
for(int i=0; i<n ; i++)
{
if(Disp[i].intersecta_mouse_cercle(mouseX,mouseY)|| Cercle[i].intersecta_mouse_cercle(mouseX,mouseY))
{
if(Cercle[i].centre_x >50 && Cercle[i].centre_x <450 )
{
line(Cercle[i].centre_x,Cercle[i].centre_y,Cercle[i].centrePrevi_x
+Cercle[i].velocitat_x*-100,Cercle[i].centrePrevi_y+Cercle[i].velocitat_y*-100 );
strokeWeight(0.3);
line(Cercle[i].centre_x,Cercle[i].centre_y,mouseX,mouseY);
noFill();
Disp[i].dibuixa1(Cercle[i].centre_x ,
Cercle[i].centre_y ,Disp[i].diamCercle);
}
}
}
//// Es fa creixer el cercle si està a l'esquerra clicat pel ratoli */
for(int i=0; i<n ; i++)
{
if(Cercle[i].intersecta_mouse_cercle(mouseX,mouseY)
&& mouseX < 50 && mousePressed)
{
strokeWeight(2);
fill(200)
Cercle[i].dibuixa1 (Cercle[i].centre_x ,
Cercle[i].centre_y ,Cercle[i].diamCercle+0.1);
}
}
//// Es fa decreixer el cercle si està a la dreta clicat pel ratoli */
for(int i=0; i<n ; i++)
{
if(Cercle[i].intersecta_mouse_cercle(mouseX,mouseY)
&& mouseX > 450 && mousePressed)
{
strokeWeight(2);
fill(200)
Cercle[i].dibuixa1 (Cercle[i].centre_x ,
Cercle[i].centre_y ,Cercle[i].diamCercle-0.1);
}
}
} // Mètode dibuixa
//////////////////// METODE DISTPUNTS ///////////////////////
//// Distancia entre dos punts o centres.
void distPunts (float X1, float Y1, float X2, float Y2)
{
return sqrt(pow(abs(X1 - X2),2) + pow(abs(Y1 - Y2),2));
}
//////////////////// METODE PUNTS PREVIS */
void puntsPrevis()
{
for(int i=0; i<n ; i++)
{
Cercle[i].centrePrevi_x=Cercle[i].centre_x ;
Cercle[i].centrePrevi_y=Cercle[i].centre_y ;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////// METODE CALCULA PANTALLA */
//// Métode principal de calcul de col·lisions
void calculaPantalla()
{
//// S'accelera el cercle amb el ratolí */
for(int i=0; i<n ; i++)
{
if(Disp[i].intersecta_mouse_cercle(mouseX,mouseY)
&& mousePressed && mouseX > 50 && mouseX < 450)
{
Cercle[i].velocitat_x=(Disp[i].centre_x-mouseX)*0.05;
Cercle[i].velocitat_y=(Disp[i].centre_y-mouseY)*0.05;
}
}
//// Es comprova col·lisió del cercle amb els limits de la pantalla
for(int i=0; i<n ; i++)
{
Cercle[i].intersecta_cercle_pantalla (Cercle[i].centre_x,Cercle[i].centre_y );
}
// COMPROVACIO DE COL·LISIONS ENTRE CERCLES
//// Es comprova si hi ha col·lisió entre cercles.
for(int i=0; i<n-1 ; i++)
{
for(int j=i+1; j<n ; j++)
{ /// Si no hi ha col·lisió false
if(distPunts(Cercle[i].centre_x,Cercle[i].centre_y,
Cercle[j].centre_x,Cercle[j].centre_y)>(Cercle[i].diamCercle
+Cercle[j].diamCercle)/2)
{
Colisio[i,j]= new Colisions;
Colisio[i,j].colisio=false;
}
/// Si no hi ha col·lisió entra
if(distPunts(Cercle[i].centre_x,Cercle[i].centre_y,
Cercle[j].centre_x,Cercle[j].centre_y)<(Cercle[i].diamCercle
+Cercle[j].diamCercle)/2 && Colisio[i,j].colisio == false)
{
//puntsPrevis();
// S'assigna condició de col·lissió amb true
Colisio[i,j].colisio = true;
Colisio[i,j].colisions =Colisio[i,j].colisions+1;
// Es calcula la col·lissió
if(Colisio[i,j].retard==0)
{
//Colisio[i,j].colisions =Colisio[i,j].colisions+1;
Colisio[i,j].calculaColisio(i,j);
Colisio[i,j].retard=100000000000000000000;
}
else Colisio[i,j].retard -=1;
}//if Comprovació de colisions
}//for(int j=i+1; j<4 ; j++)
}//for(int i=0; i<3 ; i++)
}/// Metode calcula()
}/// Classe Pantalles
/////////////////////////////////////////////////////////////////////
//////////////////// NETODE SETUP ///////////////////////
/////////////////////////////////////////////////////////////////////
void setup()
{
size(500,570);
//size(500, 301);
fill(255);
rect(1, 298, 500, 550 );
Pant.nouCercle();
}
/////////////////////////////////////////////////////////////////////
//////////////////// METODE DRAW ///////////////////////
/////////////////////////////////////////////////////////////////////
void draw()
{
Pant.puntsPrevis();
Pant.dibuixaPantalla();
Pant.calculaPantalla();
}
/////////////////////////////////////////////////////////////////////
//////////////////// EVENTS ///////////////////////
/////////////////////////////////////////////////////////////////////
//// Comprovació d'arrossegament d'un cercle amb el ratolí
void mouseDragged()
{
//Pant.dibuixa();
for(int i=0; i<4 ; i++)
{
if(Cercle[i].intersecta_mouse_cercle(mouseX ,mouseY ))
{
Cercle[i].dibuixa1(mouseX ,mouseY ,Cercle[i].diamCercle );
}
}
}// Event mouseDragged
/*///////////////////// REPARTIMENT D'ENERGIA CINETICA //////////////////
// El cercle 1 en perdrà, el cercle 2 en guanyarà
if(casC == 1 || casC == 2 || casC == 3 || casC == 4 || casC == 9 || casC == 10
|| casC == 11 || casC == 12 || casC == 13 || casC == 14)
{
if(Cercle[j].eCinetica > Cercle[i].eCinetica )
{
Cercle[j].eCinetica -= Cercle[j].eCinetica/proporcio;
Cercle[i].eCinetica += Cercle[i].eCinetica/proporcio;
}
else if(Cercle[j].eCinetica < Cercle[i].eCinetica )
{
Cercle[j].eCinetica += Cercle[j].eCinetica/proporcio;
Cercle[i].eCinetica -= Cercle[i].eCinetica/proporcio;
}
}
// El cercle 1 en guanyarà, el cercle 2 en perdrà
if(casC == 5 || casC == 6 || casC == 7 || casC == 8)
{
if(Cercle[j].eCinetica > Cercle[i].eCinetica )
{
Cercle[j].eCinetica += Cercle[j].eCinetica/proporcio;
Cercle[i].eCinetica -= Cercle[i].eCinetica/proporcio;
}
else if(Cercle[j].eCinetica < Cercle[i].eCinetica )
{
Cercle[j].eCinetica -= Cercle[j].eCinetica/proporcio;
Cercle[i].eCinetica += Cercle[i].eCinetica/proporcio;
}
}*/