[C언어 게임] 테트리스 게임 (Tetris Game with C)

• 안녕하세요. BlockDMask입니다.

• 설명하기 전에, 메이킹 영상먼저 보겠습니다.

• 초기 배경을 만들고 하나씩 수정을 하는 모습을 동영상으로 만들었습니다.

• 영상의 마지막에(1:23)에는 V1.0 플레이 영상이 첨부 되어있습니다.

1. Intro

이름 : myTetris game (테트리스 게임)

요약 : C언어로 만든 테트리스 게임입니다. 콘솔 환경에서만 돌아갑니다. (.exe파일)

기간 : 2017년 05월 26일, 27일, 29일, 30일 (4일) 

(평일에는 퇴근하고 개발을 하였고, 주말에는 여친 안만날때 틈틈히 했습니다.)

인원 : 본인 한명

실행파일(exe) : 글 하단에 다운로드 부분을 클릭해주세요!

영상 : 유튜브 <- 클릭

비고

+ C언어 뱀게임 이후 바로 만든 게임입니다. (두번째 게임)

+ 언젠가는 한번 만들어 보고싶었는데, 탄력 받은김에 이렇게 만들어 보았습니다.

+ 뱀게임 에서는 플레이 관련 함수들을 먼저 만들고 그 위에 틀을 짜는 방식으로 시도해봤는데, 이번에는 배경에 속하는(UI)를 먼저 다 만들고 난 다음에 그 안에 있는, 세세한 로직을 구현하는 식으로 시도해보았습니다.

+ 테트리스 게임이 이렇게 복잡한 것인지 이제 알았습니다...신경쓸 것이 한두개가 아니더군요..(뱀게임이 훨씬 쉬웠.....)

<MAP>

- 맵은 2차원 배열을 이용해서 구현했습니다. 

- 2차원 배열(=맵) 에서 WALL인 부분, EMPTY인 부분, BlOCK을 구분해서 출력해줍니다.

- gotoxy 함수를 이용하여 앞쪽에서(실제 user에게 보여지는) 출력을 해주고, 그것에 대한 데이터를 뒤에서(2차원 배열) 저장해주는 방식으로 구현했습니다.

<Block>

- 블럭도 3차원 배열을 이용하여서 7개의 블럭을 일일히 만들어 놨습니다.

- 랜덤 함수를 이용하여 7개의 블럭중의 하나가 출력되게 구현하였고, next 블럭 또한 구현하였습니다.

- 모든 블럭들이 4x4 안에있는데 rotation을 할때마다 4x4 배열 안에 있는 BLOCK을 인식하게 하였고, 그 블락의 범위중 왼쪽끝, 아래끝, 오른쪽끝을 계산하여서 경계(왼쪽, 오른쪽, 아래 부딪히는곳)와 만날때 이벤트를 발생하도록 구현했습니다.

- 벽면이나 블락 옆에서 로테이션 할때 블럭이 겹치게 되면 해당 방향 반대편으로 한칸 이동하도록 (겹치지 않도록) 하였습니다.

<기능>

0. 방향키(←, →)로 좌우로 이동합니다.

1. 방향키 위(↑) 를 누르면 테트리스 블럭의 모양이 시계방향으로 회전합니다.

2. 스페이스(space)를 누르면 매우 빠르게 블럭이 내려가서 해당하는 곳의 맨 밑으로 위치합니다.

3. 가만히 있어도 일정한 속도로 블럭이 내려갑니다.

4. 처음 시작을 하면 3초 정도 시간이 주어진 다음 게임이 시작됩니다.

5. Best Score 는 기록이 되어서, exe와 같은 폴더 내에 "score.txt" 파일로 저장이 됩니다. 파일 입출력을 이용하여서, exe파일이 시작 될때 "score.txt" 파일의 내용을 불러와서, Best Score를 기록합니다.

6. 게임중 't | T' 를 누르면 현재 스코어를 저장하지 않고 메인화면으로 이동합니다.

