//import processing.opengl.*;
import ddf.minim.*;

Player player;
ArrayList blobs;
AnimFrames blobAnim;
ArrayList judges;
AnimFrames judgeAnim;
ArrayList beams;
Background back;

int stage;
int oldStage;
int transCount;

Minim minim;
AudioPlayer[] songs;

                  // up,    down,  left, right
boolean[] keyDown = {false, false, false, false};

boolean playerMoving;
static float speed = 1;
static float damp = 0.52;
static float variance = 5;

int numBlobs = 5;
int numJudges = 10;
int maxJudges = 80;
int judgeSpawnCount = 0;
int maxJudgeSpawnCount = 30;

float cam = 0;

//------------------------------------SETUP-------------------------------------//
void setup()
{
//  size(640, 480, OPENGL);
  size(640, 480);
  frameRate(30);
  
  stage = 1;
  oldStage = 0;
  transCount = -1;
  
  blobs = new ArrayList();
  
  judges = new ArrayList();
  judgeAnim = new AnimFrames("guilt", "guilt.png");
  for(int i=0; i<numJudges; i++)
  {
    judges.add(new Judge(random(-10, 20),
                         random(-10, 300),
                         random(0.6, 0.7),
                         judgeAnim ));
  }
  beams = new ArrayList();
  
  back = new Background();
  
  player = new Player(320, height-40);
  
  minim = new Minim(this);
  songs = new AudioPlayer[7];
  
  for(int i=0; i<7; i++)
    songs[i] = minim.loadFile("music/" + i + ".mp3");
  
  songs[stage].play();
  songs[stage].loop();
}


//------------------------------------DRAW-------------------------------------//
void draw()
{
  back.update();
  
  player.update();
  
  Blob tmpBlob;
  for(int i=0; i<blobs.size(); i++)
  {
    tmpBlob = (Blob)blobs.get(i);
    if(tmpBlob.update( player.x, player.y ))
      blobs.remove(i);
  }
  
  
  Judge tmpJudge;
  for(int i=0; i<judges.size(); i++)
  {
    tmpJudge = (Judge)judges.get(i);
    if(tmpJudge.update())
    {
      judges.remove(i);
      player.heal();
    }
  }
  if(--judgeSpawnCount <= 0)
  {
    if(judges.size() < maxJudgeSpawnCount && stage != 6)
    {
      judges.add(new Judge(cam+random(-10, 20),
                           random(-10, 300),
                           random(0.6, 0.7),
                           judgeAnim ));
    }
    judgeSpawnCount = maxJudgeSpawnCount + (int)random(-10, 10);
  }
  
  
  Beam tmpBeam;
  for(int i=0; i<beams.size(); i++)
  {
    tmpBeam = (Beam)beams.get(i);
    if(tmpBeam.update())
      beams.remove(i);
  }
  
  if(transCount == 0)
    songs[oldStage].pause(); 
  if(transCount == 30)
    songs[oldStage].shiftGain(0, -30, 3000); 
  if(transCount > 0)
    transCount--;
  
  cam += (player.x - width/2 - cam)*0.2;
}

void switchStage(int newStage)
{
  for(int i=0; i < 16; i++)
    blobs.add(new Blob(player.x, player.y, random(8, 12)));
  
  songs[newStage].play( songs[stage].position() );
  songs[newStage].loop();
  songs[newStage].shiftGain(-30, 0, 3000);
  
  transCount = 64;
  oldStage = stage;
  
  stage = newStage;
  
  if(newStage == 6)
  {
    blobs.clear();
    judges.clear();
  }
}

void stop()
{
  for(int i=0; i<7; i++)
  {
    songs[i].close();
  }
  minim.stop();
  super.stop();
}

void keyPressed()
{
  if(key == CODED)
  {
    switch(keyCode)
    {
      case UP:
      {
        keyDown[0] = true;
        break;
      }
      case DOWN:
      {
        keyDown[1] = true;
        break;
      }
      case LEFT:
      {
        keyDown[2] = true;
        break;
      }
      case RIGHT:
      {
        keyDown[3] = true;
        break;
      }
    }
  }
  else
  {
    if(key==' ')
    {
      player.isShooting = true;
    }
  }
}

void keyReleased()
{
  if(key == CODED)
  {
    switch(keyCode)
    {
      case UP:
      {
        keyDown[0] = false;
        break;
      }
      case DOWN:
      {
        keyDown[1] = false;
        break;
      }
      case LEFT:
      {
        keyDown[2] = false;
        break;
      }
      case RIGHT:
      {
        keyDown[3] = false;
        break;
      }
    }
  }
  else
  {
    switch(key)
    {
      case ' ':
      {
        player.isShooting = false;
        break;
      }
      case 'z':
      {
        if(stage > 0)
          switchStage(stage - 1);
        break;
      }
      case 'x':
      {
        if(stage < 6)
          switchStage(stage + 1);
        break;
      }
    }
  }
}