/* Tetris by Ben Hoyt, April 2008 */

#include <stdlib.h>
#include "tio.h"

/* falling speed, 1 is slow, 10 is fast */
#define SPEED 5

/* width and height of board (board has 3-square wide border
   so we don't have to worry about edge detection */
#define WIDTH 10
#define HEIGHT 20
#define BORDER 3
#define TOTAL_WIDTH (WIDTH+BORDER*2)
#define TOTAL_HEIGHT (HEIGHT+BORDER*2)
#define SQUARE(x, y) board[BORDER+y][BORDER+x]

/* board and game state */
static char board[TOTAL_HEIGHT][TOTAL_WIDTH];
static int curpiece, currote;
static int curx, cury;
static int gameover;

/* piece definitions (all pieces in all their rotations) */
extern int starts[7];
extern char pieces[7][4][4][4];

/* return a random piece number in the range 0..6 */
int randpiece(void) {
    return rand() % 7;
}

/* tell main loop the game has ended */
void endgame(void) {
    gameover = 1;
}

/* check if current piece fits at given x,y and rotation */
int fits(int tryx, int tryy, int tryrote) {
    int x, y;

    /* for each position in the 4x4 piece, if the board has a square there
       or the piece has a square there, it won't fit */
    for (y=0; y<4; y++) {
        for (x=0; x<4; x++) {
            if (SQUARE(tryx+x, tryy+y) && pieces[curpiece][tryrote][y][x])
                return 0;
        }
    }
    return 1;
}

/* place piece on board at current location (assumes it fits) */
void place(void) {
    int x, y;

    /* for each non-empty position in the 4x4 piece, place square on board */
    for (y=0; y<4; y++) {
        for (x=0; x<4; x++) {
            if (pieces[curpiece][currote][y][x])
                SQUARE(curx+x, cury+y) = curpiece+1;
        }
    }
}

/* show piece or hide piece (show if "show" is nonzero) */
void _showpiece(int show) {
    int x, y;

    /* for each non-empty position in the 4x4 piece, show or hide square */
    for (y=0; y<4; y++) {
        for (x=0; x<4; x++) {
            if (pieces[curpiece][currote][y][x])
                putsquare(curx+x+1, cury+y+1, show ? curpiece+1 : 0);
        }
    }
}

/* show current piece at current location */
void showpiece(void) {
    _showpiece(1);
}

/* erase current piece at current location */
void hidepiece(void) {
    _showpiece(0);
}

/* generate a new piece and show it, end game if it doesn't fit */
void newpiece(void) {
    curpiece = randpiece();
    currote = 0;
    curx = WIDTH/2 - 2;
    cury = starts[curpiece];
    if (fits(curx, cury, currote))
        showpiece();
    else
        endgame();
}

/* show the current board on the screen, including the border */
void showboard(void) {
    int x, y;

    for (y=-1; y<HEIGHT+1; y++) {
        for (x=-1; x<WIDTH+1; x++) {
            putsquare(x+1, y+1, SQUARE(x, y));
        }
    }
}

/* set up the board and the first piece */
void init(void) {
    int x, y;

    /* clear board, put 3-square border all the way around */
    for (y=0; y<TOTAL_HEIGHT; y++) {
        for (x=0; x<TOTAL_WIDTH; x++) {
            /* blank if inside border, otherwise mark as "border colour" */
            if (x>=BORDER && x<WIDTH+BORDER && y>=BORDER && y<HEIGHT+BORDER)
                board[y][x] = 0;
            else
                board[y][x] = 8;
        }
    }

    /* show board, place the first piece */
    showboard();
    srand(time(NULL));
    newpiece();
    gameover = 0;
}

/* move current piece left if possible */
void left(void) {
    if (fits(curx-1, cury, currote)) {
        hidepiece();
        curx--;
        showpiece();
    }
}

/* move current piece right if possible */
void right(void) {
    if (fits(curx+1, cury, currote)) {
        hidepiece();
        curx++;
        showpiece();
    }
}

/* move down the rows on the board above full row y */
void movedown(int rowy) {
    int x, y;
    
    /* move rows down, working from rowy upwards */
    for (y=rowy; y>=1; y--) {
        for (x=0; x<WIDTH; x++) {
            SQUARE(x, y) = SQUARE(x, y-1);
        }
    }

    /* then blank out first row */
    for (x=0; x<WIDTH; x++)
        SQUARE(x, 0) = 0;
}

/* check if we can chop any rows and chop them */
void choprows(void) {
    int x, y, moved = 0;

    /* check rows starting at bottom row */
    for (y=HEIGHT-1; y>=1; y--) {
        for (x=0; x<WIDTH; x++) {
            if (!SQUARE(x, y))
                break;
        }
        if (x==WIDTH) {
            movedown(y);
            y++;
            moved = 1;
        }
    }

    /* redisplay the board if any rows moved */
    if (moved)
        showboard();
}

/* move current piece down if possible, else chop rows and go to next piece */
void down(void) {
    if (fits(curx, cury+1, currote)) {
        hidepiece();
        cury++;
        showpiece();
    } else {
        place();
        choprows();
        newpiece();
    }
}

/* rotate current piece clockwise if possible */
void rotate(void) {
    int newrote;
    
    newrote = (currote+1) % 4;
    if (fits(curx, cury, newrote)) {
        hidepiece();
        currote = newrote;
        showpiece();
    }
}

/* main game loop */
int main(void) {
    int key, ticks = 0;

    setup();
    init();

    /* loop till game over */
    while (!gameover) {
        /* wait for key (-1 if timeout) */
        key = waitkey();
        if (key < 0)
            ticks++;
        else if (key == 'j')
            left();
        else if (key == 'l')
            right();
        else if (key == 'i')
            rotate();
        else if (key == 'k')
            down();
        else if (key == 'q')
            endgame();

        /* game tick -- move piece down */
        if (ticks >= 11-SPEED) {
            down();
            ticks = 0;
        }
    }

    teardown();
}