#include<stdio.h>
#include<stdlib.h>
#include<windows.h>
#include<conio.h>
#include<time.h>

#define NORMAL (1)
#define VARIABLE_MAP (2)
#define SCORE_BOARD (3)
#define HARD (4)
#define EXIT (0)

#define MAP_HEIGHT (20)
#define MAP_WIDTH (10)

#define LEFT_EDGE (0)
#define RIGHT_EDGE (9)
#define BOTTOM_EDGE (19)

#define BLOCK_SIZE (4)
#define BLOCK_DIAG (7)

#define DEFAULT_SPACE (0)
#define FIXED_SPACE (1)

#define LEFT_KEY (75)
#define RIGHT_KEY (77)
#define UP_KEY (72)
#define DOWN_KEY (80)
#define SPACE_KEY (' ')
#define PAUSE_KEY ('p')

#define UNIT_SPEED (10)

#define FILE_NAME_LENGTH (100)
#define LIST_LENGTH (10)
#define NAME_LENGTH (10)

typedef struct{
	int x;
	int y;
}Point;
typedef struct{
	Point point_set[BLOCK_SIZE];
	int block_diag;
	int block_dir;
	Point current_position;
}Block;

void tRunNormalGame();
void tViewScoreBoard();
void tRunMapSelGame();
int tMakeMap(int map[][MAP_WIDTH]);
char* selectMapList();
void tAddScore(char* name, int score);
int tIsGameEnd (int map[][MAP_WIDTH]);

void tBlockInitial (Block *block, int block_diag);
void tManageBlockFlow(int map[][MAP_WIDTH], Block* new_block, Block* next_block, int speed, int score);
void tMovingBlock2FixedSpace (int map[][MAP_WIDTH], Block* current_block);
void tPrintView (int map[][MAP_WIDTH], Block current_block_pos, int score, int speed);

int tConditionalDeletionLines (int map[][MAP_WIDTH]);
void tDeleteLine (int map[][MAP_WIDTH], int height);
void tCopyLine(int map[][MAP_WIDTH], int from_height, int to_height);
int tIsFullLine(int map[][MAP_WIDTH], int height);

int tIsFixedBlockSpace(Point check_point, int map[][MAP_WIDTH]);
int tIsMovingBlockSpace(Point check_point, Block current_block_pos);

void tMoveBlockByKey (int map[][MAP_WIDTH], Block* current_block, int key_input);
void tSideMoveBlock (int map[][MAP_WIDTH], Block* current_block, int key_input);
void tDownMoveBlock (int map[][MAP_WIDTH], Block* current_block);
int tIsTouchWall (Block* current_block, int direction);
void tLotateBlock (int map[][MAP_WIDTH], Block* current_block);
int tIsTouchBottom (int map[][MAP_WIDTH], Block* current_block);
int tIsTouchSideFixedBlock (int map[][MAP_WIDTH], Block* current_block, int direction);

const Point block_set[BLOCK_DIAG][4][BLOCK_SIZE] =
{
	{
		{{-1,-1},{0,-1},{1,-1},{2,-1}},
		{{0,-1},{0,0},{0,1},{0,2}},
		{{-1,-1},{0,-1},{1,-1},{2,-1}},
		{{0,-1},{0,0},{0,1},{0,2}}, // ¡à¡à¡à¡à
	},
	{
		{{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},{-1,0},{1,-1},{0,0}},
		{{0,-1},{0,0},{1,0},{1,1}},
		{{0,-1},{-1,0},{1,-1},{0,0}},// ¡à¡à
		{{0,-1},{0,0},{1,0},{1,1}}, //    ¡à¡à   
	},
	{	
		{{-1,-1},{0,-1},{0,0},{1,0}},
		{{0,0},{0,1},{1,-1},{1,0}},
		{{-1,-1},{0,-1},{0,0},{1,0}},//    ¡à¡à
		{{0,0},{0,1},{1,-1},{1,0}},  //  ¡à¡à
	},	
	{
		{{-1,0},{0,0},{1,0},{0,-1}},
		{{1,0},{0,-1},{0,0},{0,1}},
		{{-1,-1},{0,-1},{1,-1},{0,0}}, //   ¡à¡à¡à
		{{-1,0},{0,-1},{0,0},{0,1}}, //       ¡à
	},
	{
		{{-1,0},{0,0},{1,0},{-1,-1}},
		{{0,-1},{-1,-1},{-1,0},{-1,1}},
		{{-1,-1},{0,-1},{1,-1},{1,0}}, // ¡à¡à¡à
		{{0,1},{1,-1},{1,0},{1,1}},   //      ¡à
	},
	{
		{{-1,0},{0,0},{1,0},{1,-1}},
		{{1,1},{0,-1},{0,0},{0,1}},
		{{-1,-1},{0,-1},{1,-1},{-1,0}}, //  ¡à¡à¡à
		{{0,-1},{1,-1},{1,0},{1,1}},    //  ¡à
	}
};

