ArrayList bibittes;
ArrayList explosions;
 
void setup() {
  size(400,400);
  smooth();
  frameRate(20);
  bibittes = new ArrayList();
  explosions = new ArrayList();
  for ( int i =0; i < 30; i++ ) {
    bibittes.add( new Bibitte(random(width),random(height)) );
  }
}
 
void draw() {
  background(255);
 
 
  for ( int i =0; i < bibittes.size(); i++ ) {
    Bibitte bibitte1 = (Bibitte) bibittes.get(i);
    for ( int j = i+1; j < bibittes.size();j++ ) {
      Bibitte bibitte2 = (Bibitte) bibittes.get(j);
 
      float distance = dist( bibitte1.x , bibitte1.y , bibitte2.x , bibitte2.y );
      if ( distance < 20 ) {
 
        // Changer la direction des bibittes concernees
        float angle = atan2( bibitte2.y-bibitte1.y, bibitte2.x-bibitte1.x );
        bibitte1.angle = bibitte1.angleCible = angle + PI;
        bibitte2.angle = bibitte2.angleCible = angle;
 
        // Ajouter des explosions
        int nombreExplosions = floor(random(3,10));
        for ( int k =0 ; k < nombreExplosions ; k++ ) {
 
          // Trouver le point au centre des deux bibittes concerness
          float xCentre = bibitte1.x + cos(angle) * 10;
          float yCentre = bibitte1.y + sin(angle) * 10;
          Explosion explosion = new Explosion(xCentre, yCentre);
          explosions.add(explosion);
        }
      }
    }
  }
 
  // Dessiner les bibittes
  for ( int i =0; i < bibittes.size(); i++ ) {
    Bibitte b = (Bibitte) bibittes.get(i);
    b.draw();
  }
 
  // Dessiner les explosions et les retirer
  // si elles ont depasse leur duree
  for ( int i = explosions.size()-1; i >= 0; i-- ) {
    Explosion e = (Explosion) explosions.get(i);
 
    if ( e.draw() == false ) {
      explosions.remove(i);
    }
  }
}
 
class Bibitte {
  float x;
  float y;
  float angle;
  float angleCible;
  float v;
   
  Bibitte(float x, float y) {
    this.x = x;
    this.y = y;
    v = random(2,4);
    angle = random(PI*2);
    angleCible = random(PI*2);
  }
   
  
 
   
  void draw() {
    
    // Determiner si la bibitte de direction
    if ( random(100) < 5 ) {
       angleCible = random(PI*2);
   }
    
   // Deplacer la bibitte
   float angle_difference = angleCible - angle;
     
    angle_difference = angle_difference  % (PI * 2);
     
     if (angle_difference > PI) {
      angle_difference = angle_difference- PI * 2;
    } else if (angle_difference < -PI)  {
      angle_difference = angle_difference + PI * 2;
    }
     
    angle = angle_difference * 0.1 + angle;
     
    x = x + cos(angle) * v;
    y = y + sin(angle) * v;
     
    if ( x > width + 10) x = - 10;
    else if ( x < -10) x = width + 10;
    else if ( y > height + 10) y = - 10;
    else if ( y < -10) y = height + 10;
     
    // Dessiner la bibitte
    fill(0);
    noStroke();
    pushMatrix();
    translate(x,y);
    rotate(angle);
    ellipse(0,0,20,20);
    translate(7,0);
    fill(255);
    stroke(0);
    ellipse(0,-4,6,6);
    ellipse(0,4,6,6);
    popMatrix();
  }
 
}
 
class Explosion {
 
 
  float x;
  float y;
  color c;
  float taille;
  int duree;
  private int temps;
  float direction;
  float vitesse;
  float rotation;
  float vitesseRotation;
 
  Explosion( float x, float y) {
 
    this.x = x;
    this.y = y;
    c = color(random(200,256),random(0,256),random(0,30));
    taille = random(5,20);
    duree = floor(random(200,1500));
    temps = millis();
    direction = random(TWO_PI);
    vitesse = random(2,6);
    rotation = random(TWO_PI);
    vitesseRotation = random(-0.5,0.5);
  }
 
 
  boolean draw() {
 
    if ( millis() - temps > duree ) {
      return false;
    }
    else {
      x = x + cos(direction) * vitesse;
      y = y + sin(direction) * vitesse;
 
      noStroke();
      fill(c);
      pushMatrix();
      translate(x,y);
      rotation = rotation + vitesseRotation;
      rotate(rotation);
      rectMode(CENTER);
       
      // Changer la taille selon le temps restant
      int tempsEcoule = millis() - temps;
      float tailleCourante =  map( tempsEcoule , 0 , duree , taille , 0);
       
      rect( 0, 0, tailleCourante, tailleCourante );
      popMatrix();
    }
    return true;
  }
}

