//
// floq experiment
//

// start in debug mode or not
boolean debugKeys = false;

int fadeInFrames = 60;

int initBoidNum = 300;
boolean drawBox = false;
boolean doSmooth = true;

int bgColor = 64;
int normalBoidColor = 160;
int meColor = 32;
int anotherColor = 255;

// length of trail points list
int trailPoints = 20;
// how often trail points are created
// (this influences trail length just as much as trailPoints)
int trailFrameInterval = 8;

float starDistance = 100;
// time in seconds after one star is created before a new star can appear
int starDelay = 5;
float starGrowRate = 1.0;
int starFadeDelay = 90;

// frame counter, transient stuff
int frames = 0;
int lastStarTime;

Boid me, another;
FloqList floq;
ArrayList selfTrailPoints;
ArrayList stars;

void addTrailPoint(PVector p)
{
    // check if list is full, remove to preserve length
    if (selfTrailPoints.size() > trailPoints)
    	selfTrailPoints.remove(0);
    selfTrailPoints.add(p);
}

void drawTrails()
{
    PVector p1;
    int tr=32, tg=32, tb=32, ta=0;
    
    beginShape();
    stroke(tr, tg, tb, ta);
    strokeWeight(2);
    noFill();
    for (int i=0; i < selfTrailPoints.size(); i++)
    {
	stroke(tr, tg, tb, ta);
	strokeWeight(i*0.25);
	p1 = (PVector)selfTrailPoints.get(i);
	curveVertex(p1.x, p1.y, p1.z);
	//tr += 2;
	//tr = min(255, tr);
	ta += 2;
	//tg -= 2;
	//tb -= 2;
	//println(tr + ", " + tg + ", " + tb);
    }
    // fade in last vert
    stroke(tr, tg, tb, 0);
    curveVertex(me.pos.x, me.pos.y, me.pos.z);
    endShape();
}

class Star
{
    PVector pos;
    int startTime;
    float size = 1;
    int alpha = 255;
    // star size should vary
    int variance = 0;
    
    Star(PVector p, int t)
    {
	pos = p;
	startTime = t;
	//println("star @ " + pos);
	variance = (int)random(60);
    }
    
    void draw()
    {
	// if before fade delay, keep growing
	if ( frames < startTime + starFadeDelay - variance )
	{
	    size += starGrowRate;
	} else {
	    // else fade out
	    // if alpha is <= 0, we'll be removed during next drawStars()
	    alpha -= 1;
	}
	beginShape(LINES);
	strokeWeight(1);
	// 4-pointed star with alpha'd tips
	stroke(255, alpha);
	vertex(pos.x, pos.y, pos.z);
	stroke(255, 0);
	vertex(pos.x + size, pos.y, pos.z);
	stroke(255, alpha);
	vertex(pos.x, pos.y, pos.z);
	stroke(255, 0);
	vertex(pos.x - size, pos.y, pos.z);
	//
	stroke(255, alpha);
	vertex(pos.x, pos.y, pos.z);
	stroke(255, 0);
	vertex(pos.x, pos.y + size, pos.z);
	stroke(255, alpha);
	vertex(pos.x, pos.y, pos.z);
	stroke(255, 0);
	vertex(pos.x, pos.y - size, pos.z);
	//
	endShape();
    }
}

void drawStars()
{
    for (int i=0; i<stars.size(); i++)
    {
	Star s = (Star)stars.get(i);
	s.draw();
	// if completely faded out, remove
	if (s.alpha <= 0)
	{
	    //println("star " + i + " of " + stars.size() + " died.");
	    stars.remove(i);
	}
    }
}

void checkStars()
{
    float d;
    PVector mid;
    
    // no stars until sim has spun up for a bit
    if (frames < 60)
	return;
    
    d = me.pos.dist(another.pos);
    //println(d);
    // if me is close to another,
    // and last star time > star delay,
    // make new star
    if (d <= starDistance && frames >= lastStarTime + starDelay * 30)
    {
	lastStarTime = frames;
	// determine midpoint between me and another
	mid = another.pos.get();
	mid.sub(me.pos);
	mid.normalize();
	mid.mult(d / 2);
	mid.add(me.pos);
	stars.add(new Star(mid, frames));
    }
}


class FloqList
{
    ArrayList boids;
    
    FloqList(int n)
    {
	boids = new ArrayList();
	for(int i=0; i<n; i++)
	    boids.add(new Boid(new PVector(width / 2, height / 2, 600)));
    }
    
