Hello, im trying to understand how the bouncybubbles code from the processing examples works .... but i do not understand what happens when 2 balls collide, can anybody explain me how the collide function works?

why does it calculate the angle? and what is targetX, targetY, etc?
Can anybody explain this piece of code?

thanks


 void collide() {
   for (int i = id + 1; i < numBalls; i++) {
     float dx = others[i].x - x;
     float dy = others[i].y - y;
     float distance = sqrt(dx*dx + dy*dy);
     float minDist = others[i].diameter/2 + diameter/2;
     if (distance < minDist) {
       float angle = atan2(dy, dx);
       float targetX = x + cos(angle) * minDist;
       float targetY = y + sin(angle) * minDist;
       float ax = (targetX - others[i].x) * spring;
       float ay = (targetY - others[i].y) * spring;
       vx -= ax;
       vy -= ay;
       others[i].vx += ax;
       others[i].vy += ay;
     }
   }  
 }

Looks like it's based on a collision detection example in Keith Peter's Actionscript Animation (a great reference book BTW).  In that there's a single, large central ball that the other smaller balls bounce off of.  Here's some text that might help:

"If there is a collision, you find the angle between the two, and use that plus the minimum distance to calculate a target x and y.  This target will be right on the outer edge of the centerBall.

From there, you just apply basic spring code to spring to that point...  once it reaches that point, it's no longer colliding and will fly off in whatever direction it's heading."

BenHem - since (distance < minDist) targetX/Y can't represent a point at the centre of the collision; to get that you would presumably use 'distance' rather than 'minDist' in the calculation.  In fact using minDist in the calculation ensures that targetX/Y will never be the centre of the collision and presumably ensure the balls don't get 'stuck' together...

Bouncing off polygons is a whole different ball-game (no pun intended - honest!)...  Basically it's a lot more complicated and I must admit not something I've experimented with much.  Depending on what you intend you might want to settle on a kludge, look into available libraries, or go the painful route of writing your own collision methods.  Still I'm sure there are people here with the experience who can make more helpful suggestions

blindfish, I'm sticking to my guns on this one -- if they're at the point where they're colliding, minDist represents the sum of their radii and therefore the *maximum* distance between the two circles' midpoints...distance, on the other hand, may be slightly less, and I'm guessing the difference represents the speed (depth) of impact..if you have the sketch draw a line between the actual midpoint and targetX/Y, it will be a very short one if it appears at all.

Re: polygons, I would suggest starting with a line.

Gonna steal the thread a bit..
I have a similar question...
I can't seem to get my collisions to work, i have either no collision at all, or when the collision occurs the pictures go bananas. I have stared at the code for several hours without any results at all :/
Code:

 private void move(){

    //xv = hastigheten på x
    //sänker hasigheten på xv med xGravity
    xv+= xGravity;
    //ger hastigheten till xv genom att plussa ihop x med x (hur många steg x ska ta)
    x += xv;

    // kollar ifall "bollen studsar mot en vägg"
    if (x>width || x<0)
    {

	//xv*=-1;
	if(x<0){
	  x=0+sprite.width/2;
	  xv*=-0.6;
	}
	else{
	  x=width - sprite.width/2;
	  xv*=-0.6;
	}
    }
    yv += potGravity;
    y +=yv;

    // if the ball hits the ground, bounce it back up
    if(y +sprite.height/2 > ground){
	y = ground - sprite.height/2;
	yv*=bounce;
    }

    if(yv<0){
	alive=false;
	onTheFloor = true;
    }
  }
 

Code:

  void collide(){
    //loopar igenom ballArray och 
    for (int i = 0; i <ballArray.size(); i++){
	//skapar en temp objekt av typen boll för att hålla datan på plats i
	Ball temp = (Ball)ballArray.get(i);
	//ser till att den hoppar över sig själv
	// if the other object is on the ground, you are gonna stick on top
	// this means you have to change your ground to the other's top
	//if (!temp.onTheFloor && temp.alive)
	//  ground = int(temp.y);
	// if you are on the ground, dont care about collisions
	if (!onTheFloor)
	if ( temp.getID() != id) {
	  float dx = temp.getX() - x;
	  float dy = temp.getY() - y;
	  float distance = sqrt(dx*dx + dy*dy);
	  float minDist = temp.getW()/2 + w/2;

	  if (distance < minDist) {
	    //println("gayfish: " +distance);	    
	    float angle = atan2(dy, dx);
	    float targetX = x + cos(angle) * minDist;
	    float targetY = y + sin(angle) * minDist;
	    float ax = (targetX - temp.getX()) * spring;
	    float ay = (targetY - temp.getY()) * spring;
	    //xv *= -1;//-= ax;
	    //yv *= -1;//-= ay;
	    
	    // 
	    y = temp.getY() - temp.getH()/2 - h/2;
	    //y = temp.getH - temp.getY()/2 - y/2;
	    float tempXV = temp.getXv();
	    temp.setXv(-tempXV*potGravity/2);
	    float tempYV = temp.getYv();
	    temp.setYv(-tempYV*potGravity/2);
	  }
	}
    }
  }
 

Help is hugely appreciated!