// quadblok
//    - a familiar game
//
//  Scott "Jerry" Lawrence
//  sdlpci@cis.rit.edu
//
//  $Id: quadblok.pde,v 1.1 2003/09/04 03:43:02 jerry Exp $

// Known Bugs:
//  - do doubles/triples/quads score correctly?
//  - game does not end - error when filled!

// Things to add:
//  - play modes
//    - clear N lines
//    - start with N garbage lines
//    - get down to 0 rows
//  - increasing speed with levels cleared
  

// app-level stuff
int hs = 10; // horiz size per square on the screen
int vs = 10; // vert size per square on the screen
BFont fff;      // the font we're using for the text

// game level stuff
boolean paused = false; // are we paused?

int score; // the current score
int scDrop  = 5;  // when a piece is dropped
int scAffix = 1;  // when a piece is affixed
int scOne   = 10; // one row, doubled each line cleared

int rowsCleared; // total number of rows cleared

Piece nextPiece; // the next piece we're gonna use
Playfield field; // the playfield we're playing on

int gameState = 0; // currrent game state
// 0: attract
// 1: play
// 2: game over


void setup()
{
  size( 200, 200 );
  background( 0, 0, 50 );

  fff = loadFont( "OCR-A.vlw.gz" );
  hint( SMOOTH_IMAGES );

  resetGame();
}

int val = 0;
int last = 0;

void loop()
{  
  if( gameState == 1 )
  {
    int s = second();
    
    if( last != s )
    {
      field.timeStep();
      last = s;
    }
    nextPiece.nextDraw( 130, 50 );
  }

  field.draw();

  drawText();

  if( paused )
    uberText( "paused", 65, 100 );
}

// keyPressed - keyboard handler - gameplay
void keyPressed()
{
  if( key == UP )    field.moveCCW();   // rotate the piece
  if( key == LEFT )  field.moveLeft();  // move piece left
  if( key == RIGHT ) field.moveRight(); // move piece right
  if( ( key == ' ' ) || ( key == DOWN ) )
  {
    field.moveDown(); // drop the piece
    last = -1; // force an update
  }
}

// keyReleased - keyboard handler - overall game control
void keyReleased()
{
  if( key == 'q' ) // quit game!
    resetGame();

  if( gameState == 1 )
  {
    if( key == 'p' ) // pause!
    {
      if( paused )
        paused = false;
      else
        paused = true;
    }
  }
  
  if( gameState == 2)
  {
    if( key == 'n' )
    {
      resetGame();
      gameState = 1;
    }
  }

  if( gameState == 0 ) // space to continue...
  {
    if( key == 's' )
      gameState = 1;
      field = new Playfield( 10, 20 );
  }
}

void resetGame()
{
  gameState = 0;
  score = 0;
  rowsCleared = 0;
  paused = false;

  nextPiece = new Piece();

  field = new Playfield( 10, 20 );
}

void drawText()
{
  setFont( fff, 30 );

  fill( 0 );
  text( "QUAD", 110, 21 );
  text( "BLOK", 131, 31 );

  if( gameState == 0 || gameState == 2 )  fill( random( 255 ));  else fill( 255 );
  text( "QUAD", 109, 20 );
  if( gameState == 0 || gameState == 2 )  fill( random( 255 ));  else fill( 255 );
  text( "BLOK", 130, 30 );

  if( gameState == 0 )
    uberText( "'s' to start", 40, 150 );
    
  if( gameState == 2 )
  {
    uberText( "G A M E  O V E R", 20, 80 );
    uberText( "'n' for new game", 20, 110 );
  }
  
  if( gameState >= 1 )
  {
    setFont( fff, 25 );
    
    /* not used yet
    fill( 0, 0, 255 );
    text( nf(0, 3), 108, 141 );
    */
    
    fill( 255, 0, 0 );
    text( nf(rowsCleared, 3), 108, 163 );

    fill( 255, 255, 0 );
    text( nf(score, 6), 108, 185 );
  }
}

void uberText(String text, int x, int y)
{
  setFont( fff, 18 );
  fill( 40, 0, 0 );
  rect( 0, y-15, width, 20 );

  fill( 0 );
  text( text, x-1, y );
  text( text, x+1, y );
  text( text, x, y-1 );
  text( text, x, y+1 );
  fill( 255, 255, 0 );
  text( text, x, y );
}

// Playfield class - stores all of the data for the playfield
class Playfield
{
  color[][] data;  // the pixels in the data
  int w;
  int h;

  Piece activePiece; // the active piece in play
  int apx; // x location of the piece
  int apy; // y location of the piece

  Playfield(int ww, int hh)
  {
    w = ww;
    h = hh;
    data = new color[w][h];
    zeroFill();
    diffFill( 5 );
    newPiece();
  }

  // zeroFill - clear the playfield
  void zeroFill()
  {
    for( int y=0 ; y<h ; y++ )
      for( int x=0 ; x<w ; x++ )
        data[x][y] = color( 0, 0, 0 );
  }

