See: File > Examples > Topics > Motion (especially BouncyBubbles)

thanks for your comment but i don't really understand what is going on in the void collision(); i updated my original post with the part of the code i don't understand. maybe you or someone else can explain it to me somehow : /

Woops I did not know about that BouncyBubbles example.. And I too made a similar one a while back. Unfortunately I did not know how to do it in a OOP way neither, so I just had a nested loop in the main draw() function.

This is my draw function with (very simple just for test basically) object collision:

1. void draw()
   {
     background(0);
    
     for (int i=0; i<nrob; i++)
     {
       ball[i].move();
      
       // Simple collision detection
       if (nrob>1)
       {
         for(int collide=i+1; collide<nrob; collide++)
         {
           int distance = int(sqrt(sq(ball[i].xpos - ball[collide].xpos) + sq(ball[i].ypos - ball[collide].ypos)));
           // swap speeds if collision
           if (distance < (ball[i].radius + ball[collide].radius))
           {
             int tempXspeed = ball[collide].xspeed;
             int tempYspeed = ball[collide].yspeed;
             ball[collide].xspeed = ball[i].xspeed;
             ball[collide].yspeed = ball[i].yspeed;
             ball[i].xspeed = tempXspeed;
             ball[i].yspeed = tempYspeed;
           }
         }
       }
   
       ball[i].display();
     }
   }
   

nrob = nr. of balls, and I have not included  the ball object as it seemed unneccesary.

However that BouncyBubbles example do explains a bit..  (I would never thought of it myself, it looks pretty involved in a way passing a reference to it's own object as an argument? I'd like an explanation of it as well, or a correction to what I'm about to write).

BouncyBubbles have a similar object collision detection to mine above (which is pretty standard for checking elements of an array against others in the same array), except it is included in the object itself. Which is what I also wondered about how to do.

Here is the entire BouncyBubbles example, with some text color marked for clarity (I hope... note it might not be for clarity if I'm wrong.. I'm no expert in processing syntax and I haven't tested this method other that running this example...) Generally, the text with orange background refers to a particular ball (object), while yellow background refers to other balls (objects), that are checked against for collision (I didn't color every related thing).

1. /**
    * Bouncy Bubbles.
    * Based on code from Keith Peters (www.bit-101.com).
    *
    * Multiple-object collision.
    */
    
    
   int numBalls = 12;
   float spring = 0.05;
   float gravity = 0.03;
   float friction = -0.9;
   Ball[] balls = new Ball[numBalls];
   
   void setup()
   {
     size(640, 200);
     noStroke();
     smooth();
     for (int i = 0; i < numBalls; i++) {
       balls[i] = new Ball(random(width), random(height), random(20, 40), i, balls);
     }
   }
   
   void draw()
   {
     background(0);
     for (int i = 0; i < numBalls; i++) {
       balls[i].collide();
       balls[i].move();
       balls[i].display(); 
     }
   }
   
   class Ball {
     float x, y;
     float diameter;
     float vx = 0;
     float vy = 0;
     int id;
     Ball[] others;
    
     Ball(float xin, float yin, float din, int idin, Ball[] oin) {
       x = xin;
       y = yin;
       diameter = din;
       id = idin;
       others = oin;
     }
    
     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;
         }
       }  
     }
    
     void move() {
       vy += gravity;
       x += vx;
       y += vy;
       if (x + diameter/2 > width) {
         x = width - diameter/2;
         vx *= friction;
       }
       else if (x - diameter/2 < 0) {
         x = diameter/2;
         vx *= friction;
       }
       if (y + diameter/2 > height) {
         y = height - diameter/2;
         vy *= friction;
       }
       else if (y - diameter/2 < 0) {
         y = diameter/2;
         vy *= friction;
       }
     }
    
     void display() {
       fill(255, 204);
       ellipse(x, y, diameter, diameter);
     }
   }

(btw, I can't help but think there is a possibility for a kind of an infinite recursive-ish self-reference here, in that the others[id].id is the same as id.. (of course it is avoided since checking from id+1 in the for loop). But it seems id = others[id].id = others[others[id].id].id etc...)

Also, pacorurzgonzales, nice program there!

" think there is a possibility for a kind of an infinite recursive-ish self-reference here"
Not quite. Don't forget class instances (ie. objects) are separate entities. others variable is an array of Balls. There is no others[id], actually, but others[i] where i is an index, not an id. The fact the id is generated from an index isn't relevant here, it could have been a random number, for example. Mmm, actually not, because it is also used as index in the collision checking.

In general, I advise to move such collision checking outside the Ball class: somehow it belongs to the global level, or a class holding the list of balls. It reduces the confusion and separates responsibilities, as each ball doesn't need to be aware of the list of the other balls.

Illustration:

// Based on Bouncing Bubbles example in Processing,
// "Based on code from Keith Peters (www.bit-101.com)."

final int numBalls = 12;
final float spring = 0.05;
final float gravity = 0.03;
final float friction = -0.9;
Ball[] balls = new Ball[numBalls];

void setup()
{
  size(640, 200);
  smooth();

  for (int i = 0; i < balls.length; i++)
  {
    balls[i] = new Ball();
  }
}

void draw()
{
  background(255);
  
  for (int i = 0; i < balls.length; i++)
  {
    for (int j = i; j < balls.length; j++)
    {
      // Check collision against the remainder of the balls
      if (balls[i].isCollidingWith(balls[j]))
      {
        balls[i].bounceWith(balls[j]);
      }
    }
  }

  for (int i = 0; i < balls.length; i++)
  {
    balls[i].move();
    balls[i].display();
  }
}

class Ball
{
  float x, y; // Position
  float vx, vy; // Speeds
  float diameter;
  color c;

  Ball()
  {
    x = random(width);
    y = random(height);
    diameter = random(20, 40);
    c = int(random(250));
  }

  // Code straight from the example
  void move() 
  {
    vy += gravity;
    x += vx;
    y += vy;
    if (x + diameter/2 > width) {
      x = width - diameter/2;
      vx *= friction;
    }
    else if (x - diameter/2 < 0) {
      x = diameter/2;
      vx *= friction;
    }
    if (y + diameter/2 > height) {
      y = height - diameter/2;
      vy *= friction;
    }
    else if (y - diameter/2 < 0) {
      y = diameter/2;
      vy *= friction;
    }
  }
  
  boolean isCollidingWith(Ball ball)
  {
    return dist(x, y, ball.x, ball.y) < (diameter + ball.diameter) / 2;
  }
  
  // Also code from the example
  void bounceWith(Ball ball)
  {
    float dx = ball.x - x;
    float dy = ball.y - y;
    float minDist = (ball.diameter + diameter) / 2;
    float angle = atan2(dy, dx);
    float targetX = x + cos(angle) * minDist;
    float targetY = y + sin(angle) * minDist;
    float ax = (targetX - ball.x) * spring;
    float ay = (targetY - ball.y) * spring;
    vx -= ax;
    vy -= ay;
    ball.vx += ax;
    ball.vy += ay;
  }
 
  void display()
  {
    noStroke();
    fill(c);
    ellipse(x, y, diameter, diameter);
  }
}

Not perfect, as we can see some overlapping of circles, but nicely working.