vormen overlappen, diameter varrieert met ster class       terug naar de inleiding
 
De boolean methode overlappen (regel 21) wordt in de schets gebruikt in regels 50 en 54
groenRechts.overlappen(rood)); is true als vorm groenRects de vorm rood gaat overlappen.

De rode cirkel wordt dan geel en er verschijnt een rode ster.

 
De schets:
 
 


DiamVar rood;   
DiamVar groen;  
DiamVar blauwvierkant;  
DiamVar groenLinks;  
DiamVar groenRechts;  
Ster ster;  
Ster sterLi; 
 
void setup() {   
 // size(960, 540); 
  fullScreen();  
  float x = width/2;  
  float y =height/2;  
  float n = height/10;  
 
 //argumenten van de constructor: 1) x positie, 2) y positie, 3) kleinste diameter  
 //4) grootste diameter, 5) snelheid 6) color  
  
 //constructor            1         2    3       4    5           6    
 rood =       new DiamVar(x,        y,   n,     4*n,  4.0, color(255, 20, 20, 100));   
 groen =      new DiamVar(x,        y,   3.5*n, 10*n, 2, color(0, 255, 50, 100));   
 groenLinks = new DiamVar(x-4.5*n,  y,   n,     7*n,  1.0, color(0, 200, 20, 100));   
 groenRechts = new DiamVar(x+4.5*n, y,   n,     4.5*n,0.5, color(25, 255, 20, 100)); 
 blauwvierkant = new DiamVar(x,     y,   3.5*n, 7*n,  0.5, color(23,229,228,100));  
 
//argumenten ster constructor 1) x positie, 2) y positie, 3) binnenstraal,   
//4) buitenstraal, 5) aantal punten 6) color  
 
//constructor      1,       2,       3,     4,    5,         6 
 ster = new   Ster(x,       y,       0.1*n, 4*n,  8,  color(255, 0, 0));  
 sterLi = new Ster(x-4.5*n, y-2.5*n, 0.3*n, 4*n,  10, color(180, 23, 229, 100));  
}
 
void draw() {   
  background(#E6FBFF); 
  rood.cirkel();   
  rood.kleinGroot();  
  rood.snelhxy();    
  
  groen.cirkel();   
  groen.kleinGroot(); 
  groenLinks.cirkel();   
  groenLinks.kleinGroot(); 
  
  groenRechts.cirkel();   
  groenRechts.kleinGroot(); 
   
if (groenRechts.overlappen(rood)) {  
    rood.c = color(255, 255, 0, 100);  
    ster.display();  
 }   
 if (groenLinks.overlappen(rood)) {  
    rood.c = color(255, 20, 20, 100);  
    blauwvierkant.vierkant();  
    blauwvierkant.kleinGroot();  
    sterLi.display();  
 }  
} 
 
void keyPressed() {   
 if (key == 's') {   
 noLoop();  
 }   
 if (key == 'r') {   
 loop();  
 }  
}
 
De class DiamVar bevat de vormen "cirkel" en "vierkant" die in grootte varrieren, de boolean die true wordt als de
cirkels elkaar raken en de bewegingmethodes
 
 

class DiamVar {  
 float x;  
 float y;  
 float beginvar; 
 float groot;  
 float xsnelh = 1; 
 float ysnelh = 1; 
 float snelh; 
 float begin; 
 color c;
DiamVar(float x_, float y_, float beginvar_, float groot_, float snelh_, color c_) {  
 x = x_;  
 y = y_;  
 beginvar = beginvar_;  
 groot = groot_; 
 snelh = snelh_; 
 c = c_;
begin = beginvar; 
 }
boolean overlappen(DiamVar met) {  
 float d = dist (x, y, met.x, met.y) ;  
 //d is de afstand tussen de middelpunten van de cirkels 
 if (d < beginvar/2 + met.beginvar/2) {  
 // beginvar en met.beginvar zijn de diameters van de cirkels 
 return true; 
 } else { 
 return false; 
 } 
 }
void cirkel() { 
 fill(c);  
 ellipse(x, y, beginvar, beginvar); 
 }
void vierkant() {  
 rectMode(CENTER);  
 fill(c);  
 rect(x, y, beginvar, beginvar,20); 
 }
void kleinGroot() { 
 beginvar = beginvar + snelh; 
 if ((beginvar > groot) || (beginvar < begin)) 
 { 
 snelh = snelh * -1; 
 } 
 }
void snelhxy() {  
 x = x + xsnelh;  
 if ((x > width) || (x < 0)) {  
 xsnelh = xsnelh * -1; 
 }  
 y = y + ysnelh;  
 if ((y > height) || (y < 0)) {  
 ysnelh = ysnelh * -1; 
 } 
 } 
}
 
class Ster { 
 float x;  
 float y;  
 float radius1; 
 float radius2; 
 int np; 
 color c;
// Constructor van de ster  
 Ster(float x_, float y_, float radius1_, float radius2_, int np_, color c_) {  
 x = x_; 
 y = y_; 
 radius1 = radius1_; 
 radius2 = radius2_; 
 c = c_; 
 np = np_; 
 }
void ster() {  
 float hoek = TWO_PI / np;  
 float halfHoek = hoek/2.0;  
 fill(c);  
 stroke(0);  
 beginShape();  
 for (float a = 0; a < TWO_PI; a += hoek) {  
 float sx = x + cos(a) * radius2;  
 float sy = y + sin(a) * radius2;  
 vertex(sx, sy);  
 sx = x + cos(a+halfHoek) * radius1;  
 sy = y + sin(a+halfHoek) * radius1;  
 vertex(sx, sy); 
 }  
 endShape(CLOSE); 
 } 
}