Processing Forum

Screen name:
ravingbullz

ravingbullz's Profile

3 Posts

2 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

trouble with colliding balls random colour for each ball

[2 Replies]
- 16-Sep-2012 01:24 AM
- Forum: Programming Questions
i need to reach this output but im having trouble with setting a random colour for each ball respectively, i had a bit of help from a cousin but he left and im having trouble understanding some of the codes because he is overseas

i have this code so far but i need to get this: http://sleepeater.net/comp115assignment3HD/applet/

int bColor = 0; //background color

int screenWL = 600; //screen width and length

int numberB = int(random(5,21)); //number of balls

int alphaB = 200; //alpha value of the ball

float v_threshold_H = 6;

float v_threshold_L = 0.5;

Ball[] ball = new Ball[numberB];

void setup()

{



size(600,600);

background(bColor,bColor,bColor);

smooth();

noStroke();

//initialize balls

for(int i=0; i<numberB; i++)

{

int dia = int(random(30,200));

ball[i] = new Ball(random(0+dia,screenWL-dia),random(0+dia,screenWL-dia),dia,random(-5,5),random(-5,5),alphaB,int(random(80,255)),int(random(80,255)),int(random(80,255)));

}

//check if balls overlap

for(int i=0; i<numberB; i++)

{

for(int j=i; j<numberB; j++)

{

if(i!=j)

{

float distance = dist(ball[i].x,ball[i].y,ball[j].x,ball[j].y);

if(distance<=(ball[i].d+ball[j].d)/2+1)

{

ball[i].d = floor(distance/2);

ball[j].d = floor(distance/2);

}

}

}

}

}

void draw()

{

//clean screen

background(255);

//collision

for(int i=0; i<numberB; i++)

{

for(int j=i; j<numberB; j++)

{

if(i!=j)

{

float distance = dist(ball[i].x,ball[i].y,ball[j].x,ball[j].y);

if(distance<=(ball[i].d+ball[j].d)/2)

{

//start vector

PVector vi_s = new PVector(ball[i].vx, ball[i].vy);

PVector vj_s = new PVector(ball[j].vx, ball[j].vy);

//calculate the unit vector between two center points

PVector c1 = new PVector(ball[j].x-ball[i].x, ball[j].y-ball[i].y);

c1.normalize();

//calculate the perpendicular vector of c1

PVector c2 = new PVector(c1.y, -1*c1.x);

//calculate the final vector after collision projected on c1

//assume the mass is in proportion to the diameter

float coef_i1 = (ball[i].d-ball[j].d)/(ball[i].d+ball[j].d);

float coef_i2 = (2*ball[j].d)/(ball[i].d+ball[j].d);

float coef_j1 = (2*ball[i].d)/(ball[i].d+ball[j].d);

float coef_j2 = (ball[j].d-ball[i].d)/(ball[i].d+ball[j].d);

PVector vi_f_c1 = new PVector(coef_i1*vi_s.dot(c1)*c1.x+coef_i2*vj_s.dot(c1)*c1.x, coef_i1*vi_s.dot(c1)*c1.y+coef_i2*vj_s.dot(c1)*c1.y);

PVector vj_f_c1 = new PVector(coef_j1*vi_s.dot(c1)*c1.x+coef_j2*vj_s.dot(c1)*c1.x, coef_j1*vi_s.dot(c1)*c1.y+coef_j2*vj_s.dot(c1)*c1.y);

//calculate the final vector after collision projected on c2

PVector vi_f_c2 = new PVector(vi_s.dot(c2)*c1.x, vi_s.dot(c2)*c1.y);

PVector vj_f_c2 = new PVector(vj_s.dot(c2)*c1.x, vj_s.dot(c2)*c1.y);

//calculate the final vector after collision

PVector vi_f = new PVector(vi_f_c1.x+vi_f_c2.x, vi_f_c1.y+vi_f_c2.y);

PVector vj_f = new PVector(vj_f_c1.x+vj_f_c2.x, vj_f_c1.y+vj_f_c2.y);

//adjust velocity according to thresholds

if(vi_f.x>v_threshold_H) vi_f.x=v_threshold_H;

else if(vi_f.x<v_threshold_H*-1) vi_f.x=v_threshold_H*-1;

if(vi_f.y>v_threshold_H) vi_f.y=v_threshold_H;

else if(vi_f.y<v_threshold_H*-1) vi_f.y=v_threshold_H*-1;

if(vj_f.x>v_threshold_H) vj_f.x=v_threshold_H;

else if(vj_f.x<v_threshold_H*-1) vj_f.x=v_threshold_H*-1;

if(vj_f.y>v_threshold_H) vj_f.y=v_threshold_H;

else if(vj_f.y<v_threshold_H*-1) vj_f.y=v_threshold_H*-1;

if(vi_f.x<v_threshold_L && vi_f.x>0) vi_f.x=v_threshold_L;

else if(vi_f.x>v_threshold_L*-1 && vi_f.x<0) vi_f.x=v_threshold_L*-1;

if(vi_f.y<v_threshold_L && vi_f.y>0) vi_f.y=v_threshold_L;

else if(vi_f.y>v_threshold_L*-1 && vi_f.y<0) vi_f.y=v_threshold_L*-1;

if(vj_f.x<v_threshold_L && vj_f.x>0) vj_f.x=v_threshold_L;

else if(vj_f.x>v_threshold_L*-1 && vj_f.x<0) vj_f.x=v_threshold_L*-1;

if(vj_f.y<v_threshold_L && vj_f.y>0) vj_f.y=v_threshold_L;

else if(vj_f.y>v_threshold_L*-1 && vj_f.y<0) vj_f.y=v_threshold_L*-1;

//update the velocity

ball[i].vx = vi_f.x;

ball[i].vy = vi_f.y;

ball[j].vx = vj_f.x;

ball[j].vy = vj_f.y;

//pull out the balls to avoid overlaping

float pullMag = abs(distance-(ball[i].d+ball[j].d)/2);

ball[i].x -= pullMag*c1.x;

ball[i].y -= pullMag*c1.y;

ball[j].x += pullMag*c1.y;

ball[j].y += pullMag*c1.y;

}

}

}

}

//balls

for(int i=0; i<numberB; i++)

{

//reset

//reach boundary

float nextX = ball[i].x+(ball[i].vx/abs(ball[i].vx))*ball[i].d/2;

float nextY = ball[i].y+(ball[i].vy/abs(ball[i].vy))*ball[i].d/2;

if(nextX>=screenWL || nextX<=0) ball[i].vx *= -1;

if(nextY>=screenWL || nextY<=0) ball[i].vy *= -1;

//update

ball[i].x += ball[i].vx;

ball[i].y += ball[i].vy;

//render

fill(ball[i].r,ball[i].g,ball[i].b,ball[i].a);

ellipse(ball[i].x,ball[i].y,ball[i].d,ball[i].d);

}

}