ParticleSystem ps;

void setup() {
  size(640,360);
  ps = new ParticleSystem(new PVector(width/2,50));
}

void draw() {
  background(0);
  ps.addParticle();
  ps.run();
}





// A simple Particle class

class Particle {
  PVector location;
  PVector velocity;
  PVector acceleration;
  float lifespan;

  Particle(PVector l) {
    acceleration = new PVector(0,0.05);
    velocity = new PVector(random(-1,1),random(-2,0));
    location = l.get();
    lifespan = 255.0;
  }

  void run() {
    update();
    display();
  }

  // Method to update location
  void update() {
    velocity.add(acceleration);
    location.add(velocity);
    lifespan -= 1.0;
  }

  // Method to display
  void display() {
    stroke(255,lifespan);
    fill(255,lifespan);
    ellipse(location.x,location.y,8,8);
  }
  
  // Is the particle still useful?
  boolean isDead() {
    if (lifespan < 0.0) {
      return true;
    } else {
      return false;
    }
  }
}




// A class to describe a group of Particles
// An ArrayList is used to manage the list of Particles 

class ParticleSystem {
  ArrayList<Particle> particles;
  PVector origin;

  ParticleSystem(PVector location) {
    origin = location.get();
    particles = new ArrayList<Particle>();
  }

  void addParticle() {
    particles.add(new Particle(origin));
  }

  void run() {
    for (int i = particles.size()-1; i >= 0; i--) {
      Particle p = particles.get(i);
      p.run();
      if (p.isDead()) {
        particles.remove(i);
      }
    }
  }
}
Processing was initiated by

ArrayList<Balle> maBalle;
int nbBalle=3;

void setup()
{
  size(500, 500);
  smooth();
 
  maBalle = new ArrayList<Balle>();
  for (int i=0; i<nbBalle; i++)
  {
    maBalle.add(new Balle());
  }
}
 
void draw()
{
  background(255);
  
  for(int i = 0; i < maBalle.size(); i++)
  {
    Balle b = maBalle.get(i);
    b.rebond();
    b.display();
    b.deplacement();
    
}
}
void mousePressed(){  
   maBalle.add(new Balle());
}

class Balle
{
  PVector position;
 PVector deplacement;
 PVector diametre;
 color couleur;
  Balle()
  {
    
    position=new PVector(random(0,width),random(0,height));
    deplacement=new PVector(random(-2,2),random(-2,2));
    diametre=new PVector(random(10,50),random(10,50));
    couleur=color(random(0,255),random(0,255),random(0,255));

  }
  void deplacement(){
    
   position.add(deplacement);
  }

 void rebond()
  {
  
    //detection des murs
    if (position.x < 0 ||position. x >= width)
    {
      deplacement.x=deplacement.x*-1;
    }
    if (position.y < 0 ||position. y >= height)
    {
      deplacement.y=deplacement.y*-1;
    }
  }
void display(){
  fill(couleur);
  ellipse(position.x,position.y,diametre.x,diametre.y);
}
}

int nb=10;    
Balle[]balle=new Balle[nb];    
void setup() {    
  size(800, 700);    
  for (int i=0;i<nb;i++) {    
    balle[i]=new Balle(random(width), random(height), -1, 1);
  }
}    
void draw() {    
  background(255);    
  for (int i=0;i<nb;i++) {    
    balle[i].rebondir();    
    balle[i].bouger();
  }    
  for (int i=0;i<nb;i++) {    
    for (int j = i + 1 ; j < nb; j++) {    
      balle[i].collision(balle[j]);
    }
  }
  for (int i=0;i<nb;i++) {    
    balle[i].afficher();
  }
}    

class Balle {    
  PVector position;    
  PVector deplacement;  
  int rayon;   
  boolean bing; 

  Balle(float px, float py, float dx, float dy) {    
    position = new PVector(px, py);    
    deplacement=new PVector (dx, dy);    
    rayon = 20;
  }    

  void rebondir() {   
    bing = false; 
    if (position.x > width|| position.x < 0)  
    {  
      deplacement.x=deplacement.x*-1;
    }    
    if (position.y >height||position.y<0)  
    {    
      deplacement.y= deplacement.y* -1;
    }
  }    

  void bouger() {   
    position.add(deplacement);
  }    

  void collision(Balle j) {    
    float distance = position.dist(j.position);   
    if (distance<40) {
      bing = true;
      j.bing = true;
    }
  }

  void afficher() {
    if (bing) {
      fill(255, 0, 255);
    } 
    else {
      fill(0, 255, 255);
    }
    ellipse(position.x, position.y, 40, 40);
  }
}