/**
 * Game 03: "Color Meltdown" <br/>
 * Put the same color on opposite sides of a white tile <br/>
 * Matched colors turn white <br/>
 * Get chain reactions <br/>
 * P to pause <br/>
 * <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/3.0/us/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by-nc-sa/3.0/us/80x15.png" /></a><br />This <span xmlns:dc="http://purl.org/dc/elements/1.1/" href="http://purl.org/dc/dcmitype/InteractiveResource" rel="dc:type">work</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="http://nmccoy.net" property="cc:attributionName" rel="cc:attributionURL">Nathan McCoy</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/3.0/us/">Creative Commons Attribution-Noncommercial-Share Alike 3.0 United States License</a>.
 */
//<meta name="robots" content="noindex, nofollow"/>
final int WIDTH = 640;
final int HEIGHT = 480;
final int BOARD_DIM = 11; //NxN tiles in the board; should be odd
final int TILE_SIZE = 36;
final int BOARD_SIZE = TILE_SIZE * BOARD_DIM;
final int BOARD_LEFT = WIDTH/2 - BOARD_SIZE/2;
final int BOARD_TOP = HEIGHT/2 - BOARD_SIZE/2;
final int CASCADE_TIME = 15;
final int REMOVE_TIME = 30;
final int GRAVITY_TIME = 0;
final int TIME_MAX = 60 * 60;
final int TIME_BONUS = 60;
boolean lastmouse;
boolean paused;

import ddf.minim.*;
Minim minim;
AudioSample plonkSound;
AudioSample cascadeSound1;
AudioSample cascadeSound2;
AudioSample cascadeSound3;
AudioSample cascadeSound4;
AudioSample cascadeSound5;
AudioSample[] cascade;
int cascadeCount;
AudioSample clearSound;
AudioSample timerSound;
AudioSample warningSound;
AudioSample gameOverSound;


//color consts
int NUM_COLORS = 3; //plus white
final color[] COLORS = {
  color(255, 255, 255), color(230, 32, 32), color(32, 192, 32), color(64, 64, 255), color(230, 200, 32), color(230, 64, 230), color(64, 192, 255), color(170, 180, 190)};

int[] board;
boolean[] flagged;
int score;
int gameTimer;
int fadeTimer;

PFont font;
boolean gameover;

ArrayList pieceQueue;
int QUEUE_SIZE = 7;

int phase;
final int READY = 0;
final int CASCADING = 1;
final int REMOVING = 2;
final int FALLING = 3;

int gameMode;
final int DEMOLISH = 0;
final int BUILD = 1;


//pick a tile based on screen coordinates
int screen2board(PVector screencoords)
{
  int x = (int) (screencoords.x - BOARD_LEFT)/TILE_SIZE;
  int y = (int) (screencoords.y - BOARD_TOP)/TILE_SIZE;
  x = (int) clamp(x, 0, BOARD_DIM-1);
  y = (int) clamp(y, 0, BOARD_DIM-1);

  return x + y * BOARD_DIM;
}

//get the coordinates of the upper left of the given tile
PVector board2screen(int tile)
{
  int x = (int) BOARD_LEFT + (tile % BOARD_DIM) * TILE_SIZE;
  int y = (int) BOARD_TOP + (tile / BOARD_DIM) * TILE_SIZE;
  return new PVector(x, y);
}

void clearTile(int tile)
{
  // board[tile] = -1;
  board[tile] = randomPiece();
}


float clamp(float value, float minimum, float maximum)
{
  if(value < minimum) return minimum;
  if(value > maximum) return maximum;
  return value;
}

final int ROWS = 0;
final int COLS = 1;
boolean scan(int index, int mode)
{
  boolean found = false;
  int lastcolor = -1;
  int lastcolorAt = -1;
  boolean seenWhite = false;
  for(int i = 0; i < BOARD_DIM; i++)
  {
    int cell;
    if(mode == ROWS)
      cell = BOARD_DIM*index + i;
    else
      cell = index + BOARD_DIM * i;
    int cellcolor = board[cell];
    if(cellcolor == 0) seenWhite = true;
    else
    {
      if(cellcolor == lastcolor && seenWhite && cellcolor != -1)
      {
        flagged[cell] = true;
        flagged[lastcolorAt] = true;
        found = true;
      }
      lastcolor = board[cell];
      lastcolorAt = cell;
      seenWhite = false;
    }
  }
  return found;
}

boolean doScan()
{
  boolean found = false;
  for(int i = 0; i < BOARD_DIM; i++)
  {
    found = scan(i, ROWS) || found;
    found = scan(i, COLS) || found;
  }
  return found;
}

boolean gravity()
{
  boolean somethingFell = false;
  for(int y = BOARD_DIM -1; y >= 1; y--)
    for(int x = 0; x < BOARD_DIM; x++)
      if(board[x+y*BOARD_DIM] == -1)
      {
        if(board[x+(y-1)*BOARD_DIM] != -1) somethingFell = true;
        board[x+y*BOARD_DIM] = board[x+(y-1)*BOARD_DIM];
        flagged[x+y*BOARD_DIM] = true;
        board[x+(y-1)*BOARD_DIM] = -1;
      }
      else flagged[x+y*BOARD_DIM] = false;
  return somethingFell;
}

