//import processing.opengl.*;

class Particle3
{
  float x, y, z;
  float sx, sy, sz;
  float svx, svy, svz;
  float centrex, centrey;
  float mass;
  int startTime, endTime;
  float vx, vy, vz;
  float ax, ay, az;
  boolean isAlive;
  color c;
  float dscale = 0.1f;
  float viewdist = 120.0f;
  int generation = 0;
  
  Particle3(int xpos, int ypos, int zpos, int lifespan )
  {
    sx = (float)xpos;
    sy = (float)ypos;
    sz = (float)zpos;
    x = sx;
    y = sy;
    z = sz;
    mass = 1;
    startTime = millis();
    isAlive = true;
    centrex = width/2;
    centrey = height/2;
    
    endTime = startTime + lifespan;
    c = color( 0 );
  }
  
  void display( )
  {
    float scrx, scry;
    if ( !isAlive ) return;
    if ( z + 202.0f < 1.0f ) return; // too close to or behind camera
    //if ( x > width || x < 0 || y > height || y < 0 ) return;

    fill ( c );
    //noStroke();
    scrx = x / (z + 202.0f) * viewdist;
    scry = y / (z + 202.0f) * viewdist;
    ellipse( centrex + (scrx/dscale), centrey + (scry/dscale), mass*20, mass*20 );
  }
  
  void update()
  {
    vx += ax;
    vy += ay;
    vz += az;
    x += vx;
    y += vy;
    z += vz;
    if ( millis() > endTime ) isAlive = false;
  }
}

class ParticleCloud3
{
  int centrex, centrey, centrez;
  int nParticles;
  float density;
  float colldist;
  float minmass, maxmass;
  int numAlive;
  Particle3[] p = new Particle3[400];
  int explodeNumber;
  
  ParticleCloud3( int cx, int cy, int cz, int n, float d, float minm, float maxm )
  {
    centrex = cx;
    centrey = cy;
    centrez = cz;
    nParticles = n;
    density = d;
    minmass = minm;
    maxmass = maxm;
    numAlive = nParticles;
    explodeNumber = 4;
    
    colldist = 0;
    
    for( int i=0;i<nParticles;i++)
    {
      p[i] = new Particle3( 0, 0, 0, 60000 + (int)random( 5000 ) );
      p[i].centrex = centrex;
      p[i].centrey = centrey;
      p[i].mass = minmass + random( maxmass-minmass );
      if ( i > ( nParticles / 2 ) ) p[i].isAlive = false;
    }
    
    reset();
  }
  
  void reset()
  {
    
    float rads;
    
    for( int i=0; i<nParticles; i++ )
    {
        rads = random( TWO_PI );
        p[i].x = cos( rads ) * (float)i * density;
        p[i].y = sin( rads ) * (float)i * density;
        p[i].z = cos( rads * 2 ) * (float)i * density;
    }
  }
  