int main (void)
{
	int select;
	while(TRUE)
	{
		system("cls");
		printf("--------- TETRIS ----------\n\n");
		printf("---------- Menu  ----------\n");
		printf(" 1. Normal Mode\n 2. Map Selection Mode\n 3. Score Board\n 0. Exit\n\n Select : ");
		scanf("%d",&select);
		switch(select)
		{
		case NORMAL: 
			tRunNormalGame(); 
			break;
		case VARIABLE_MAP: 
			tRunMapSelGame(); 
			break;
		case SCORE_BOARD: 
			tViewScoreBoard(); 
			break;
		case HARD:
		case EXIT: 
			printf("\nÇÁ·Î±×·¥À» Á¾·áÇÕ´Ï´Ù.\n"); 
			return 0;
		default: 
			printf("\nÀ߸øµÈ ÀÔ·ÂÀÔ´Ï´Ù. ´Ù½Ã ¼±ÅÃÇØÁÖ¼¼¿ä.\n");
			fflush(stdin);
			getchar();
		}
	}
}


void tPrintView (int map[][MAP_WIDTH], Block current_block_pos, int score, int speed)
{
	int i,j;
	Point tmp;
	system("cls");
	printf("\n\n");
	for(i=0;i<MAP_HEIGHT;i++)
	{
		printf("  ¡á");
		for(j=0;j<MAP_WIDTH;j++)
		{
			tmp.y=i;
			tmp.x=j;
			if(tIsMovingBlockSpace(tmp, current_block_pos)) printf("¡à");
			else if(tIsFixedBlockSpace(tmp, map)) printf("¢É");
			else	printf("  ");
		}
		printf("¡á");
		switch(i){
		case 0:  printf(""); break;
		case 1:  printf("\tNext Block"); break;
		case 2:  printf(""); break;
		case 3:  printf(""); break;
		case 4:  printf(""); break;
		case 5:  printf(""); break;
		case 6:  printf(""); break;
		case 7:  printf(""); break;
		case 8:  printf(""); break;
		case 9:  printf("\tKey"); break;
		case 10: printf("\t¡è:ºí·Ï¹æÇâ Àüȯ"); break;
		case 11: printf("\t¡ç:ÁÂÃøÀ̵¿ ¡æ:¿ìÃøÀ̵¿"); break;
		case 12: printf("\t¡é:¾Æ·¡·Î ÇÑ Ä­ À̵¿"); break;
		case 13: printf("\tspace bar:¾Æ·¡ ³¡À¸·Î À̵¿"); break;
		case 14: printf(""); break;
		case 15: printf(""); break;
		case 16: printf("\tSpeed : %d",speed); break;
		case 17: printf(""); break;
		case 18: printf("\tScore : %d",score); break;
		case 19: printf(""); break;
		}
		printf("\n");
	}
	printf("  ¡á¡á¡á¡á¡á¡á¡á¡á¡á¡á¡á¡á");
}

int tConditionalDeletionLines (int map[][MAP_WIDTH])
{
	int height;
	int score=0;
	int bonus_score=0;
	for(height=MAP_HEIGHT-1;height>=0;height--)
	{
		if(tIsFullLine(map, height)) { 
			tDeleteLine(map, height);
			height++;
			score += (++bonus_score);
		}
	}
	return score;
}

void tDeleteLine (int map[][MAP_WIDTH], int height)
{
	int i;
	if(height>=MAP_HEIGHT||height<0) return;
	for(i=height;i>0;i--)
	{
		tCopyLine(map,i-1,i);
	}
}
void tCopyLine(int map[][MAP_WIDTH], int from_height, int to_height)
{
	int i;
	for(i=0;i<MAP_WIDTH;i++)
	{
		map[to_height][i]=map[from_height][i];
	}
}
int tIsFullLine(int map[][MAP_WIDTH], int height)
{
	return (
	map[height][0] &&map[height][1] &&map[height][2] &&map[height][3] 
	&&map[height][4] &&map[height][5] &&map[height][6] 
	&&map[height][7] &&map[height][8] &&map[height][9]
	);
}

int tIsFixedBlockSpace(Point check_point, int map[][MAP_WIDTH])
{
	return (map[check_point.y][check_point.x]==FIXED_SPACE);
}

