14-3-사.Hexa
헥사는 가로, 세로, 대각선 방향으로 세 개의 모양이 일치하면 벽돌을 제거하는 게임이다. 테트리스와 모양뿐만 아니라 게임의 논리까지도 거의 유사하므로 처음부터 다시 작성하는 것보다 Tetris2 소스를 복사한 후 수정하는 것이 더 편리하다. 대부분의 함수와 전역 변수를 그대로 쓸 수 있되 채움 점검을 하는 TestFull 함수만 잘 작성하면 된다. TestFull 함수는 난이도가 그리 높지 않고 기본적인 수학적인 논리력만 있으면 작성할 수 있어 알고리즘 연습용으로 아주 좋다. 완성된 전체 소스는 다음과 같다.
|
예 제 : Hexa |
#include <Turboc.h>
#define LEFT 75
#define RIGHT 77
#define UP 72
#define DOWN 80
#define PGUP 73
#define PGDN 81
#define ESC 27
#define BX 5
#define BY 1
#define BW 10
#define BH 20
void DrawScreen();
void DrawBoard();
BOOL ProcessKey();
void PrintBrick(BOOL Show);
int GetAround(int x,int y);
BOOL MoveDown();
void TestFull();
void DrawNext();
void PrintInfo();
void MakeNewBrick();
enum { EMPTY, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, WALL };
char *arTile[]={". ","■","●","★","♣","☎","◆","♠","♥","♨","♬","□"};
int board[BW+2][BH+2];
int nx,ny;
int brick[3];
int nbrick[3];
int score;
int bricknum;
int level;
void main()
{
int nFrame, nStay;
int x,y;
setcursortype(NOCURSOR);
randomize();
level=6;
for (;3;) {
clrscr();
for (x=0;x<BW+2;x++) {
for (y=0;y<BH+2;y++) {
board[x][y] = (y==0 || y==BH+1 || x==0 || x==BW+1) ? WALL:EMPTY;
}
}
DrawScreen();
nFrame=20;
score=0;
bricknum=0;
MakeNewBrick();
for (;1;) {
bricknum++;
memcpy(brick,nbrick,sizeof(brick));
MakeNewBrick();
DrawNext();
nx=BW/2;
ny=3;
PrintBrick(TRUE);
if (GetAround(nx,ny) != EMPTY) break;
nStay=nFrame;
for (;2;) {
if (--nStay == 0) {
nStay=nFrame;
if (MoveDown()) break;
}
if (ProcessKey()) break;
delay(1000/20);
}
if (bricknum % 10 == 0 && nFrame > 5) {
nFrame--;
}
}
clrscr();
gotoxy(30,12);puts("G A M E O V E R");
gotoxy(25,14);puts("다시 시작하려면 Y를 누르세요");
if (tolower(getch()) != 'y') break;
}
setcursortype(NORMALCURSOR);
}
void DrawScreen()
{
int x,y;
for (x=0;x<BW+2;x++) {
for (y=0;y<BH+2;y++) {
gotoxy(BX+x*2,BY+y);
puts(arTile[board[x][y]]);
}
}
gotoxy(50,3);puts("Hexa Ver 1.0");
gotoxy(50,5);puts("좌우:이동, 위:회전, 아래:내림");
gotoxy(50,6);puts("공백:전부 내림, ESC:종료");
gotoxy(50,7);puts("P:정지,PgUp,PgDn:난이도 조절");
DrawNext();
PrintInfo();
}
void DrawBoard()
{
int x,y;
for (x=1;x<BW+1;x++) {
for (y=1;y<BH+1;y++) {
gotoxy(BX+x*2,BY+y);
puts(arTile[board[x][y]]);
}
}
}
BOOL ProcessKey()
{
int ch;
int t;
if (kbhit()) {
ch=getch();
if (ch == 0xE0 || ch == 0) {
ch=getch();
switch (ch) {
case LEFT:
if (GetAround(nx-1,ny) == EMPTY) {
PrintBrick(FALSE);
nx--;
PrintBrick(TRUE);
}
break;
case RIGHT:
if (GetAround(nx+1,ny) == EMPTY) {
PrintBrick(FALSE);
nx++;
PrintBrick(TRUE);
}
break;
case UP:
PrintBrick(FALSE);
t=brick[0];
brick[0]=brick[1];
brick[1]=brick[2];
brick[2]=t;
PrintBrick(TRUE);
break;
case DOWN:
if (MoveDown()) {
return TRUE;
}
break;
case PGDN:
if (level > 2) {
level--;
PrintInfo();
}
break;
case PGUP:
if (level < 10) {
level++;
PrintInfo();
}
break;
}
} else {
switch (tolower(ch)) {
case ' ':
while(MoveDown()==FALSE) {;}
return TRUE;
case ESC:
exit(0);
case 'p':
clrscr();
gotoxy(15,10);
puts("Tetris 잠시 중지. 다시 시작하려면 아무 키나 누르세요.");
getch();
clrscr();
DrawScreen();
PrintBrick(TRUE);
break;
}
}
}
return FALSE;
}
void PrintBrick(BOOL Show)
{
int i;
for (i=0;i<3;i++) {
gotoxy(BX+nx*2,BY+ny+i);
puts(arTile[Show ? brick[i]:EMPTY]);
}
}
int GetAround(int x,int y)
{
int i,k=EMPTY;
for (i=0;i<3;i++) {
k=max(k,board[x][y+i]);
}
return k;
}
BOOL MoveDown()
{
if (GetAround(nx,ny+1) != EMPTY) {
TestFull();
return TRUE;
}
PrintBrick(FALSE);
ny++;
PrintBrick(TRUE);
return FALSE;
}
void TestFull()
{
int i,x,y;
int t,ty;
BOOL Remove;
static int arScoreInc[]={ 0,1,3,7,15,30,100,500 };
int count=0;
BOOL Mark[BW+2][BH+2];
// 배열에 기록
for (i=0;i<3;i++) {
board[nx][ny+i]=brick[i];
}
for (;;) {
// 연속 무늬 점검
memset(Mark,0,sizeof(Mark));
Remove=FALSE;
for (y=1;y<BH+1;y++) {
for (x=1;x<BW+1;x++) {
t=board[x][y];
if (t==EMPTY) continue;
// 수평
if (board[x-1][y]==t && board[x+1][y]==t) {
for (i=-1;i<=1;i++) Mark[x+i][y]=TRUE;
Remove=TRUE;
}
// 수직
if (board[x][y-1]==t && board[x][y+1]==t) {
for (i=-1;i<=1;i++) Mark[x][y+i]=TRUE;
Remove=TRUE;
}
// 우하향
if (board[x-1][y-1]==t && board[x+1][y+1]==t) {
for (i=-1;i<=1;i++) Mark[x+i][y+i]=TRUE;
Remove=TRUE;
}
// 좌하향
if (board[x+1][y-1]==t && board[x-1][y+1]==t) {
for (i=-1;i<=1;i++) Mark[x-i][y+i]=TRUE;
Remove=TRUE;
}
}
}
if (Remove == FALSE) return;
// 제거 애니메이션
for (i=0;i<6;i++) {
for (y=1;y<BH+1;y++) {
for (x=1;x<BW+1;x++) {
if (board[x][y]!=EMPTY && Mark[x][y]==TRUE) {
gotoxy(BX+x*2,BY+y);
puts(arTile[i%2 ? EMPTY:board[x][y]]);
}
}
}
delay(150);
}
// 연속된 무늬 삭제
for (y=1;y<BH+1;y++) {
for (x=1;x<BW+1;x++) {
if (board[x][y]!=EMPTY && Mark[x][y]==TRUE) {
for (ty=y;ty>1;ty--) {
board[x][ty]=board[x][ty-1];
}
board[x][1]=EMPTY;
count++;
}
}
}
DrawBoard();
score += arScoreInc[min(count/3,7)];
PrintInfo();
}
}
void DrawNext()
{
int x,y,i;
for (x=50;x<=70;x+=2) {
for (y=12;y<=18;y++) {
gotoxy(x,y);
puts(arTile[(x==50 || x==70 || y==12 || y == 18) ? WALL:EMPTY]);
}
}
for (i=0;i<3;i++) {
gotoxy(60,14+i);
puts(arTile[nbrick[i]]);
}
}
void PrintInfo()
{
gotoxy(50, 9);printf("난이도 : %d ",level);
gotoxy(50,10);printf("점수 : %d ",score);
gotoxy(50,11);printf("벽돌 : %d 개 ",bricknum);
}
void MakeNewBrick()
{
int i;
do {
for (i=0;i<3;i++) {
nbrick[i]=random(level)+1;
}
} while (nbrick[0]==nbrick[1] && nbrick[1]==nbrick[2] && nbrick[0]==nbrick[2]);
}
테트리스는 각 벽돌의 모양이 다른데 비해 헥사의 벽돌들은 모두 세로 세 칸짜리이되 새끼 벽돌의 구성이 다를 뿐이다. 그래서 모양을 정의하는 Shape 배열은 필요치 않으며 대신 각 새끼 벽돌의 무늬를 정의하는 arTile 배열이 필요하다. 이 예제는 총 10개의 무늬를 사용하되 난이도에 따라 사용할 무늬의 개수를 결정할 수 있다. 전역 변수 level이 이런 용도로 사용되며 단축키 PgUp, PgDn으로 실행중에 level을 변경할 수 있다. 벽돌의 모양이 연속적으로 같도록 배치하는 것이 게임의 목적이므로 벽돌의 종류가 작을수록 난이도는 쉬워진다.
board나 nx, ny 전역 변수는 테트리스와 동일하되 nx, ny는 제일 위 벽돌의 좌표를 가리키는 것으로 한다. 이런 변수의 의미는 처음 개발할 때부터 분명히 정할 필요가 있다. 헥사의 벽돌은 회전하기는 하되 전체 벽돌의 모양이 바뀌는 것이 아니라 새끼 벽돌의 위치만 바뀌므로 rot 전역 변수는 필요없으며 대신 새끼 벽돌의 구성을 기억하는 별도의 배열이 필요하다. 그래서 brick은 크기 3의 정수형 배열로 선언했으며 이 배열에 위쪽부터 각 새끼 벽돌의 번호를 기억하고 회전할 때는 새끼 벽돌의 위치를 바꾼다.
전체 프로그래의 흐름이 유사하므로 main 함수의 구조는 테트리스의 것을 그대로 사용하고 있다. 단 벽돌을 만들 때 세 개의 무늬가 모두 같아서는 안되므로 이 조건에 맞는 벽돌을 만드는 MakeNewBrick이라는 별도의 함수를 더 정의한다는 점만 다르다. MakeNewBrick은 nbrick 배열에 난수로 새끼 벽돌을 선택하되 무늬 중 하나라도 다를 때까지 반복함으로써 착륙 직후에 바로 제거되는 벽돌을 만들지 않도록 한다. 세 개의 무늬가 똑같은 벽돌은 게임의 목적상 만들지 않는 것이 바람직하다.
DrawScreen, DrawBoard, DrawNext, ProcessKey, PrintInfo 등의 함수는 거의 변한 것이 없다. 벽돌을 관리하는 함수들은 자료 구조가 바뀜에 따라 조금씩 변화가 있는데 PrintBrick 함수는 세 칸짜리 벽돌을 nx, ny에 차례대로 출력하거나 삭제한다. 각 칸에 대해 루프를 돌며 brick의 각 새끼 벽돌 무늬 또는 공백을 출력한다. GetAround 함수는 원형이 바뀌었는데 회전 모양이 없고 벽돌의 모양이 정해져 있으므로 b, r 인수가 제거되었다. 주어진 좌표 x, y에서 아래쪽으로 세 칸을 읽어 보고 그 중 가장 큰 값을 리턴한다. MoveDown은 아래쪽으로 한 칸 내리되 바닥이나 이미 쌓은 벽돌에 닿을 때 TestFull을 호출한다. 이 함수의 내용도 테트리스와 똑같다.
이 게임의 가장 핵심 코드는 게임의 규칙 구현부인 TestFull함수에 모두 작성되어 있으며 이 부분이 테트리스와 가장 다르다. board 배열을 읽어 같은 무늬가 세 개 이상 연속되어 있는 칸을 찾아 제거하는 것이 TestFull의 임무이다. 이 함수는 벽돌이 바닥에 착륙했을 때 MoveDown에 의해 호출되는데 게임판에 변화가 생겼으므로 연속된 무늬를 제거해야 한다. 우선 착륙한 벽돌을 배열에 기록한다. 그리고 무한 루프를 돌며 세 번 이상 연속된 무늬를 모두 찾아 제거한다.
이때 고려해야 할 사항은 연속된 무늬가 반드시 세 개가 아니라 네 개나 그 이상일 수도 있다는 것과 조금이라도 게임판에 변화가 생기면 추가로 제거되는 벽돌이 생기기도 한다는 점이다. 즉 제거된 벽돌 위쪽의 벽돌이 아래쪽으로 내려 오므로 또 다른 추가 제거 벽돌이 생길 수도 있다. 테트리스는 하나의 벽돌이 착륙할 때 한번에 벽돌을 모두 제거할 수 있지만 헥사는 제거에 의해 새로운 벽돌이 추가로 제거될 수 있기 때문에 더 이상 제거할 벽돌이 없을 때까지 점검을 반복해야 한다.
그래서 TestFull은 한 번에 점검과 제거를 다 할 수 없으며 점검을 먼저하여 제거할 벽돌을 고르고 이렇게 선택한 벽돌을 일괄 제거한다. 세 개의 무늬가 일치했다고 해서 바로 삭제해 버리면 그 이상의 무늬가 일치했는지를 정확하게 판별할 수 없을 것이다. 세 개의 연속 무늬가 있는지 조사하는 방법은 생각보다 간단하다. board 배열 전체를 순회하면서 비어있지 않은 각 칸에 대해 양쪽 인접 벽돌의 무늬가 같은지를 점검하는 것이다. 하나의 칸에 대해 다음 4가지 경우를 점검하면 된다.
수평으로 점검할 때는 인접한 좌우칸을 보고 수직으로 점검할 때는 상하칸을 보면 된다. 대각선으로 점검할 때는 그림과 같이 대각선 맞은편의 무늬를 본다. 점검 결과 세 칸의 무늬가 일치하면 Mark 배열에 이 칸이 제거 대상임을 표시한다. 모든 칸에 대해 이 과정을 반복하면 4개 이상 연속되어 있는 무늬들에 대해서도 정확하게 표시할 수 있다. 이때 약간의 중복 표시가 되기는 하지만 논리가 단순하기 때문에 큰 문제가 되지는 않는다. 또한 벽에 붙어 있는 줄은 4방향을 다 볼 필요가 없지만 어차피 벽과 안쪽의 무늬가 같을 수는 없으므로 이 경우도 아무 부작용이 없다.
위 그림과 같은 상황에서 채움 제거 점검을 한다고 해 보자. 왼쪽의 전화기 무늬 셋을 점검할 때는 수직 방향만 점검하면 된다. 만약 이 전화기가 수평이나 대각선으로도 연속되어 있다면 이 점검은 안쪽 좌표를 볼 때 체크될 것이다. 그러나 이 위치에 대해서도 별도의 조건 점검없이 4방향을 모두 다 보는데 제일 바깥의 무늬가 벽이므로 안쪽과 일치하는 세 개의 무늬가 절대로 나오지 않는다. 마찬가지로 아래쪽의 네모 무늬 셋을 점검할 때는 수평 방향만 보면 된다. 중간의 별 모양 4개를 점검할 때는 가운데에 있는 두 개의 별에서 두 번 중복 점검하지만 별 부작용은 없다.
TestFull 함수는 제거될 칸을 표시하기 위해 Mark라는 별도의 배열을 추가로 선언해서 사용하는데 이런 방법이 번거로우면 board 배열 요소의 특정 비트를 1로 설정하는 방법을 쓸 수도 있다. 예를 들어 제거 대상 칸에 대해 최상위 비트를 1로 설정하는 것도 나름대로 쓸만하다. 그러나 이렇게 하면 무늬를 비교할 때 ==로 바로 비교할 수 없고 최상위 비트를 마스크 오프한 후 비교해야 하므로 오히려 더 번거로와진다.
board 점검을 하기 전에 Remove는 FALSE로 초기화되고 하나라도 연속된 무늬가 발견되면 이 값을 TRUE로 변경하는데 이는 탈출 시점을 결정하기 위해서이다. board 배열 전체를 다 점검해도 연속된 무늬가 전혀 발견되지 않으면 이때가 바로 함수를 종료할 때이다. 바꾸어 말하면 연속된 무늬가 발견되면 다시 점검을 반복해야 하며 쌓인 벽돌이 많을 때는 다섯 번, 여섯 번 이 과정을 반복할 경우도 있다.
제거해야 할 벽돌이 발견되었으면 이 칸들을 깜박거리도록 하여 사용자에게 어떤 벽돌이 제거되는지를 분명히 표시한다. 이 처리가 생략되면 게임판이 너무 급격하게 변하므로 사용자가 게임의 진행 상황을 정확하게 알 수 없다. 헥사는 자신도 모르는 사이에 벽돌들이 연속되어 한꺼번에 제거되기도 하므로 이 처리는 단순한 멋부리기가 아니라 꼭 필요한 필수 서비스이다.
깜박임 처리까지 완료했으면 실제 벽돌을 배열에서 제거한다. 처음부터 끝까지 다시 루프를 돌면서 제거될 벽돌을 위쪽의 정보로 덮어 버리면 된다. 벽돌 제거 후 게임판을 완전히 다시 그리고 점수를 계산한 후 다시 루프의 선두로 돌아가 더 제거할 벽돌이 있는지 계속 점검한다. 한꺼번에 많은 벽돌을 없앨수록 높은 점수를 주도록 했는데 이는 째째하게 세 개씩 없애지 말고 가급적 모아 두었다가 한꺼번에 없애도록 유도하는 효과가 있다. 그래서 사용자는 다음 나올 벽돌을 보고 이중, 삼중으로 벽돌을 제거하는 계산을 미리 해야 하며 이런 머리 굴리기가 이 게임의 묘미이다. 왜냐하면 막상 해 보면 뜻대로 쉽게 되지 않으며 잘 안되면 약오르기 때문이다.