void flaggedToWhite()
{
  for(int i=0; i<board.length; i++)
  {
    if(flagged[i])
    {
      flagged[i] = false;
      board[i] = 0;
    }
  }
  fadeTimer = 0;
}
int whiteToColors()
{
  int cascade = 0;
  for(int i=0; i<board.length; i++)
  {
    if(board[i]==0)
    {
      clearTile(i);
      cascade++;
    }
  }
  return cascade;
}

int randomPiece()
{
  NUM_COLORS = (int)clamp(4 + score/10000, 4, 7);
  return (int) random(NUM_COLORS)+1;
}

void setup()
{
  gameMode = DEMOLISH;
  minim = new Minim(this);
  plonkSound = minim.loadSample("plonk.wav", 512);
  warningSound = minim.loadSample("warning2.wav", 512);
  cascadeSound1 = minim.loadSample("cascade1.wav", 512);
  cascadeSound2 = minim.loadSample("cascade2.wav", 512);
  cascadeSound3 = minim.loadSample("cascade3.wav", 512);
  cascadeSound4 = minim.loadSample("cascade4.wav", 512);
  cascadeSound5 = minim.loadSample("cascade5.wav", 512);
  cascade=new AudioSample[]{
    cascadeSound1, cascadeSound2, cascadeSound3, cascadeSound4, cascadeSound5  };
  clearSound = minim.loadSample("clear2.wav", 512);
  timerSound  = minim.loadSample("timer2.wav", 512);
  gameOverSound  = minim.loadSample("gameover.wav", 512);

  frameRate(60);
  size(640, 480);
  font = loadFont("Calibri-32.vlw");
  textFont(font, 32);

  reset();
  gameover = true;
}

void reset()
{
  score = 0;
  board = new int[BOARD_DIM * BOARD_DIM];
  flagged = new boolean[BOARD_DIM * BOARD_DIM];
  pieceQueue = new ArrayList();

  for(int i=0; i<board.length; i++)
  {
    if(gameMode == DEMOLISH)
      board[i] = randomPiece();
    if(gameMode == BUILD)
      board[i] = -1;
  }

  for(int i =0; i < QUEUE_SIZE - 1; i++)
  {
    pieceQueue.add(new Integer(randomPiece()));
  }
  pieceQueue.add(new Integer(0));

  gameTimer = TIME_MAX;
  phase = READY;
  NUM_COLORS = 3;
  gameover = false;
}

void drawTimer()
{
  stroke(192);
  fill(128);
  int left = width/2 + BOARD_SIZE/2 +2;
  int top = height/2 - BOARD_SIZE/2;
  rect(left, top, 8, BOARD_SIZE);
  noStroke();
  if((gameTimer < 60 * 10) && (gameTimer/30)%2 == 1)
  {
    fill(color(255, 0, 0));
  }
  else
    fill(255);
  float timeRatio = gameTimer / (float)TIME_MAX;
  rect(left, top + BOARD_SIZE*(1-timeRatio), 8, BOARD_SIZE*timeRatio);

}


void drawQueue()
{
  textAlign(LEFT, TOP);
  fill(255);
  text("NEXT", 0, 0);

  int right = width/2 - BOARD_SIZE/2 -6;
  int top = height/2 - BOARD_SIZE/2;

  int y = top;
  int cellsize = TILE_SIZE*2;
  int x = right - cellsize;
  smooth();
  for(int i = 0; i < pieceQueue.size(); i++)
  {
    if(i == 0) stroke(255); 
    else stroke(0);
    fill(COLORS[((Integer)pieceQueue.get(i)).intValue()]);
    ellipse(x+cellsize/2, y+cellsize/2, cellsize, cellsize);
    y += cellsize + 2;
    cellsize *= 0.8;
    x = right - cellsize;
  }
  noSmooth();
}

void drawBoard()
{
  for(int i=0; i<board.length; i++)
  {
    if(board[i] == -1) fill(0);
    else fill(COLORS[board[i]]);

    stroke(64);
    PVector corner = board2screen(i);
    if(phase == FALLING && flagged[i])
      rect(corner.x, corner.y - TILE_SIZE* (fadeTimer/(float)GRAVITY_TIME), TILE_SIZE, TILE_SIZE);
    else rect(corner.x, corner.y, TILE_SIZE, TILE_SIZE);
    if(phase == CASCADING)
    {
      if(flagged[i])
      {
        noStroke();
        fill(255);
        rect(corner.x + TILE_SIZE/2 * (fadeTimer/(float)CASCADE_TIME), corner.y + TILE_SIZE/2 * (fadeTimer/(float)CASCADE_TIME), TILE_SIZE * (1 - fadeTimer/(float)CASCADE_TIME), TILE_SIZE * (1 - fadeTimer/(float)CASCADE_TIME));
      }
    }
    if(phase == REMOVING)
    {
      if(flagged[i])
      {
        noStroke();
        fill(255);
        rect(corner.x + TILE_SIZE/2 * (1 - fadeTimer/(float)REMOVE_TIME), corner.y + TILE_SIZE/2 * (1 - fadeTimer/(float)REMOVE_TIME), TILE_SIZE * (fadeTimer/(float)REMOVE_TIME), TILE_SIZE * (fadeTimer/(float)REMOVE_TIME));
      }
    }
  }
}