    void run()
    {
	for(int i=0; i<boids.size(); i++)
	{
	    Boid tempBoid = (Boid)boids.get(i);
	    // first boid is "me"
	    if (i == 0)
	    {
		tempBoid.h = meColor;
		tempBoid.run(boids);
		// curveVertex smooths, so only grab trail points every X frames
		if (frames % trailFrameInterval == 0)
		{
		    // duh: PVector.get() returns copy of vector
		    addTrailPoint(tempBoid.pos.get());
		}
	    }
	    else if ((Boid)boids.get(i) == another)
	    {
		tempBoid.h = anotherColor;
		tempBoid.run(boids);
	    }
	    else
	    {
		tempBoid.h = normalBoidColor;
		tempBoid.run(boids);
	    }
	}
    }
}

// camera settings
// (these are tuned for 1280x720)

/*
3/4 perspective

float rot_x = 3.6;
float rot_y = 2.45;
float rot_z = -0.25;
int pan_x = 720;
int pan_y = -300;
float zoom = 600;
*/

//another 3/4 perspective
/*
float rot_x = -0.5;
float rot_y = -0.4;
float rot_z = -0.2;
int pan_x = -420;
int pan_y = 320;
float zoom = 700;
*/

// straight on
float rot_x = 0;
float rot_y = 0;
float rot_z = 0;
int pan_x = 0;
int pan_y = 0;
float zoom = 900;

void setup()
{
    int pick;
    
    size(1280, 720, P3D);
    //size(1024, 600, P3D);
    frames = 0;
    lastStarTime = 0;
    selfTrailPoints = new ArrayList();
    stars = new ArrayList();
    floq = new FloqList(initBoidNum);
    me = (Boid)floq.boids.get(0);
    // choose another
    pick = floq.boids.size();
    pick = (int)random(pick);
    another = (Boid)floq.boids.get(pick);
    //println(another);
}



void draw()
{
    int a;
    
    // clear screen
    beginCamera();
    camera();
    translate(pan_x, pan_y, zoom);
    rotateX(rot_x);
    rotateY(rot_y);
    rotate(rot_z);
    // use mouse to orbit view
    // rot_x = map(mouseY,0,height,0,TWO_PI);
    // rot_y = map(mouseX,width,0,0,TWO_PI);

    // log view info
    //println("X:" + rot_x + ", Y: " + rot_y + ", Z: " + rot_z);
    //println("panX:" + pan_x + ", panY: " + pan_y + ", zoom: " + zoom);
  
    endCamera();
    background(bgColor);
    ambientLight(0, 0, 0);
    directionalLight(255, 255, 255, 0, -1, -0.5);
    noFill();
    stroke(0);

    // debug view of bounding area
    if (drawBox)
    {
	line(0, 0, 300, 0, height, 300);
	line(0, 0, 900, 0, height, 900);
	line(0, 0, 300, width, 0, 300);
	line(0, 0, 900, width, 0, 900);
  	line(width, 0, 300, width, height, 300);
	line(width, 0, 900, width, height, 900);
	line(0, height, 300, width, height, 300);
	line(0, height, 900, width, height, 900);
  	line(0, 0, 300, 0, 0, 900);
	line(0, height, 300, 0, height, 900);
	line(width, 0, 300, width, 0, 900);
	line(width, height, 300, width, height, 900);
    }
    drawStars();
    floq.run();
    drawTrails();
    checkStars();
    
    // full view fade in on start
    /*
    if (frames < 255)
    {
	noStroke();
	ambientLight(255, 255, 255);
	translate(0, 0, zoom);
	a = 255 - frames;
	//println(a);
	fill(bgColor, a);
	rect(0, 0, 1280, 720);
    }
    */
    
    frames += 1;
    //println(frames);
    if (debugKeys)
	text("debug mode", 30, 30, zoom + 25);
    //
    if (doSmooth)
	smooth();
    else
	noSmooth();
}

// debug camera stuffs
void keyPressed()
{
    if (key == '1')
	debugKeys = !debugKeys;
    
    if (!debugKeys)
	return;
    
    switch (keyCode)
    {
        case LEFT: rot_y += 0.1; break;
        case RIGHT: rot_y -= 0.1; break;
        case DOWN: rot_x += 0.1; break;
        case UP: rot_x -= 0.1; break;
    }
    switch (key)
    {
	case 'a': pan_x -= 10; break;
	case 'd': pan_x += 10; break;
	case 'w': pan_y -= 10; break;
	case 's': pan_y += 10; break;
	case 'z': zoom -= 10; break;
	case 'x': zoom += 10; break;
	case 'q': rot_z += 0.1; break;
	case 'e': rot_z -= 0.1; break;
	case 'b': drawBox = !drawBox; break;
        case 'r': setup(); break;
        case '3': boids3D = !boids3D; break;
        case 't': doSmooth = !doSmooth; break;
        case '2': stars.add(new Star(me.pos.get(), frames)); break;
    }
}