Circles colliding with each other and off walls.

[2 Replies]
- 13-Sep-2012 09:40 PM
- Forum: Programming Questions
I have this assignment and i am really struggling with, i understand what to do but i cant implement the code because the teacher didnt explain classes, methods and arrays well so all i did was read the textbook but i still struggle immensly.

i need to make this
http://sleepeater.net/comp115assignment3HD/applet/

using: classes, methods and arrays.

Each ball has the following characteristics –

diameter (between 20 and 80 pixels)

color (random)

location (random, but such that the entire ball is within the window)

speed in x and y directions (each speed component is a random value

between 0.1 and 2.0)

additionally for fading, it has –

opacity and

speed of fading

The number of balls that are generated are between 5 and 20.

(16%) Using collideWith(Ball other) method to implement collision between Balls.

i know i can't really do this but i need urgent help guys, and i would honestly appreciate it because i dont want to fail this hard course, i need it to graduate, thankyou heaps.

Need urgent help with a code.

[3 Replies]
- 11-Sep-2012 07:26 PM
- Forum: Programming Questions
I need to implement this code:
several balls moving around the display window and rebounding off the edge. For higher grades, you are required to add the following functionalities –

Fading of the balls while moving

Ensure that, at the time of generation, none of the balls overlap

Utilize collideWith(Ball other) method provided to implement

collision of balls with each other.

Please note that although you CAN implement a solution without using Classes to obtain up to 84% marks, an implementation using Classes would be much simpler and logical.

Each ball has the following characteristics –

diameter (between 20 and 80 pixels)

color (random)

location (random, but such that the entire ball is within the window)

speed in x and y directions (each speed component is a random value

between 0.1 and 2.0)

additionally for fading, it has –

opacity and

speed of fading

