#include"Turboc.h"


#define LEFT 75

#define RIGHT 77

#define UP 72

#define DOWN 80

#define ESC 27

#define BX 3

#define BY 2

#define BW 10

#define BH 30



struct Point
{
    int x, y;
};

Point Shape[][4][4] = {
    { { 0, 0, 1, 0, 2, 0, -1, 0 }, { 0, 0, 0, 1, 0, -1, 0, -2 }, { 0, 0, 1, 0, 2, 0, -1, 0 }, { 0, 0, 0, 1, 0, -1, 0, -2 } },
    { { 0, 0, 1, 0, 0, 1, 1, 1 }, { 0, 0, 1, 0, 0, 1, 1, 1 }, { 0, 0, 1, 0, 0, 1, 1, 1 }, { 0, 0, 1, 0, 0, 1, 1, 1 } },
    { { 0, 0, -1, 0, 0, -1, 1, -1 }, { 0, 0, 0, 1, -1, 0, -1, -1 }, { 0, 0, -1, 0, 0, -1, 1, -1 }, { 0, 0, 0, 1, -1, 0, -1, -1 } },
    { { 0, 0, -1, -1, 0, -1, 1, 0 }, { 0, 0, -1, 0, -1, 1, 0, -1 }, { 0, 0, -1, -1, 0, -1, 1, 0 }, { 0, 0, -1, 0, -1, 1, 0, -1 } },
    { { 0, 0, -1, 0, 1, 0, -1, -1 }, { 0, 0, 0, -1, 0, 1, -1, 1 }, { 0, 0, -1, 0, 1, 0, 1, 1 }, { 0, 0, 0, -1, 0, 1, 1, -1 } },
    { { 0, 0, 1, 0, -1, 0, 1, -1 }, { 0, 0, 0, 1, 0, -1, -1, -1 }, { 0, 0, 1, 0, -1, 0, -1, 1 }, { 0, 0, 0, -1, 0, 1, 1, 1 } },
    { { 0, 0, -1, 0, 1, 0, 0, 1 }, { 0, 0, 0, -1, 0, 1, 1, 0 }, { 0, 0, -1, 0, 1, 0, 0, -1 }, { 0, 0, -1, 0, 0, -1, 0, 1 } },
};


enum {EMPTY,BRICK, WALL};

char *arTile[] = { ". ", "??quot;, "??quot; };



char board[BW][BH] = { 0 };


int ch;

int block, turn;

int dx, dy;

int nframe;

BOOL exist;


BOOL GetAround(int nx, int ny, int nturn);
BOOL CreateBlock();
void MoveBlock(BOOL boolean);
void ProcessKey();
void StackBrick();



int main(void)
{



    int i, j;

    for (i = 0; i < BH; i++)
    {
        gotoxy(BX, BY);

        puts(arTile[BRICK]);

        if (i == 0 || i == BH - 1)
            puts(arTile[EMPTY]);

        puts(arTile[BRICK]);

    }


    randomize();


    while (1)
    {

        if (exist == FALSE)
            if (!CreateBlock())
                break;

        ProcessKey();

        nframe--;


        delay(20);

        if ((nframe <= 0) && (GetAround(dx, dy, turn)))
        {
            MoveBlock(FALSE);
            dy++;
            MoveBlock(TRUE);
        }
        else
            StackBrick();


    }





}





BOOL GetAround(int nx, int ny, int nturn)
{
    int i;

    for (i = 0; i < 4; i++)
        if (board[nx + Shape[block][nturn][i].x][ny + Shape[block][nturn][i].y] != EMPTY)
        {
            putch('\a');
            return FALSE;
        }
    return TRUE;
}




BOOL CreateBlock()
{
    block = random(4) % 4;
    turn = random(7) % 7;
    
    dx = BX + 5;
    dy = BY + 4;

    nframe = 50;

    if (!GetAround(dx, dy, turn))
        return FALSE;


    return TRUE;
}




BOOL GetAround(int nx,int ny,int nturn)
{
    int i;
    
    for (i = 0; i < 4;i++)
        if (board[nx + Shape[block][nturn][i].x][ny + Shape[block][nturn][i].y] != EMPTY)
        {
            putch('\a');
            return FALSE;
        }
    return TRUE;
}