int tIsMovingBlockSpace(Point check_point, Block current_block_pos)
{
	int i;
	for(i=0;i<4;i++){
		if(current_block_pos.point_set[i].x==check_point.x && current_block_pos.point_set[i].y==check_point.y)
			return 1;
	}
	return 0;
}
void tMoveBlockByKey (int map[][MAP_WIDTH], Block* current_block, int key_input)
{
	switch(key_input){
	case LEFT_KEY:
	// ÀûÀýÈ÷ ÇÔ¼ö¸¦ È°¿ë
	case RIGHT_KEY:
	// ÀûÀýÈ÷ ÇÔ¼ö¸¦ È°¿ë
		break;
	case UP_KEY:
	// ÀûÀýÈ÷ ÇÔ¼ö¸¦ È°¿ë
		break;
	case DOWN_KEY:
	// ÀûÀýÈ÷ ÇÔ¼ö¸¦ È°¿ë
		break;
	case SPACE_KEY:
	// ÀûÀýÈ÷ ÇÔ¼ö¸¦ È°¿ë
		break;
	default: 
		break;
	}
}
void tSideMoveBlock (int map[][MAP_WIDTH], Block* current_block, int key_input)
{
	if(	key_input==LEFT_KEY && 
		!tIsTouchWall(current_block, LEFT_KEY) &&
		!tIsTouchSideFixedBlock(map, current_block, LEFT_KEY))
	{
		current_block->point_set[0].x -= 1;
		current_block->point_set[1].x -= 1;
		current_block->point_set[2].x -= 1;
		current_block->point_set[3].x -= 1;

		current_block->current_position.x -= 1;
	}
	else if(
		key_input==RIGHT_KEY && 
		!tIsTouchWall(current_block, RIGHT_KEY) &&
		!tIsTouchSideFixedBlock(map, current_block, RIGHT_KEY))
	{
		current_block->point_set[0].x += 1;
		current_block->point_set[1].x += 1;
		current_block->point_set[2].x += 1;
		current_block->point_set[3].x += 1;

		current_block->current_position.x += 1;
	}
}
void tDownMoveBlock (int map[][MAP_WIDTH], Block* current_block)
{
	if(!tIsTouchBottom(map, current_block))
	{
		current_block->point_set[0].y += 1;
		current_block->point_set[1].y += 1;
		current_block->point_set[2].y += 1;
		current_block->point_set[3].y += 1;
		current_block->current_position.y += 1;
	}
}

int tIsTouchWall (Block* current_block, int direction)
{
	int i;
	if(direction==LEFT_KEY)
	{
		for(i=0;i<4;i++){
			if(current_block->point_set[i].x<=0)
			{
				return 1;
			}
		}
		return 0;
	}
	else if(direction==RIGHT_KEY)
	{
		for(i=0;i<4;i++){
			if(current_block->point_set[i].x>=MAP_WIDTH-1)
			{
				return 1;
			}
		}
		return 0;
	}
}

int tIsTouchSideFixedBlock (int map[][MAP_WIDTH], Block* current_block, int direction)
{
	int i;
	if(direction==LEFT_KEY)
		for(i=0;i<4;i++)
		{
			if(map[current_block->point_set[i].y][current_block->point_set[i].x-1]==FIXED_SPACE)
			{
				return 1;
			}
		}
	else if(direction==RIGHT_KEY)
		for(i=0;i<4;i++)
		{
			if(map[current_block->point_set[i].y][current_block->point_set[i].x+1]==FIXED_SPACE)
			{
				return 1;
			}
		}
	return 0;
}

void tLotateBlock (int map[][MAP_WIDTH], Block* current_block)
{
	int i;
	Block temp_block = *current_block;
	
	current_block->block_dir = (current_block->block_dir+1)%4;
	current_block->point_set[0].x = block_set[current_block->block_diag][current_block->block_dir][0].x+current_block->current_position.x;
	current_block->point_set[0].y = block_set[current_block->block_diag][current_block->block_dir][0].y+current_block->current_position.y;
	current_block->point_set[1].x = block_set[current_block->block_diag][current_block->block_dir][1].x+current_block->current_position.x;
	current_block->point_set[1].y = block_set[current_block->block_diag][current_block->block_dir][1].y+current_block->current_position.y;
	current_block->point_set[2].x = block_set[current_block->block_diag][current_block->block_dir][2].x+current_block->current_position.x;
	current_block->point_set[2].y = block_set[current_block->block_diag][current_block->block_dir][2].y+current_block->current_position.y;
	current_block->point_set[3].x = block_set[current_block->block_diag][current_block->block_dir][3].x+current_block->current_position.x;
	current_block->point_set[3].y = block_set[current_block->block_diag][current_block->block_dir][3].y+current_block->current_position.y;
	
	for(i=0;i<4;i++)
	{
		if(current_block->point_set[i].x<0 || current_block->point_set[i].x>=10)
		{
			*current_block = temp_block;
			return;
		}
		if(map[current_block->point_set[i].y][current_block->point_set[i].x]==FIXED_SPACE)
		{
			*current_block = temp_block;
			return;
		}
	}
}