7. 게임중 'p | P'를 누르면 일시정지 하게됩니다. 다시 'p | P'를 누르면 개임이 다시 시작 됩니다.

8. 메인화면에서 't | T'를 누르면 프로그램이 종료됩니다.

2. 소스코드

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
#include <conio.h>
#include <time.h>
 
#define MAP_SIZE_W 10
#define MAP_SIZE_H 20
#define HALF_W 15
#define HALF_H 10
#define EXIT 100
 
#define WALL 5
#define EMPTY 0
#define BLOCK 1
 
#define UP 72
#define LEFT 75
#define RIGHT 77
#define SPACE 32
#define ESC 27
#define DOWN 80
 
typedef char MData ;
 
typedef struct _currentlocation{
    int X;
    int Y;
} Location;
 
 
//hide cursor
void hidecursor() {
    HANDLE consoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO info;
    info.dwSize = 100;
    info.bVisible = FALSE;
    SetConsoleCursorInfo(consoleHandle, &info);
}
 
//move cursor.
void gotoxy(int x, int y){
    COORD P;
    P.X = 2*x;
    P.Y = y;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), P);
}
 
//get keyboard input.
int getKeyDown(){
    if(kbhit()) return getch();
    else return -1;
}
 
//////////////////////////////////////////////////DRAW/////////////////////////////////////////////////////////////////
void drawWall(MData map[MAP_SIZE_H][MAP_SIZE_W]){
    int h, w;
    HANDLE hand = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hand, 11);
 
    for(h=0; h<=MAP_SIZE_H +1; h++){
        for(w=0; w<=MAP_SIZE_W +1; w++){
            gotoxy(w+1,h+1);
            if(h==0 || w==0 || h==MAP_SIZE_H+1 || w==MAP_SIZE_W+1)
                printf("■");
        }
        printf("\n");
    }
    gotoxy(HALF_W, 1);
    SetConsoleTextAttribute(hand, 14);
    printf("<Next>");
    SetConsoleTextAttribute(hand, 11);
 
    for(h=2; h<=7 ;h++){
        for(w=HALF_W ; w<=HALF_W+5; w++){
            if(w==HALF_W || w==HALF_W+5 || h==2 || h==7){
                gotoxy(w, h);
                printf("■");
            }
        }
    }
    gotoxy(HALF_W, HALF_H+1);
    printf("Best  : ");
    gotoxy(HALF_W, HALF_H+2);
    printf("Score : ");
    gotoxy(HALF_W, HALF_H+12);
    printf("<Exit : 't' / Pause : 'p'>");
    SetConsoleTextAttribute(hand, 7);
}
 
int drawFrontMenu(){
    HANDLE hand = GetStdHandle(STD_OUTPUT_HANDLE);
    int keyInput;
    gotoxy(1,2);
    SetConsoleTextAttribute(hand, 11);
    printf("=====================================================");
    gotoxy(1,3);
    SetConsoleTextAttribute(hand, 14);
    printf("=================== T E T R I S =====================");
    SetConsoleTextAttribute(hand, 11);
    gotoxy(1,4);
    printf("=====================================================\n");
 
    SetConsoleTextAttribute(hand, 14);
    gotoxy(2,6);
    printf("Left : ← \n");
    gotoxy(2,7);
    printf("Right : → \n");
    gotoxy(2,8);
    printf("Rotation : ↑ \n");
    gotoxy(2,9);
    printf("Down: space \n");
    gotoxy(2,10);
    printf("Exit: 't' \n");
 
    SetConsoleTextAttribute(hand, 14);
    gotoxy(15,20);
    printf(" >> Made by BlockDMask.");
    gotoxy(15,21);
    printf(" >> BlockDMask@gmail.com");
 
    while(1){
        keyInput = getKeyDown();
        if(keyInput == 's' || keyInput == 'S') break;
        if(keyInput == 't' || keyInput == 'T') break;
 
        gotoxy(7, 15);
        SetConsoleTextAttribute(hand, 11);
        printf(" === press 's' to start ===");
        SetConsoleTextAttribute(hand, 7);
        Sleep(1000/2);
        gotoxy(7, 15);
        printf("                            ");
        Sleep(1000/2);
    }
 
    return keyInput;
}
 