  void gravitate( float strength )
  {
      int i, j, k;
      int newparts[] = new int[10];
      float distance, dx, dy, dz, nx, ny, nz;
      float avx, avy, avz;
      int numNew;
      float xpercent;
      
      for ( i=0; i<nParticles; i++ )
      {
        
        if ( !p[i].isAlive ) continue;
        avx = 0;
        avy = 0;
        avz = 0;
        
        for ( j=0; j<nParticles; j++ )
        {
           if ( j==i ) continue;
           if ( !p[j].isAlive ) continue;
           dx = (p[j].x - p[i].x);
           dy = (p[j].y - p[i].y);
           dz = (p[j].z - p[i].z);
           distance = dist( p[j].x, p[j].y, p[j].z, p[i].x, p[i].y, p[i].z );
           
           // check for collision
           if ( distance < colldist ) {      // 0.01 is good
           xpercent = (((p[i].mass + p[j].mass)/2.0f)/maxmass) * 50.0f;
           //println( xpercent );
             if ( random(100.0f) < xpercent )  // collision leads to explosion
             {
               
               p[j].isAlive = false;
               numNew = 0;
               // find free particles
               for ( k=0;k<nParticles;k++ )
               {
                 if ( numNew > explodeNumber ) break;
                 if ( p[k].isAlive==true ) continue;
                 newparts[numNew] = k;                 
                 numNew++;
               }

               if ( numNew==0 ) continue;
               for (k=0;k<numNew;k++)
               {
                 p[newparts[k]].isAlive = true;
                 p[newparts[k]].x = p[i].x + 1.0f + cos( random(TWO_PI) ) * random(2.0f);
                 p[newparts[k]].y = p[i].y + 1.0f + sin( random(TWO_PI) ) * random(2.0f);
                 p[newparts[k]].z = p[i].z + 1.0f + cos( random(TWO_PI) ) * random(2.0f);
                 p[newparts[k]].vx = random( 0.1f ) - 0.05f;
                 p[newparts[k]].vy = random( 0.1f ) - 0.05f;
                 p[newparts[k]].vz = random( 0.1f ) - 0.05f;
                 p[newparts[k]].mass = p[i].mass/(numNew + 1);
                 p[newparts[k]].endTime = millis() + (int)random( 60000 ) + 5000;
                 p[newparts[k]].generation++;
               }
               p[i].mass = p[i].mass/(numNew + 1);
               p[i].vx = random( 2.0f ) - 1.0f;
               p[i].vy = random( 2.0f ) - 1.0f;
               p[i].vz = random( 2.0f ) - 1.0f;
               p[i].endTime = millis() + (int)random( 60000 ) + 5000;
               p[i].generation++;
               //numAlive+=numNew;
             }
             else
             {
               p[j].isAlive = false;
               //numAlive--;
               p[i].mass += p[j].mass;
               p[i].vx = (p[i].vx + p[j].vx ) / 4;
               p[i].vy = (p[i].vy + p[j].vy ) / 4; 
               p[i].vz = (p[i].vz + p[j].vz ) / 4; 
               p[i].endTime = millis() + (int)random( 10000 ) + 5000;
               p[i].generation = (p[i].generation + p[j].generation) / 2;
               //print( i + " collided with " + j + "\n" );  
               //print( "[i]x:y=" + p[i].x + ":" + p[i].y + "[j]x:y=" + p[j].x + ":" + p[j].y + "\n" );          
             }
             continue;
             
           }
           if ( distance < 1.0f ) distance = 1.0f;
           
           // normalise the direction vector
           nx = dx / distance;
           ny = dy / distance;
           nz = dz / distance;

          // accumulate the acceleration vector
          avx += (nx * ((p[i].mass * p[j].mass)/sq(distance)));
          avy += (ny * ((p[i].mass * p[j].mass)/sq(distance)));
          avz += (nz * ((p[i].mass * p[j].mass)/sq(distance)));

         }
         
         // apply the accumulated accel vector
         p[i].ax = avx / p[i].mass;
         p[i].ay = avy / p[i].mass;
         p[i].az = avz / p[i].mass;
         //print( "[" + avx + ", " + avy + "] " );
      }
      
      for ( i=0; i<nParticles; i++ )
      {
        p[i].update();
        //if ( abs(p[i].vx) > 100 || abs(p[i].vy) > 100 ) p[i].isAlive = false;
        if ( abs(p[i].x) > 10000 || abs(p[i].y) > 10000 ) 
        {
          p[i].isAlive = false;
          //numAlive--;
        }
      }
  }
  
  int nearest( int i )
  {
    int j;
    float bestd = 9999999;
    float d = 0;
    int bestIndex = 0;
    
    if (!p[i].isAlive) return -1;
    
    for (j=0; j<nParticles; j++ )
    {
      if (j==i) continue;
      if (!p[j].isAlive) continue;
      
      d = dist( p[i].x, p[i].y, p[i].z, p[j].x, p[j].y, p[j].z );
      if ( d < bestd ) 
      {
        bestd = d;
        bestIndex = j;
      }
    }
    return bestIndex;
    
  }
  
  void display()
  {
    int i, j = 0;
    float depth;
    
    for ( i=0; i<nParticles; i++ )
    {
      if ( !p[i].isAlive ) continue;
      float vel = dist( 0, 0, 0, p[i].vx, p[i].vy, p[i].vz )*255;
      //p[i].c = color( vel, vel, vel, 10 );
      p[i].c = color( 255 - (25*p[i].generation),  vel, p[i].generation * 25, (p[i].generation * 10.0f) + 4 );
      p[i].display();
    }
  }
}

// set globals
ParticleCloud3 pc;
int n = 0;

// initialise
void setup()
{
  size( 650, 650 ); 
  pc = new ParticleCloud3( width/2, height/2, 0, 200, 0.5, 0.01f, 0.1f );
  pc.colldist = 0.2f;
  background( 128, 110, 100 );
}

// main draw loop
void draw()
{
  n++;
  
  noStroke();
  //fill( 0 );
  //fill( 0, 0, 0, 4 );
  //rect( 0, 0, width, height );

  pc.gravitate( 1 );
  pc.display();
}

void mousePressed()
{
  pc = new ParticleCloud3( mouseX, mouseY, 0, 200, abs(((float)width/2.0f - (float)mouseX)/((float)width/2.0f)), 0.01f, 0.1f );
  pc.colldist = 0.2f;
  //background( 128, 110, 100 );
}