//import processing.opengl.*;
// BoomThread 
// stolen by: Chris Dillon (http://ubernub.com)
// stolen from Ryan Alexander (http://onecm.com) 

BoomThread boom[] = new BoomThread[78]; 
int boomThreads; 
int activeBooms;

PFont font;

int now;
int then;

void setup() 
{ 
	size(900,400);
	frameRate(60);
	initThreads(); 
	noStroke(); 
	noSmooth();
 	font = loadFont("04b-08-8.vlw");
	textFont(font);
	
	// note the starting time
	now = millis();
} 

void draw() 
{ 
	// note how much time has passed since our last loop
	  then = now;

	  float elapsed = 0;

	  // wait for at least 1/100th of a second to pass
	  while( elapsed < 1.0/100.0 ) {
	    now = millis();

	    // compute elapsed time in seconds
	    elapsed = (now - then) / 1000.0f;
	  }
	
	
  background(0); 

	for(int i=0; i<boom.length; i++) 
	{ 
    	if(! boom[i].isDone()) {
			boom[i].draw(elapsed);
		} else {
			// ask boom to recreate itself, like a Phoenix oooOOoooOO
			//boom[i] = new BoomThread(this);
		}
	}
	
	// draw boom count
	fill(255);
	text("Active Threads:" + activeBooms, 0, 8);
	text("Total Threads:" + boom.length, 0, 16);
	
} 

void initThreads() 
{ 
  boomThreads = 0;
	activeBooms = 0;

  for(int i=0; i<boom.length; i++) 
  { 
    boom[i] = new BoomThread(this, boomThreads++); 
    boom[i].start(); 
  } 
} 

void boomCreated() 
{ 
  activeBooms++;
} 

void boomDestroyed(int id) 
{ 
  activeBooms--;
	//println("destroyed " + id);
	boom[id].stop();

	// give some space between creating a new one for activeBoom count to mean something
	try {
		Thread.sleep( (int) random(2,2000) );
    } 
    	catch(InterruptedException e) {
    }
	
	boom[id] = new BoomThread(this, id);
	boom[id].start();
} 



// Thread Class // 

public class BoomThread implements Runnable 
{ 
  Thread thread; 

  	//int pauseTime;  // Time to wait between loops 
  	float level; 

	float x;
	float y;
	float w;
	float h;
	float size;

  	boolean done;
	int id;
	
	float drawX;
	float drawY;
	float drawH;
	float drawW;
	
	float elapsed;

	public BoomThread(PApplet parent, int id) 
	{ 
		parent.registerDispose(this);

		this.level = 255;
		this.done = false;
		this.id = id;

		this.h = 16;		// this is half size because it starts stretched in the animation
		this.w = 32;		// width doesn't get distorted
		this.size = 32;		// this is the size
		this.x = (int)random(0, width/4);		// start mostly to the left
		this.y = (int)random(0, height-size);	// start from top padded by size, rects draw down by default
	} 

	// draw does not contain the elapsed because it's not the update really
	// store it for run()
	public void draw(float elapsed) 
	{
		this.elapsed = elapsed;
		
		fill(255, 255, 255, level);
		drawX = x * 255 / level;
		drawY = y;
		drawW = w - level / 255;
		drawH = h + level / 16;
		rect(drawX, drawY, drawW, drawH);
		fill(255,125,0, level);
		text(id, drawX, drawY + drawH + h / 2);
	}

	public void start() 
	{ 
		thread = new Thread(this);
		boomCreated();
		thread.start(); 
	} 

	public void run() 
	{ 
	    // do something threaded here 
	    while(level > 1) { 
			// level-- plus a little extra for lost time between draws
			level = level - 1 - elapsed;
			try 
			{
				// add random waiting to make each boom different
		      	Thread.sleep( (int)random(1, 10) ); 
			} catch(InterruptedException e)
			{
				// do nothing, to the horror of good coding
			} 
	    }
	
		// while loop finished, level is 0
		done = true;
	    boomDestroyed(id);
	}

	public boolean isDone()
	{
		return done;
	}

	public void stop() 
	{ 
		thread = null; 
	} 

	// this will magically be called by the parent once the user hits stop  
	// this functionality hasn't been tested heavily so if it doesn't work, file a bug  
	public void dispose() { 
		stop(); 
	} 
}