void drawMap(MData map[MAP_SIZE_H][MAP_SIZE_W]){
    int h, w;
    HANDLE hand = GetStdHandle(STD_OUTPUT_HANDLE);
 
    for(h=0; h<MAP_SIZE_H; h++){
        for(w=0; w<MAP_SIZE_W; w++){
            gotoxy(w+2,h+2);
            if(map[h][w] == EMPTY){
                printf("·");
            }else if(map[h][w] == BLOCK){
                SetConsoleTextAttribute(hand, 14);
                printf("■");
                SetConsoleTextAttribute(hand, 7);
            }
        }
        printf("\n");
    }
 
}
//show next shape, score, time, best score.
void drawSubMap(int best, int score){
    HANDLE hand = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hand, 14);
    gotoxy(HALF_W + 4, HALF_H+1);
    printf("%4d", best);
    gotoxy(HALF_W + 4, HALF_H+2);
    printf("%4d", score);
    SetConsoleTextAttribute(hand, 7);
}
 
void drawSubShape(MData map[MAP_SIZE_H][MAP_SIZE_W],int shape[4][4]){
    int h, w;
    HANDLE hand = GetStdHandle(STD_OUTPUT_HANDLE);
 
    for(h=3; h<=6 ;h++){
        for(w=HALF_W+1 ; w<=HALF_W+4; w++){
                gotoxy(w, h);
                printf(" ");
 
        }
    }
    for(h=3; h<=6 ;h++){
        for(w=HALF_W+1 ; w<=HALF_W+4; w++){
            if(shape[h-3][w - HALF_W-1] == BLOCK){
                gotoxy(w, h);
                SetConsoleTextAttribute(hand, 14);
                printf("■");
                SetConsoleTextAttribute(hand, 7);
 
            }
        }
    }
}
 