The number of balls that are generated are between 5 and 20.
Demonstration of the working of the programs is available at –

http://sleepeater.net/comp115assignment3P/applet/ http://sleepeater.net/comp115assignment3Cr/applet/ http://sleepeater.net/comp115assignment3D/applet/ http://sleepeater.net/comp115assignment3HD/applet/
Problem solving

Control structures

Arrays

Classes and Objects
USING THIS CODE BELOW:
class Ball {
/*

PLEASE NOTE THAT THE FOLLOWING DATA

MEMBER 'm'(which stands for mass IS REQUIRED ONLY FOR

HD SUBMISSIONS AND SHOULD BE SET

TO diameter * 0.05 FOR THE METHOD

collideWith(Ball) TO WORK CORRECTLY

*/

float m;

//You WILL need to implement a boolean checkCollisionWith(Ball other) method

//to correctly use collideWith method provided

DO NOT MODIFY THIS METHOD

void collideWith(Ball other) {

PVector bVect = new PVector();

bVect.x = other.x - x;

bVect.y = other.y - y;

float bVectMag = sqrt(bVect.x * bVect.x + bVect.y * bVect.y);

if (checkCollisionWith(other)) {

// get angle of bVect

float theta = atan2(bVect.y, bVect.x);

// precalculate trig values

float sine = sin(theta);

float cosine = cos(theta);

Ball[] bTemp = {

new Ball(), new Ball()

};

/* b[1]'s position is relative to b[0]'s

so you can use the vector between them (bVect) as the

reference point in the rotation expressions.

bTemp[0].x and bTemp[0].y will initialize

automatically to 0.0, which is what you want

since b[1] will rotate around b[0] */

bTemp[1].x = cosine * bVect.x + sine * bVect.y;

bTemp[1].y = cosine * bVect.y - sine * bVect.x;

// rotate Temporary velocities

PVector[] vTemp = {

new PVector(), new PVector()

};

PVector[] v = {

new PVector(speedX, speedY),

new PVector(other.speedX, other.speedY)

};

vTemp[0].x = cosine * v[0].x + sine * v[0].y;

vTemp[0].y = cosine * v[0].y - sine * v[0].x;

vTemp[1].x = cosine * v[1].x + sine * v[1].y;

vTemp[1].y = cosine * v[1].y - sine * v[1].x;

/* Now that velocities are rotated, you can use 1D

conservation of momentum equations to calculate

the final velocity along the x-axis. */

PVector[] vFinal = {

new PVector(), new PVector()

};

// final rotated velocity for b[0]

vFinal[0].x = ((m - other.m) * vTemp[0].x + 2 * other.m *

vTemp[1].x) / (m + other.m);

vFinal[0].y = vTemp[0].y;

// final rotated velocity for b[0]

vFinal[1].x = ((other.m - m) * vTemp[1].x + 2 * m *

vTemp[0].x) / (m + other.m);

vFinal[1].y = vTemp[1].y;

// hack to avoid clumping

bTemp[0].x += vFinal[0].x;

bTemp[1].x += vFinal[1].x;

/* Rotate ball positions and velocities back

Reverse signs in trig expressions to rotate

in the opposite direction */

// rotate balls

Ball[] bFinal = {

new Ball(), new Ball()

};

bFinal[0].x = cosine * bTemp[0].x - sine * bTemp[0].y;

bFinal[0].y = cosine * bTemp[0].y + sine * bTemp[0].x;

bFinal[1].x = cosine * bTemp[1].x - sine * bTemp[1].y;

bFinal[1].y = cosine * bTemp[1].y + sine * bTemp[1].x;

// update balls to screen position

other.x = constrain(x + bFinal[1].x, other.diameter/2, width-other.diameter/2);

other.y = constrain(y + bFinal[1].y, other.diameter/2, height-other.diameter/2);

x = constrain(x + bFinal[0].x, diameter/2, width-diameter/2);

y = constrain(y + bFinal[0].y, diameter/2, height-diameter/2);

// update velocities

speedX = cosine * vFinal[0].x - sine * vFinal[0].y;

speedY = cosine * vFinal[0].y + sine * vFinal[0].x;

other.speedX = cosine * vFinal[1].x - sine * vFinal[1].y;

other.speedY = cosine * vFinal[1].y + sine * vFinal[1].x;

}

}

}

«Prev
Next »