int tIsTouchBottom (int map[][MAP_WIDTH], Block* current_block)
{
	int i;
	for(i=0;i<4;i++)
	{
		if(map[current_block->point_set[i].y+1][current_block->point_set[i].x]==FIXED_SPACE
			|| current_block->point_set[i].y==MAP_HEIGHT-1)
		{
			return 1;
		}
	}
	return 0;
}

void tMovingBlock2FixedSpace (int map[][MAP_WIDTH], Block* current_block)
{
	int i;
	for(i=0;i<4;i++) map[current_block->point_set[i].y][current_block->point_set[i].x]=FIXED_SPACE;
}

void tManageBlockFlow(int map[][MAP_WIDTH], Block* new_block, Block* next_block, int speed, int score)
{
	int i;
	char key_input;
	Block current_block = *new_block;
	tPrintView(map,current_block, score, speed);
	while(TRUE)
	{
		for(i=0;i<speed+5;i++){ 
			Sleep(UNIT_SPEED);
			if(_kbhit())
			{
				key_input=_getch();
				if(key_input==-32)
					key_input=_getch();
				// Å°¿¡ ¸Â°Ô ºí·ÏÀ» ¿òÁ÷ÀÓ
			}
			
		} // UNIT_SPEED * speed ÀÇ ½Ã°£
		// ºí·ÏÀ» ÇÑÄ­ ³»¸²

		// while ³»ºÎ¿¡¼­ Àû´çÇÑ À§Ä¡¿¡
		// ºí·ÏÀÌ ¹Ù´Ú¿¡ Á¢ÃËÇßÀ» ¶§, ºí·ÏÀ» °íÁ¤ µÈ ¿µ¿ªÀ¸·Î ¹Ù²Ù°í, ÇÔ¼ö¸¦ Á¾·á½Ãų ¼ö ÀÖµµ·Ï ÇؾßÇÔ
		// ºí·ÏÀÇ º¯È­¿¡ µû¶ó tPrintView() ÇÔ¼ö·Î Ãâ·ÂÀ» ´Ù½Ã ÇØ¾ß ÇÔ
	}
}

void tBlockInitial (Block* block, int block_diag)
{
	block->block_diag = block_diag;
	block->block_dir = 0;
	block->current_position.x = 4;
	block->current_position.y = 1;

	block->point_set[0].x = block_set[block_diag][block->block_dir][0].x+block->current_position.x;
	block->point_set[0].y = block_set[block_diag][block->block_dir][0].y+block->current_position.y;
	block->point_set[1].x = block_set[block_diag][block->block_dir][1].x+block->current_position.x;
	block->point_set[1].y = block_set[block_diag][block->block_dir][1].y+block->current_position.y;
	block->point_set[2].x = block_set[block_diag][block->block_dir][2].x+block->current_position.x;
	block->point_set[2].y = block_set[block_diag][block->block_dir][2].y+block->current_position.y;
	block->point_set[3].x = block_set[block_diag][block->block_dir][3].x+block->current_position.x;
	block->point_set[3].y = block_set[block_diag][block->block_dir][3].y+block->current_position.y;
}

int tIsGameEnd (int map[][MAP_WIDTH])
{
	if(map[0][3]==FIXED_SPACE || map[0][4]==FIXED_SPACE || map[0][5]==FIXED_SPACE || map[0][6]==FIXED_SPACE) return 1;
	else return 0;
}