  // rndFill - fill with random colors
  void rndFill()
  {
    for( int y=0 ; y<h ; y++ )
      for( int x=0 ; x<w ; x++ )
      data[x][y] = color( random(255), random(255), random(255) );
  }

  // diffFill - fill with starting pixels
  void diffFill( int difficulty )
  {
    for( int y=h-difficulty;  y<h ; y++ )
      for( int x=0 ; x<w ; x++ )
        if( random(100) < 50 )
          data[x][y] = color( random(255), random(255), random(255) );
  }
  
  // newPiece -- pop the next piece into the active piece, generate new 'next'  
  void newPiece()
  {
    activePiece = new Piece( nextPiece.getWhich(), nextPiece.getFrame() );
    nextPiece.randomNew();
    apy = -activePiece.top();
    apx = 3;
    
  }

  // draw - draw the playfield
  void draw()
  {
    noStroke();

    // draw the playfield
    for( int y=0 ; y<h ; y++ )
    {
      for( int x=0 ; x<w ; x++ )
      {
        if( gameState == 0 ) // attract mode
          fill(random(255), random(255), random(255));
        else if( paused ) // pause mode
          fill( 0 );
        else // gameplay
        {
          fill( data[x][y] );
         
          if(( x >= apx && x < apx+activePiece.getSize() ) &&
             ( y >= apy && y < apy+activePiece.getSize() ))
          {
            if( activePiece.active( x-apx, y-apy ))
            {
              fill( activePiece.c() );
            }
          }
        }
        
        rect( x*hs, y*vs, hs-1, vs-1 );
      }
    }
  }

  // moveCCW -- attempt to rotate the piece
  void moveCCW()
  {
    if( !rotateCollide() )
      activePiece.spin();
  }

  // moveLeft -- attempt to move piece to the left
  void moveLeft()
  {
    if( !collide( apx-1, apy ))
      apx--;
  }

  // moveRight -- attempt to move piece to the right
  void moveRight()
  {
    if( !collide( apx+1, apy ))
      apx++;
  }

  // moveDown -- attemp to drop piece down
  void moveDown()
  {
    if( !collide( apx, apy+1 ))
    {
      apy++;
      moveDown();
    }
    score += scDrop; // score adjust
  }
  
  // timeStep - every N ticks of the clock, we do these things. (auto drop, affix)
  void timeStep()
  {
    gameOverCheck();
    
    if( !collide( apx, apy+1 ))
    {
      apy++;
    } else {
      // glue down the piece, make a new one
      affixPiece();
      newPiece();
      score += scAffix; // score adjust
    }
    // check for line clearing
    lineClear();
  }
  
  // gameOverCheck -- check for game over
  void gameOverCheck()
  {
    if( collide( apx, apy ) )
    {
      gameState = 2;
    }
  }
  
  // lineClear -- check for rows to be cleared and clear them
  void lineClear()
  {
    int scoreAdjust = 0;
    int remove = checkClear();

    while( remove > 0 )
    {
      // shift them all up
      for( int j=remove ; j>0 ; j-- )
      {
        for( int i=0 ; i<w ; i++ )
        {
          data[i][j] = data[i][j-1];
        }
      }
      
      // backfill the top line
      for( int i=0 ; i<w ; i++ )
      {
        data[ i ][ 0 ] = color( 0, 0, 0 );
      }
      
      // adjust score
      if( scoreAdjust == 0 )
      {
        scoreAdjust = scOne;
      } else {
        scoreAdjust += scoreAdjust;
      }
      rowsCleared++;
      
      // see if we need to do more
      remove = checkClear();
    }
    score += scoreAdjust;
  }
  
  // checkClear -- return the first line number found to be removed (complete)
  int checkClear()
  {
    for( int row=h-1 ; row>=0 ; row-- )
    {
      int set = 0;
      for( int col=0 ; col<w ; col++ )
      {
         if( data[col][row] != color( 0,0,0 ))
           set++;
      }
      
      if( set == w )
      {
        for( int col=0 ; col<w ; col++ )
        {
          data[col][row] = color( 255, 255, 255 );
        }
        return( row );
      }
    }
    return( 0 );
  }
  
  // collide - check for the current piece collisions with the new location
  boolean collide( int x, int y ) // 0,0 is top left
  {
    boolean collision = false;
    
    for( int i=0 ; i<activePiece.getSize() ; i++ )
    {
      for( int j=0 ; j<activePiece.getSize() ; j++ )
      {
        if( activePiece.active( i, j ))
        {
          if( x+i >= w || x+i < 0 || y+j >=h )
            collision = true;
          else if( data[ x+i ][ y+j ] != color( 0, 0, 0 ))
            collision = true;
        }
      }
    }
    return( collision );
  }
  
  // rotateCollide - check for current piece collisions with the new rotation
  boolean rotateCollide()
  {
    Piece rotatedPiece = new Piece( activePiece.getWhich(), activePiece.getFrame()+1 );
    
    boolean collision = false;
    
    for( int i=0 ; i<rotatedPiece.getSize() ; i++ )
    {
      for( int j=0 ; j<rotatedPiece.getSize() ; j++ )
      {
        if( rotatedPiece.active( i, j ))
        {
          if( apx+i >= w || apx+i < 0 || apy+j >=h )
            collision = true;
          else if( data[ apx+i ][ apy+j ] != color( 0, 0, 0 ))
            collision = true;
        }
      }
    }
    return( collision );
  }
  