void cascadePhase()
{
  phase = CASCADING;
  for(int i=0; i<board.length; i++)
  {
    flagged[i] = false;
  }
}

void removalPhase()
{
  phase = REMOVING;
  int removalCount = 0;
  for(int i = 0; i < board.length; i++)
  {
    if(board[i]==0) 
    {
      flagged[i] = true;
      clearTile(i);
      removalCount++;
    }
  }
  score += removalCount * removalCount;
  gameTimer += max((removalCount - 1) * TIME_BONUS, 0);
  gameTimer = min(gameTimer, TIME_MAX);
  if(removalCount > 0)  
  {
    clearSound.trigger();
    fadeTimer = REMOVE_TIME;
  }
  else fadeTimer = 0;
}
int nextPiece()
{
  return ((Integer)pieceQueue.get(0)).intValue();
}


void clicky()
{
  if(gameover)
  {
    //reset();
  }
  else if(phase == READY)
  {
    int mouseTile = screen2board(new PVector(mouseX, mouseY));
    board[mouseTile] = nextPiece();
    if(nextPiece() == 0)
      pieceQueue.add(new Integer(0));
    else
      pieceQueue.add(new Integer(randomPiece()));
    pieceQueue.remove(0);
    plonkSound.trigger();
    if(pieceQueue.get(0).equals(new Integer(0))) warningSound.trigger();
    cascadePhase();
  }
}

void draw()
{

  background(0);
  drawBoard();
  drawQueue();
  drawTimer();
      textAlign(RIGHT, TOP);
    fill(255);
    //text("SCORE\n"+score+"\n\nTIME\n"+(gameTimer/60)+"."+(gameTimer%60), width, 0);
    text("SCORE\n"+score+"\n\nTIME\n"+(gameTimer/60), width, 0);
  if(!paused)
  {
    if(!gameover)
    {
      if((gameTimer <= 60* 10) && (gameTimer%60 == 0)) timerSound.trigger();

      if(phase == READY)
      {
        cascadeCount = 0;
      }
      if(phase == CASCADING)
      {
        if(fadeTimer == 0)
        {
          flaggedToWhite();
          boolean continuing = doScan();
          if(continuing) {
            fadeTimer = CASCADE_TIME;
            cascade[cascadeCount].trigger();
            cascadeCount++;
            if(cascadeCount > 4) cascadeCount = 4;
          }
          else 
          {
            removalPhase();
          }
        }
      }
      if(phase == REMOVING)
      {
        if(fadeTimer == 0) {
          if(gameMode == DEMOLISH)
            phase = FALLING;
          else phase = READY;
        }
      }
      if(phase == FALLING)
      {
        if(fadeTimer == 0)
        {
          boolean fall = gravity();
          if(fall) fadeTimer = GRAVITY_TIME;
          else phase = READY;
        }
      }
      if(fadeTimer > 0) fadeTimer--;

      fill(color(255, 255, 255, 160));
      stroke(255);
      int mouseTile = screen2board(new PVector(mouseX, mouseY));

      PVector corner = board2screen(mouseTile);
      //rect(corner.x, corner.y, TILE_SIZE, TILE_SIZE);
      fill(COLORS[nextPiece()]);
      ellipse(corner.x + TILE_SIZE/2, corner.y+TILE_SIZE/2, TILE_SIZE/2, TILE_SIZE/2);


      gameTimer--;
      if(gameTimer <= 0) 
      {
        if(phase == READY) 
        {
          gameover = true;
          gameOverSound.trigger();
        }
        else gameTimer = 0;
      }
    }
    else
    {
      fill(0, 128);
      rect(0,0,width, height);
      textAlign(CENTER, CENTER);
    fill(255);
    //text("SCORE\n"+score+"\n\nTIME\n"+(gameTimer/60)+"."+(gameTimer%60), width, 0);
    text("COLOR MELTDOWN\n\npress space for new game", width/2, height/2);
    }


    if(!lastmouse && mousePressed) 
      clicky();
    lastmouse = mousePressed;
  }
  else
  {
    textAlign(RIGHT, TOP);
    fill(255);
    //text("SCORE\n"+score+"\n\nTIME\n"+(gameTimer/60)+"."+(gameTimer%60)+"\nPAUSED", width, 0);
    text("SCORE\n"+score+"\n\nTIME\n"+(gameTimer/60)+"\nPAUSED", width, 0);
  }
}
void keyPressed()
{
  if(key == 'p') paused = !paused;
  if(key == ' ' && gameover) reset();
}

void stop()
{
  plonkSound.close();
  cascadeSound1.close();
  cascadeSound2.close();
  cascadeSound3.close();
  cascadeSound4.close();
  cascadeSound5.close();
  clearSound.close();
  timerSound.close();
  warningSound.close();
  gameOverSound.close();

  minim.stop();
  super.stop();

}