void tRunNormalGame ()
{
	int map[MAP_HEIGHT][MAP_WIDTH]={0};
	int score = 0;
	int speed=100;
	char player[NAME_LENGTH];
	Block tmp1,tmp2;

	srand(time(NULL));
	tBlockInitial(&tmp1,rand()%7);

	while(1){
		// ´ÙÀ½ºí·ÏÀ» »ý¼ºÇÏ°í,
		// ÇϳªÀÇ ºí·Ï¿¡ ´ëÇÑ È帧 °ü¸®(ÇÔ¼ö È°¿ë)
		// ¸Ê¿¡¼­ ¿Ï¼ºµÈ °¡·ÎÁÙ »èÁ¦ ¹× ½ºÄÚ¾î °»½Å
		 
		// (ºí·ÏÀÌ ¶³¾îÁö´Â ¼Óµµ¸¦ ÀÚÀ¯·Î¿î Á¶°Ç ÇÏ¿¡¼­ Á¶ÀýÇϵµ·Ï ÇÒ °Í)
		
		// °ÔÀÓÀÌ ³¡³µ´ÂÁö È®ÀÎÇÏ°í,
		// Ç÷¹À̾îÀÇ À̸§À» ÀԷ¹޾Æ
		// ½ºÄÚ¾î¿Í ÇÔ²² ScoreBoard.txt¿¡ ±â·Ï
		// ÀÌÈÄ Á¾·á
}

void tRunMapSelGame()
{
	// ´ë´Ù¼ö ±â´ÉÀº tRunNormalGame() ÇÔ¼ö¿Í µ¿ÀÏ
	// ºí·ÏÀ» »ý¼ºÇÏ¿© ¶³¾î¶ß¸®±â Àü¿¡, ¸Ê ÆÄÀÏÀ» ¼±ÅÃÇÏ¿© Àаí ÆÄÀÏ ³»¿ë¿¡ µû¶ó ¸ÊÀ» ¼öÁ¤
	// ½ºÄÚ¾î´Â ±â·ÏÇÏÁö ¾ÊÀ½
}

int tMakeMap (int map[][MAP_WIDTH])
{
	int x,y;
	char * file_name = selectMapList();
	FILE * fp = NULL;
	if(!file_name)
		return FALSE;
	fp = fopen(file_name,"r");
	if(fp==NULL)
	{ 
		printf("ÆÄÀÏÀÌ ¾ø½À´Ï´Ù.\n"); 
		fflush(stdin);
		getchar();
		return FALSE;
	}

	while(2==fscanf(fp,"%d,%d",&y,&x))
	{
		if(x>=0&&x<10&&y>=0&&y<20)
			map[y][x]=FIXED_SPACE;
	}
	return TRUE;
}

char* selectMapList ()
{
	int file_count=1, file_number;
	FILE * fp = fopen("mapList.txt","r");

	char * file_name = (char*)malloc(sizeof(char)*FILE_NAME_LENGTH);
	
	if(fp==NULL)
	{ 
		printf("ÆÄÀÏÀÌ ¾ø½À´Ï´Ù.\n");  
		fflush(stdin);
		getchar();
		return 0;
	}
	
	printf("------- Map List -------\n");
	while(fgets(file_name,FILE_NAME_LENGTH,fp)!=NULL)
		printf("%3d. %s",file_count++,file_name);
	printf("\n------------------------\n");
	rewind(fp);
	printf("Select File-Number : ");
	fflush(stdin);
	scanf("%d",&file_number);
	
	if((file_count<file_number+1)||(file_number<1)) return 0;

	while((--file_number)!=0)
		fgets(file_name,FILE_NAME_LENGTH,fp);
	fgets(file_name,FILE_NAME_LENGTH,fp);
	file_name[strlen(file_name)-1]=0;
	printf("%s",file_name);
	fclose(fp);

	return file_name;
}

void tViewScoreBoard()
{
	// ScoreBoard.txt ÆÄÀÏÀ» Àаí,
	// Çü½Ä¿¡ ¸Â°Ô ¼øÂ÷ÀûÀ¸·Î Ãâ·Â
}

void tAddScore(char* name, int score)
{
	int i,j,length=0;
	char name_list[LIST_LENGTH][NAME_LENGTH];
	int score_list[LIST_LENGTH];

	FILE * fp;

	// ScoreBoard.txt ÆÄÀÏÀ» Àаí,
	// ¼øÂ÷ÀûÀ¸·Î ¹è¿­¿¡ ÀúÀåÇÑ µÚ
	// ScoreBoard.txt ÆÄÀÏ¿¡ ÀçÀúÀå
	// ÀÎÀÚ·Î ¹ÞÀº ½ºÄھ ScoreBoard.txt¿¡ ±â·ÏµÈ ½ºÄھ´Ù ³ô´Ù¸é
	// ±× ÀÚ¸®¿¡ ÀÎÀÚ·Î ¹ÞÀº »ç¿ëÀÚ À̸§°ú ½ºÄھ ±â·ÏÇÏ°í,
	// Çϳª¾¿ ¹Ì·ç¾î ÀúÀå
	// Á¦ÇÑÀº 10°³¸¦ ³ÑÁö ¾Ê´Â´Ù.
}