void drawShape(MData map[MAP_SIZE_H][MAP_SIZE_W],int shape[4][4], Location curLoc){
    int h, w;
 
    for(h=0; h<4;h++){
        for(w=0; w<4;w++){
            if(shape[h][w] ==BLOCK){
                map[curLoc.Y+ h][curLoc.X +w]=BLOCK;
                //gotoxy(curLoc.X+2+w,curLoc.Y+2+h);
                // printf("■");
            }
        }
    }
 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
void startTime(){
    int i;
    HANDLE hand = GetStdHandle(STD_OUTPUT_HANDLE);
 
    for(i=0 ;i<3;i++){
        gotoxy(2,0);
        SetConsoleTextAttribute(hand, 14);
        printf("Start : %d sec", 3-i);
        SetConsoleTextAttribute(hand, 7);
        Sleep(1000);
    }
    gotoxy(2,0);
    printf("                       ");
}
void mapInit(MData map[MAP_SIZE_H][MAP_SIZE_W]){
    int i, j=0;
    for(i=0;i<MAP_SIZE_H;i++){
        for(j=0; j<MAP_SIZE_W; j++){
            map[i][j] = EMPTY;
        }
    }
}
void locationInit(Location * curLoc){
    curLoc->X =3;
    curLoc->Y =0;
}
void copyBlock(int blockShape[4][4], int copy[4][4]){
    int i, j;
    for(i=0;i<4;i++){
        for(j=0; j<4;j++){
            blockShape[i][j] = copy[i][j];
        }
    }
}
void setBlock(int blockShape[4][4]){
 
    int shape[7][4][4] = {
            {{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0}},
            {{0,0,0,0},{0,1,1,0},{0,1,1,0},{0,0,0,0}},
            {{0,0,0,0},{0,1,0,0},{1,1,1,0},{0,0,0,0}},
            {{0,0,1,0},{0,1,1,0},{0,1,0,0},{0,0,0,0}},
            {{0,1,0,0},{0,1,1,0},{0,0,1,0},{0,0,0,0}},
            {{0,0,0,0},{0,1,0,0},{0,1,1,1},{0,0,0,0}},
            {{0,0,0,0},{0,1,1,1},{0,1,0,0},{0,0,0,0}}
    };
    /*
    int shapeLong[4][4] = {{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0}};
    int shapeRock[4][4] = {{0,0,0,0},{0,1,1,0},{0,1,1,0},{0,0,0,0}};
    int shapeHorn[4][4] = {{0,0,0,0},{0,1,0,0},{1,1,1,0},{0,0,0,0}};
    int shapeStair[4][4] = {{0,0,1,0},{0,1,1,0},{0,1,0,0},{0,0,0,0}};
    int shapeRStair[4][4] = {{0,1,0,0},{0,1,1,0},{0,0,1,0},{0,0,0,0}};
    int shapeNienun[4][4] = {{0,0,0,0},{0,1,0,0},{0,1,1,1},{0,0,0,0}};
    int shapeRNieun[4][4] = {{0,0,0,0},{0,1,1,1},{0,1,0,0},{0,0,0,0}};
*/
    srand((unsigned int)(time(NULL)));
 
    switch(rand()%7) {
        case 0:
            copyBlock(blockShape, shape[0]);
            break;
        case 1:
            copyBlock(blockShape, shape[1]);
            break;
        case 2:
            copyBlock(blockShape, shape[2]);
            break;
        case 3:
            copyBlock(blockShape, shape[3]);
            break;
        case 4:
            copyBlock(blockShape, shape[4]);
            break;
        case 5:
            copyBlock(blockShape, shape[5]);
            break;
        case 6:
            copyBlock(blockShape, shape[6]);
            break;
        default :
            break;
    }
}
 
////////////////////////////////////////////////////////////////////!ah//////////////////////////////
void removeShape(MData map[MAP_SIZE_H][MAP_SIZE_W], int blockShape[4][4], Location * curLoc){
    int h, w;
    for(h=0; h<4;h++){
        for(w=0; w<4;w++){
            if(blockShape[h][w] == BLOCK)
                map[curLoc->Y + h][curLoc->X + w]=EMPTY;
        }
    }
}
 
int getShapeLeftLoc(int blockShape[4][4]){
    int h, w, leftW=4;
    for(w=0; w<4;w++){
        for(h=0; h<4;h++){
            if(blockShape[h][w] == BLOCK){
                if(leftW > w)
                    leftW = w;
            }
        }
    }
    return leftW;
}
int getShapeRightLoc(int blockShape[4][4]){
    int h, w, rightW=0;
    for(w=3; w>=0;w--){
        for(h=3; h>=0;h--){
            if(blockShape[h][w] == BLOCK){
                if(rightW < w)
                    rightW = w;
            }
        }
    }
    return rightW+1;
}
int getShapeBottomLoc(int blockShape[4][4]){
    int h, w, bottomH=0;
    for(w=3; w>=0;w--){
        for(h=3; h>=0;h--){
            if(blockShape[h][w] == BLOCK){
                if(bottomH < h)
                    bottomH =h;
            }
        }
    }
    return bottomH+1;
}
int getEachBottomLoc(int blockShape[4][4], int w){
    int h, bottomH=-1;
    for(h=3; h>=0;h--){
        if(blockShape[h][w] == BLOCK){
            if(bottomH < h)
                bottomH =h;
        }
    }
    return bottomH;
}
int getEachLeftLoc(int blockShape[4][4], int h){
    int w, leftW= 5;
    for(w=0; w<4;w++){
        if(blockShape[h][w] == BLOCK){
            if(leftW > w)
                leftW = w;
        }
    }
    return leftW;
}
int getEachRightLoc(int blockShape[4][4], int h){
    int w, rightW= -1;
    for(w=0; w<4;w++){
        if(blockShape[h][w] == BLOCK){
            if(rightW < w)
                rightW = w;
        }
    }
    return rightW;
}
void goLeft(MData map[MAP_SIZE_H][MAP_SIZE_W],int blockShape[4][4], Location *curLoc){
    int leftW = getShapeLeftLoc(blockShape);
    int boundaryArr[4] ={0};
    int i;
    for(i=0; i<4;i++){
        boundaryArr[i] = getEachLeftLoc(blockShape, i);
 
    }
    if((curLoc->X) + leftW > 0){
        if(!((boundaryArr[0] != 5 && map[curLoc->Y][curLoc->X + boundaryArr[0] -1] != EMPTY)
           ||(boundaryArr[1] != 5 && map[curLoc->Y +1][curLoc->X + boundaryArr[1] -1] != EMPTY)
           ||(boundaryArr[2] != 5 && map[curLoc->Y +2][curLoc->X + boundaryArr[2] -1] != EMPTY)
           ||(boundaryArr[3] != 5 && map[curLoc->Y +3][curLoc->X + boundaryArr[3] -1] != EMPTY))){
 
            removeShape(map, blockShape,curLoc);
            (curLoc->X)--;
        }
    }
}
void goRight(MData map[MAP_SIZE_H][MAP_SIZE_W],int blockShape[4][4], Location *curLoc){
    int rightW = getShapeRightLoc(blockShape);
    int boundaryArr[4] ={0};
    int i;
    for(i=0; i<4;i++){
        boundaryArr[i] = getEachLeftLoc(blockShape, i);
 
    }
 
    if((curLoc->X) + rightW < MAP_SIZE_W){
        if(!((boundaryArr[0] != 5 && map[curLoc->Y][curLoc->X + boundaryArr[0] +1] != EMPTY)
             ||(boundaryArr[1] != 5 && map[curLoc->Y +1][curLoc->X + boundaryArr[1] +1] != EMPTY)
             ||(boundaryArr[2] != 5 && map[curLoc->Y +2][curLoc->X + boundaryArr[2] +1] != EMPTY)
             ||(boundaryArr[3] != 5 && map[curLoc->Y +3][curLoc->X + boundaryArr[3] +1] != EMPTY))){
 
            removeShape(map, blockShape,curLoc);
            (curLoc->X)++;
        }
 
    }
}
 
int fixShape(MData map[MAP_SIZE_H][MAP_SIZE_W], int blockShape[4][4], Location *curLoc){
    int w, h;
    for(w=0; w<4; w++){
        for(h=0; h<4 ; h++){
            if(blockShape[h][w] ==1){
                map[curLoc->Y+ h][curLoc->X +w]=BLOCK;
            }
        }
    }
}
 
int goDown(MData map[MAP_SIZE_H][MAP_SIZE_W], int blockShape[4][4], Location *curLoc){
    int bottomH = getShapeBottomLoc(blockShape);
    int bottomArr[4] = {0};
    int i;
    for(i=0; i<4; i++){
        bottomArr[i] = getEachBottomLoc(blockShape, i);
    }
    if(curLoc->Y + bottomH  == MAP_SIZE_H
       ||(bottomArr[1] != -1 && map[curLoc->Y + bottomArr[1] +1][curLoc->X + 1] != EMPTY)
       ||(bottomArr[0] != -1 && map[curLoc->Y + bottomArr[0] +1][curLoc->X + 0] != EMPTY)
       ||(bottomArr[3] != -1 && map[curLoc->Y + bottomArr[3] +1][curLoc->X + 3] != EMPTY)
       ||(bottomArr[2] != -1 && map[curLoc->Y + bottomArr[2] +1][curLoc->X + 2] != EMPTY)
       ){
 
        fixShape(map, blockShape, curLoc);
 
        Sleep(1000/8);
        return TRUE;
    }
 
 
    if(curLoc->Y + bottomH < MAP_SIZE_H){
        removeShape(map, blockShape, curLoc);
        Sleep(1000/8);
        (curLoc->Y)++;
    }
    return FALSE;
}
 
void rotate(MData map[MAP_SIZE_H][MAP_SIZE_W],int blockShape[4][4], Location * curLoc){
    int i, j;
    int tmp[4][4];
    int leftW, rightW, bottomH;
 
    for(i=0; i<4;i++){
        for(j=0; j<4;j++){
            if(blockShape[i][j] == BLOCK){
                tmp[j][3-i] = blockShape[i][j];
                blockShape[i][j] = EMPTY;
            }
 
        }
    }
 
    for(i=0; i<4;i++){
        for(j=0; j<4;j++){
            if(tmp[i][j] == 1){
                blockShape[i][j] = BLOCK;
            }
 
        }
    }
 
 
    //벽에 붙어서 rotate 했을때. (when rotate near the wall.
    leftW= getShapeLeftLoc(blockShape);
    if(curLoc->X + leftW <0){
        goRight(map, blockShape, curLoc);
        if(leftW == 0) goRight(map, blockShape, curLoc); //long shape
    }
 
    rightW = getShapeRightLoc(blockShape);
    if(curLoc->X + rightW >MAP_SIZE_W){
        goLeft(map, blockShape, curLoc);
        if(rightW == 4)goLeft(map, blockShape, curLoc); //long shape
    }
 
 
    bottomH = getShapeBottomLoc(blockShape);
    if(curLoc->Y + bottomH > MAP_SIZE_H){
        removeShape(map, blockShape, curLoc);
        (curLoc->Y)--;
        if(bottomH ==4) (curLoc->Y)--;      //long shape
    }
}
 
int goSpace(MData map[MAP_SIZE_H][MAP_SIZE_W],int blockShape[4][4],Location * curLoc){
    int bottomH = getShapeBottomLoc(blockShape);
    int bottomArr[4] = {0};
    int i;
    for(i=0; i<4; i++){
        bottomArr[i] = getEachBottomLoc(blockShape, i);
    }
    while(1){
        if(curLoc->Y + bottomH  == MAP_SIZE_H
           ||(bottomArr[1] != -1 && map[curLoc->Y + bottomArr[1] +1][curLoc->X + 1] != EMPTY)
           ||(bottomArr[0] != -1 && map[curLoc->Y + bottomArr[0] +1][curLoc->X + 0] != EMPTY)
           ||(bottomArr[3] != -1 && map[curLoc->Y + bottomArr[3] +1][curLoc->X + 3] != EMPTY)
           ||(bottomArr[2] != -1 && map[curLoc->Y + bottomArr[2] +1][curLoc->X + 2] != EMPTY)
                ){
 
            fixShape(map, blockShape, curLoc);
 
            Sleep(1000/8);
            return TRUE;
        }
        if(curLoc->Y + bottomH < MAP_SIZE_H){
            removeShape(map, blockShape, curLoc);
            (curLoc->Y)++;
        }
    }
 
    return FALSE;
}
 
 
void deleteLine(MData map[MAP_SIZE_H][MAP_SIZE_W], int h){
    int w;
    for(w=0 ; w < MAP_SIZE_W ; w++){
        map[h][w] = EMPTY;
    }
}
void organizeLine(MData map[MAP_SIZE_H][MAP_SIZE_W], int h){
    int w;
    while(h > 1){
        for(w=0; w<MAP_SIZE_W;w++){
            map[h][w] = map[h-1][w];
        }
        h--;
    }
 
}
void checkLine(MData map[MAP_SIZE_H][MAP_SIZE_W], Location curLoc, int * score){
    int h, w, full, count =0;
 
    for(h=MAP_SIZE_H ; h >= (curLoc.Y -1); h--){
        full =0;
        for(w=0; w<MAP_SIZE_W  ;w++){
            if(map[h][w] == EMPTY){
                break;
            }else{
                full++;
            }
        }
 
        if(full == MAP_SIZE_W){
            (*score) += 5;
            deleteLine(map, h);
            organizeLine(map, h);
        }
    }
 
}
int GameOver(MData map[MAP_SIZE_H][MAP_SIZE_W],int score, int bestScore){
    FILE * wfp;
    int w=0;
    for(w=0; w<MAP_SIZE_W; w++){
        if(map[0][w] == BLOCK){
            HANDLE hand = GetStdHandle(STD_OUTPUT_HANDLE);
            SetConsoleTextAttribute(hand, 14);
            gotoxy(HALF_W -7, HALF_H-2);
            printf("====== Game Over ======");
            gotoxy(HALF_W -6, HALF_H-1);
            printf("Your Score : %4d\n", score);
            SetConsoleTextAttribute(hand, 7);
            gotoxy(1, MAP_SIZE_H+3);
 
            if(score >= bestScore){
                wfp = fopen("score.txt", "w");
                fprintf(wfp, "%d", score);
                fclose(wfp);
            }
 
            system("pause");
            return TRUE;
        }
    }
 
    return FALSE;
}
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int GameStart(MData map[MAP_SIZE_H][MAP_SIZE_W]){
    int key;
    int reachBottom = FALSE;
    int one = TRUE;
    int score =0, bestScore =0;
    int blockShape[4][4] ={0};
    int blockShapeSub[4][4] = {0};
    Location curLoc = {2,2};
    FILE * rfp;
    if((rfp = fopen("score.txt", "r")) == NULL){
        FILE * wfp;
        wfp = fopen("score.txt", "w");
        fprintf(wfp, "%d", 0);
        fclose(wfp);
    }
    fscanf(rfp, "%d", &bestScore);
 
    mapInit(map);
    drawWall(map);
    drawMap(map);
 
    locationInit(&curLoc);
    setBlock(blockShape);
    startTime();
    setBlock(blockShapeSub);
    drawSubShape(map, blockShapeSub);
    while(1){
 
        if(reachBottom == TRUE){
            if(GameOver(map,score, bestScore)) return EXIT;
 
            checkLine(map, curLoc, &score);
            checkLine(map, curLoc, &score);
            locationInit(&curLoc);
            copyBlock(blockShape, blockShapeSub);
            setBlock(blockShapeSub);
            drawSubShape(map, blockShapeSub);
            reachBottom = FALSE;
        }
 
        drawSubMap(bestScore,score);
        drawShape(map,blockShape, curLoc);
        drawMap(map);
        reachBottom = goDown(map, blockShape, &curLoc);
        if(reachBottom == TRUE) continue;
 
        key = getKeyDown();
        if(key == 't' || key =='T') break;
        if(key == 'p' || key == 'P'){
            system("pause"); system("cls");
            drawMap(map); drawWall(map);
        }
        if(key == SPACE){
            goSpace(map, blockShape, &curLoc);
        }
        if(key==224 || key ==0){
            key = getch();
            if(key == UP){
                rotate(map, blockShape, &curLoc);
            }else if(key == LEFT){
                goLeft(map, blockShape, &curLoc);
            }else if(key == RIGHT){
                goRight(map, blockShape, &curLoc);
            }
        }
    }
    return EXIT;
}
 
 
 
int main() {
    char map[MAP_SIZE_H][MAP_SIZE_W] ={0};   //map
    int key;
    hidecursor();
 
    system("color 7");                      //console color
    system("mode con: cols=57 lines=25");   //console size
 
    while(1){
        key = drawFrontMenu();
        if(key == 't' || key == 'T') break;
        system("cls");
        GameStart(map);
        Sleep(1000/3);
        system("cls");
    }
    return 0;
}
 

3. Download

- DOWNLOAD = Tetris(v1.0).exe.zip

- 소스코드 = https://github.com/BlockDMask/Tetris_Game