void MoveBlock(BOOL boolean)
{
    int i;

    for (i = 0; i < 4; i++)
    {
        board[Shape[block][turn][i].x][Shape[block][turn][i].y] = boolean ? BRICK : EMPTY;
        gotoxy(Shape[block][turn][i].x + 1, Shape[block][turn][i].y + 1);
        puts(arTile[board[Shape[block][turn][i].x][Shape[block][turn][i].y]]);
    }
}





void ProcessKey()
{
    ch = getch();

    if (ch == 0xE0 || ch == 0)
    {
        ch = getch();

        switch (ch)
        {
        case UP:
            if (GetAround(dx, dy, (turn + 1) % 4))
            {
                MoveBlock(FALSE);
                turn = (turn + 1) % 4;
                MoveBlock(TRUE);
            }
            break;

        case DOWN:
            if (GetAround(dx, dy+1, turn))
            {
                MoveBlock(FALSE);
                dy++;
                MoveBlock(TRUE);
            }
            break;


        case LEFT:
            if (GetAround(dx-1, dy, turn))
            {
                MoveBlock(FALSE);
                dx--;
                MoveBlock(TRUE);
            }
            break;

        case RIGHT:
            if (GetAround(dx+1, dy, turn))
            {
                MoveBlock(FALSE);
                dx++;
                MoveBlock(TRUE);
            }
            break;
        }
    }

    if (ch == ' ')
    {
        MoveBlock(FALSE);

        while (GetAround(dx, dy+1, turn))
        {
            dy++;
        }

        MoveBlock(TRUE);
        StackBrick();
    }


}





void StackBrick()
{
    int i;

    for (i = 0; i < 4; i++)
    {
        board[dx + Shape[block][turn][i].x][dy + Shape[block][turn][i].y] = BRICK;
    }

    exist = FALSE;
}

#ifndef TURBOC_HEADER

#define TURBOC_HEADER



#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <time.h>

#include <windows.h>



typedef enum { NOCURSOR, SOLIDCURSOR, NORMALCURSOR } CURSOR_TYPE;

void clrscr();

void gotoxy(int x, int y);

int wherex();

int wherey();

void setcursortype(CURSOR_TYPE c);



#define delay(n) Sleep(n)                              // n/1000珥덈쭔???쒓컙 ??/span>

#define randomize() srand((unsigned)time(NULL))         // ?쒖닔 諛쒖깮湲?珥덇린??/span>

#define random(n) (rand() % (n))                        //0~n源뚯????쒖닔 諛쒖깮



// ??ㅽ겕濡쒓? ?뺤쓽?섏뼱 ?덉쑝??⑥닔???먰삎??좎뼵?섍퀬 ?뺤쓽???섏? ?딅뒗??

#ifndef TURBOC_PROTOTYPE_ONLY



// ?붾㈃??⑤몢 ?대떎.

void clrscr()

{

    system("cls");

}



// 而ㅼ꽌瑜?x,y醫뚰몴濡??대룞?쒗궓??

void gotoxy(int x, int y)

{

    COORD Cur;

    Cur.X = x;

    Cur.Y = y;

    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), Cur);

}



// 而ㅼ꽌??x 醫뚰몴瑜?議곗궗?쒕떎.

int wherex()

{

    CONSOLE_SCREEN_BUFFER_INFO BufInfo;



    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &BufInfo);

    return BufInfo.dwCursorPosition.X;

}



// 而ㅼ꽌??y醫뚰몴瑜?議곗궗?쒕떎.

int wherey()

{

    CONSOLE_SCREEN_BUFFER_INFO BufInfo;



    GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &BufInfo);

    return BufInfo.dwCursorPosition.Y;

}



// 而ㅼ꽌瑜??④린嫄곕굹 ?ㅼ떆 ?쒖떆?쒕떎.

void setcursortype(CURSOR_TYPE c)

{

    CONSOLE_CURSOR_INFO CurInfo;



    switch (c) {

    case NOCURSOR:

        CurInfo.dwSize = 1;

        CurInfo.bVisible = FALSE;

        break;

    case SOLIDCURSOR:

        CurInfo.dwSize = 100;

        CurInfo.bVisible = TRUE;

        break;

    case NORMALCURSOR:

        CurInfo.dwSize = 20;

        CurInfo.bVisible = TRUE;

        break;

    }

    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &CurInfo);

}