• fullscreen
• Ball.pde
• VectorTools.pde
• vBall.pde
• ```class Ball {

PVector loc;
PVector vel;
PVector acc;

color c;
float bounce = 0.8;

boolean colliding = false;

PFont f = createFont("Arial",10,true);

Ball(float setX, float setY, color setColor, int setRadio ){

loc = new PVector(setX,setY);
vel = new PVector(random(-2,2),random(-2,0));
acc = new PVector(1,2);

c = setColor;
}

void applyForce(PVector force){
}

void go(){
update();
bordes();
render();
}

void update(){
acc.mult(0);
}

void bordes(){
if (loc.y + radio >= height){
vel.y *= -bounce;
}

if (loc.y - radio <= 0) {
vel.y *= -bounce;
}

vel.x *= -bounce;
}

if (loc.x - radio <= 0){
vel.x *= -bounce;
}
}

PVector calcGravForce(Ball b){
PVector dir = PVector.sub(loc,b.loc);
float d = dir.mag();
//d = constrain(d,5.0,25.0);
dir.normalize();
float force = (9.8 * radio * b.radio) / (d * d);
dir.mult(force);
return dir;
}

void collideEqualMass(Ball b) {
float d = PVector.dist(loc,b.loc);
// Are they colliding?
if (!colliding && d < sumR) {
// Yes, make new velocities!
colliding = true;
// Direction of one object to another
PVector n = PVector.sub(b.loc,loc);
n.normalize();

// Difference of velocities so that we think of one object as stationary
PVector u = PVector.sub(vel,b.vel);

// Separate out components -- one in direction of normal
PVector un = componentVector(u,n);
// Other component
u.sub(un);
// These are the new velocities plus the velocity of the object we consider as stastionary
} else if (d > sumR) {
colliding = false;
}
}

void render(){
fill(c);
noStroke();

if (showVectors) {
drawVector(vel,loc,10);
drawVector(G,loc,100);
}

if (showPosition) {
textFont(f,8);
fill(255,0,0,127);
text("("+ int(loc.x) + "," + int(loc.y) + ")",loc.x + radio, loc.y + radio);
}
}

}

```
```void drawVector(PVector v, PVector loc, float scayl) {
pushMatrix();
float arrowsize = 4;
// Translate to location to render vector
translate(loc.x,loc.y);
stroke(0);
// Call vector heading function to get direction (note that pointing up is a heading of 0) and rotate
// Calculate length of vector & scale it to be bigger or smaller if necessary
float len = v.mag()*scayl;
// Draw three lines to make an arrow (draw pointing up since we've rotate to the proper direction)
line(0,0,len,0);
line(len,0,len-arrowsize,+arrowsize/2);
line(len,0,len-arrowsize,-arrowsize/2);
popMatrix();
}

PVector componentVector (PVector vector, PVector directionVector) {
//--! ARGUMENTS: vector, directionVector (2D vectors)
//--! RETURNS: the component vector of vector in the direction directionVector
//-- normalize directionVector
directionVector.normalize();
directionVector.mult(vector.dot(directionVector));
return directionVector;
}
```
```//import lll.Loc.*;
//import lll.wrj4P5.*;
//Wrj4P5 wii;

Ball balls[] = new Ball[1];

boolean showVectors = true;
boolean showPosition = false;

PVector G;

void setup(){
size(400, 400,P3D);
//smooth();

//wii=new Wrj4P5(this);
//wii.connect();

balls[0] = new Ball(random(0,190), random(0,190),color(random(0,255),random(0,255),random(0,255)),int(random(10,30)));
}

void draw(){
background(255);

for(int i = 0; i < balls.length ; i++){
for(int a = 0; a < balls.length; a++){
if(a != i){
//PVector f = balls[i].calcGravForce(balls[a]);  // Use the function we wrote above
//balls[i].applyForce(f);
balls[i].collideEqualMass(balls[a]);
}
}
//G = new PVector(0,9.8);
G = new PVector(mouseX - width/2,mouseY - height/2);
//G = new PVector(wii.rimokon.sensed.x,wii.rimokon.sensed.y);
G.normalize();

balls[i].applyForce(G);
balls[i].go();
}
}

void mousePressed(){
Ball b = new Ball(mouseX,mouseY,color(random(0,255),random(0,255),random(0,255)),int(random(10,30)) );
balls = (Ball[]) append(balls,b);
}

void keyPressed() {
showVectors = !showVectors;
}
```

### tweaks (0)

This sketch is running as Java applet, exported from Processing.

Report Sketch

Report for inappropriate content

Your have successfully reported the sketch. Thank you very much for helping to keep OpenProcessing clean and tidy :)