  // affixPiece
  void affixPiece()
  {
    for( int i=0 ; i<activePiece.getSize() ; i++ )
      for( int j=0 ; j<activePiece.getSize() ; j++ )
      {
        if( activePiece.active( i, j ))
        {
          data[ apx+i ][ apy+j ] = activePiece.c();
        }
      }
  }
}


// Piece class -- an individual piece to be moved or whatever
class Piece
{
  BImage pieceImage;  // where we load in the piece gif

  boolean[][] data;   // of size NxN
  int pieceSize;  // N
  int pieceCount; // M

  // current values
  int which; // 0..M
  int frame; // 0..3

  // Piece - constructor:
  // picks a random piece
  // updates itself
  Piece( )
  {
    parseImageFile(); // read in the image
    randomNew(); // pick a piece
    updateData(); // update the matrix
  }
  
  // Piece - constructor:
  // picks the piece requested
  // updates itself;
  Piece( int ww, int ff )
  {
    parseImageFile(); // read in the image

    // use the passed in variables
    which = ww % pieceCount;
    frame = ff % 3;

    updateData(); // update the matrix
  }
  
  // randomNew -- get a new piece in place
  void randomNew()
  {
    // now we determine a random image...
    which = (int) random( pieceCount ); // [0..pieceCount]]
    frame = (int) random( 3 ); // [0..3]

    updateData(); // update the matrix  
  }
 
  // parseImageFile -- load the image, determine geometry
  void parseImageFile()
  {
    pieceImage = loadImage( "quadblocks.gif" );
    // image is structured as 4 NxN images across, M NxN images tall.
    // N is determined by image.width()
    pieceSize = pieceImage.width / 4;  // N

    // we will assume that the image is some multiple of 4 wide
    // that multiple is the number of pieces in the image
    pieceCount = pieceImage.height / pieceSize;

    // now allocate the data and fill it.
    data = new boolean[pieceSize][pieceSize];
  }
  
  // getWhich -- acccessor for the 'which' variable
  int getWhich()
  {
    return( which );
  }
  
  // getFrame -- accessor for the 'frame' variable
  int getFrame()
  {
    return( frame );
  }
  
  // getSize -- accessor for the 'pieceSize' variable
  int getSize()
  {
    return( pieceSize );
  }

  // updateData - convert the image data from the .gif into the data[][] array
  void updateData()
  {
    for( int i=0 ; i<pieceSize ; i++ )
    {
      for( int j=0 ; j<pieceSize ; j++ )
      {
        int x = (pieceSize * frame) + j;
        int y = (pieceSize * which) + i;
        
        color c = pieceImage.pixels[ (y*pieceImage.width) + x ];

        if( brightness( c ) > 1 )
          data[i][j] = true;  // pixel is occupied
        else
          data[i][j] = false; // pixel is empty
      }
    }
  }

  // active - returns true if the pixel in the data array is occupied
  boolean active( int x, int y )
  {
    return( data[x][y] ); // just a simple accessor of the data array
  }

  // top -- returns the first row number with data in it
  int top()
  {
    for( int y=0 ; y<pieceSize ; y++ )
      for( int x=0 ; x<pieceSize ; x++ )
      {
        if( active( x, y ) )
        {
          return( y );
        }
      }
    return( 0 );
  }

  // c - returns the color that this piece should be
  color c()
  {
         if( which == 0 ) return( color( 255,   0,   0 )); // red
    else if( which == 1 ) return( color( 255, 127,   0 )); // orange
    else if( which == 2 ) return( color( 255, 255,   0 )); // yellow
    else if( which == 3 ) return( color(   0, 255,   0 )); // green
    else if( which == 4 ) return( color(   0,   0, 255 )); // cyan
    else if( which == 5 ) return( color(   0,   0, 255 )); // blue
    else if( which == 6 ) return( color( 255,   0, 255 )); // purple

    // unknown (custom pieces?) return gray
    return( color( 127, 127, 127 )); // gray
  }

  // activeC - for the pixel, returns the piece color if active, otherwise black
  color activeC( int x, int y )
  {
    if( active( x, y ))
      return( c() );
      
    return( color( 0, 0, 0 ));
  }

  // nextDraw -- draw the next piece widget
  void nextDraw( int xo, int yo )
  {
    int c = 0;
    noStroke();

    for( int y=0 ; y<4 ; y++ )
      for( int x=0 ; x<4 ; x++ )
      {
        if( paused ) {
          fill( 40 );
        } else {
          // use the piece color or black
          fill( activeC( x, y ));
        }
        rect( xo+(x*hs), yo+(y*vs), hs-1, vs-1 );
      }
  }

  // spin - rotate the piece through its 4-frame array
  void spin()
  {
    frame = (frame + 1) % 4;
    updateData();
  }
}