#include<stdio.h>	//fopen, fread, fclose, exit
#include<allegro.h>
#include"justris.h"

FILE *File;	//Binary file for storing high scores

void Check_Line(){
	int Is_Line,z;  //Flag to detect a line and a third counter
	for(y=GAMEBOARD_HIEGHT-1;y>=0;y--){	//Go through gameboard row by row
		Is_Line=1;	//Default the line flag to true
		for(x=0;x<GAMEBOARD_WIDTH;x++)		//Check for a line
			if(GameBoard[x][y]==0)	//If there is an empty space in the row, than it isnt a line
				Is_Line=0;	
			if(Is_Line==1){	//if it is a line, move the above lines down one
				play_sample((SAMPLE *)DataFile[LINE_SOUND].dat,255,128,1000,0);	//Play the line sound effect
				Stats.Lines++;	//increase points.
				Stats.Line_Ctr++;	//increase the line counter
				for(z=y;z>0;z--)	//Move all the lines above the complete line down one position
					for(x=0;x<GAMEBOARD_WIDTH;x++)
						GameBoard[x][z]=GameBoard[x][z-1];
			}
		Is_Line=1;	//Reset the line flag
	}
}

int Choose_Random_Piece(){	//This function returns a random number excluding 0 or numbers > 7
	return 1+random()%MAX_PIECES;	//Randomly choose piece type between 1 and 7
}

void Clear_GameBoard_Array(){	//This function clears off the gameboard
	for(x=0;x<GAMEBOARD_WIDTH;x++)
		for(y=0;y<GAMEBOARD_HIEGHT;y++)
			GameBoard[x][y]=0;	//Clear off the blocks (ones) from the gameboard
}

void Clear_Piece_Array(struct Piece_Struct *Ptr){	//Clears the piece array.  Arguement is either Next or Current
	for(x=0;x<MAX_PIECE_SIZE;x++)
		for(y=0;y<MAX_PIECE_SIZE;y++)
			Ptr->Block[x][y]=0;	//clear away blocks contents
}

void Collision_Detection(){	//Contains a little bit of the collision detection
	if((Piece.YPos+Piece.YSize)>GAMEBOARD_HIEGHT){	//If Piece hits the bottom, or goes through the bottom
		Piece.YPos=GAMEBOARD_HIEGHT-Piece.YSize;		//Place place piece on the bottom
		Put_Block();	//Copy the piece array to the gameboard
	}
	for(x=0;x<Piece.XSize;x++)	//Check to see if the live piece lands on a dead one
		for(y=0;y<Piece.YSize;y++)
			if((GameBoard[Piece.XPos+x][Piece.YPos+y]==1)&&(Piece.Block[x][y]==1)){	//If the piece lands on another, copy the piece to the gameboard
				Piece.YPos-=1;
				Put_Block();	//If block lands on another block...
			}
}

void DeInit(){
	play_sample((SAMPLE *)DataFile[SHUTDOWN_SOUND].dat,255,128,1000,0);	//Play the sound effect
	File=fopen("hiscores.dat","wb");
	fwrite(&HighScore,sizeof(struct HighScore_Struct),MAX_HIGHSCORES,File);	//Write the updated highscores to file
	fclose(File);
	//Clean up
	Draw_HighScores();
	destroy_bitmap(Virtual);
	unload_datafile(DataFile);
	exit(0);
}

void Draw_Piece(){		//Loops through the piece array.  When it sees a 1, it draws a block
	for(y=0;y<Piece.YSize;y++)
		for(x=0;x<Piece.XSize;x++)
			if(Piece.Block[x][y]==1)	//If there is a one at this position...
				draw_sprite(Virtual,(BITMAP *)DataFile[BLOCK].dat,(Piece.XPos+x+GAMEBOARD_XPOS)*BLOCK_SIZE,(Piece.YPos+y+GAMEBOARD_YPOS)*BLOCK_SIZE); //Draw a block
}

void Draw_GameBoard(){	//Draws the gameboard background and the blocks on the gameboard
	rectfill(Virtual,GAMEBOARD_XPOS*BLOCK_SIZE,GAMEBOARD_YPOS*BLOCK_SIZE,(GAMEBOARD_WIDTH+GAMEBOARD_XPOS)*BLOCK_SIZE,(GAMEBOARD_HIEGHT+GAMEBOARD_YPOS)*BLOCK_SIZE,GAMEBOARD_COLOR); //Draws a simple rectangle for the background
	for(x=0;x<GAMEBOARD_WIDTH;x++)	//Loop through the gameboard array, and draw a block if the array element is 1
		for(y=0;y<GAMEBOARD_HIEGHT;y++)
			if(GameBoard[x][y]==1)	//If it sees a 1 on the gameboard, it draws a block
				draw_sprite(Virtual,(BITMAP *)DataFile[BLOCK].dat,(GAMEBOARD_XPOS+x)*BLOCK_SIZE,(GAMEBOARD_YPOS+y)*BLOCK_SIZE);
}

void Draw_HighScores(void){	
	clear(screen);	//Clear the screen
	for(x=0;x<MAX_HIGHSCORES;x++){	//Loop through and draw the highscores
		sprintf(Text_String,"%d. %s",x+1,HighScore[x].Name);
		textout(screen,Tech_Font,Text_String,1,x*40,96+x);	//Display the name
		sprintf(Text_String,"%d",HighScore[x].Points);
		textout(screen,Tech_Font,Text_String,300,x*40,96+x);	//Display the points
	}
	clear_keybuf();
	readkey();	//Wait for user to strike a key
}

void Draw_Misc(){	//Pretty basic.  This function just displays the game info. 
	sprintf(Text_String,"Level %d",Stats.Level);
	textout(Virtual,Tech_Font,Text_String,STAT_XPOS,STAT_YPOS,96);
	sprintf(Text_String,"Lines %d",Stats.Lines);
	textout(Virtual,Tech_Font,Text_String,STAT_XPOS,STAT_YPOS+20,99);
	sprintf(Text_String,"Points %d",Stats.Points);
	textout(Virtual,Tech_Font,Text_String,STAT_XPOS,STAT_YPOS+40,102);
	textout(Virtual,Tech_Font,"Next Piece:",STAT_XPOS,STAT_YPOS+60,104);
	for(y=0;y<MAX_PIECE_SIZE;y++)	//Go through the 'next piece' array and draw it
		for(x=0;x<MAX_PIECE_SIZE;x++)
			if(Next_Piece.Block[x][y]==1)
				draw_sprite(Virtual,(BITMAP *)DataFile[BLOCK].dat,(STAT_XPOS)+x*BLOCK_SIZE,(STAT_YPOS+80)+y*BLOCK_SIZE); //Draw a block
	textout(Virtual,Tech_Font,"JusTris - JUStin's teTRIS",STAT_XPOS-100,STAT_YPOS+240,96);
	textout(Virtual,Tech_Font,"By CipherSoft",STAT_XPOS-100,STAT_YPOS+260,99);
	textout(Virtual,Tech_Font,"http://justin-todd.tripod.com ",STAT_XPOS-100,STAT_YPOS+280,102);
	textout(Virtual,Tech_Font,"Music by Justin Todd",STAT_XPOS-100,STAT_YPOS+300,104);
	textout(Virtual,Tech_Font,"Use J,K,L,I to move the gameboard around",STAT_XPOS-300,STAT_YPOS+450,99);
}

void Enter_HighScore(){
	char ch;
	clear(screen);
	textout(screen,Tech_Font,"Please enter your name:",1,1,96);
	strcpy(Text_String,"Your Name Here");
	textout(screen,Tech_Font,Text_String,1,40,103);	//Display the string
	x=14;
	while(!key[KEY_ENTER]){
		ch=0;	//imitates a key buffer clear
		ch=readkey();
		if((key[KEY_ENTER])||(key[KEY_ESC])) break;
		if(key[KEY_BACKSPACE]){
			if(x>0) x--;	//If the cursor is inside the textfield then decrease the cursor position
			Text_String[x]=' ';
			ch=0;
		}if(x>=17){	//If text exits textfield
			Text_String[x]=' ';
			x=17;	//Put the cursor position inside the textfield
		}if(ch!=0){
			play_sample((SAMPLE *)DataFile[KEYBOARD_SOUND].dat,255,128,1000,0);	//Play the sound effect
			Text_String[x]=ch;	//Make the string position equal the key enter
			x++;	//increment the string position
		}
		Text_String[x+1]='\0';
		textout(screen,Tech_Font,Text_String,1,40,96+(x*0.5));	//Display the string
	}
	//Place this highscore in the right order
	for(x=0;x<MAX_HIGHSCORES;x++){
		if(Stats.Points>HighScore[x].Points){	//If users score is greater than current highscore...
			for(y=MAX_HIGHSCORES-1;y>=x;y--){	//Move entries below it down one
				strcpy(HighScore[y].Name,HighScore[y-1].Name);
				HighScore[y].Points=HighScore[y-1].Points;
			}
			HighScore[x].Points=Stats.Points;	//Put the users score in the current highscore position
			strcpy(HighScore[x].Name,Text_String);	//Put the users name in the current highscore position
			break;
		}
	}
}

int Find_Piece_XSize(){	//This function returns the X-size of the piece
	for(x=MAX_PIECE_SIZE-1;x>=0;x--)
		for(y=0;y<MAX_PIECE_SIZE;y++)
			if(Piece.Block[x][y]==1) return x+1; //If a 1 is in the row, than return the number of columns
}

int Find_Piece_YSize(){	////This function returns the Y-size of the piece
	for(y=MAX_PIECE_SIZE-1;y>=0;y--)
		for(x=0;x<MAX_PIECE_SIZE;x++)
			if(Piece.Block[x][y]==1) return y+1; //If a 1 is in the row, than return the number of rows
}

void Game_Init(){		//Starts a new game.  Basicly resets all the variables
	if(Stats.Points>HighScore[MAX_HIGHSCORES-1].Points){	//If the users points are greater than the lowest highscore...
		Enter_HighScore();	//Enter this user into the highscore table
		Draw_HighScores();	//Display the highscores
	}
	Stats.Level=1;	//Starting level is 1
	Stats.Lines=0;	//Reset the varables to 0
	Stats.Line_Ctr=0;
	Game_Timer=0;
	Clear_GameBoard_Array();	//Clear off the gameboard array
	//Make the next and current pieces
	Next_Piece.Kind=Choose_Random_Piece();
	Piece.Kind=Next_Piece.Kind;
	Make_Piece(&Piece);
	Next_Piece.Kind=Choose_Random_Piece();
	Make_Piece(&Next_Piece);
}

void Game_Stats(){	//This function takes care of all of the game stats such as current level, points and total lines
	if(Stats.Line_Ctr>=20){	//If the user gets 20 lines...
		Stats.Level++;	//...Increase the level
		Stats.Line_Ctr=0;	//and reset the line counter
	}
	Stats.Points=Stats.Lines*50;			//make a line worth 50 points
	if(Stats.Level==10) Stats.Level=1;		//When Stats.Level = ten, restart at Stats.Level one
}


void Init(){
	allegro_init();
	install_keyboard();
	set_gfx_mode(GFX_AUTODETECT,640,480,0,0);	//Set graphics mode to 640x480
	detect_digi_driver(DIGI_AUTODETECT);
	install_sound(DIGI_AUTODETECT,MIDI_AUTODETECT,NULL);	//Install sound driver

	Virtual=create_bitmap(SCREEN_W,SCREEN_H);	//Create virtual screen double buffer animation
	DataFile=load_datafile("justris.dat");		//Load the datafile containing all of the sounds, bitmaps, etc
	Tech_Font=(FONT *)DataFile[INTELL_FONT].dat;
	Palette=(PALLETE *)DataFile[GAME_PAL].dat;
	set_palette((RGB *)Palette);
		
	srandom(time(NULL));	//create a random seed
	
	File=fopen("hiscores.dat","rb");	//Open file for reading
	if(File){	//If the file exists, copy the saved highscores into the highscore structure
		fread(&HighScore,sizeof(struct HighScore_Struct),MAX_HIGHSCORES,File);	//Read the file into the highscore structure
		fclose(File);	//Close the file
	}
	else for(x=0;x<10;x++)	//If the file doesn't exist, fill the highscores with some information
			HighScore[x].Points=(10-x)*1000;
	play_midi((MIDI *)DataFile[SONG_MIDI].dat,1);	//Play the midi song in the background continuosly
}

void Input(){	//This function deals with the users input, and also does a bit of collision detection
	int CanMove=1;
	if((key[KEY_Q])||(key[KEY_ESC])) GameDone=1;	//set the gamedone flag to 1 if user hits escape or Q
	if(key[KEY_R]) Game_Init();	//Restart the game if 'R' is pressed
	if(key[KEY_UP])	Rotate_Piece();	//If user hits the up arrow, rotate the piece clockwise
	if(key[KEY_H]) Draw_HighScores();
	
	if(key[KEY_J])	//Move the gameboard left
		if(GAMEBOARD_XPOS>0) --GAMEBOARD_XPOS;
	if(key[KEY_L])	//Move the gameboard right
		if(GAMEBOARD_XPOS<SCREEN_W/BLOCK_SIZE-GAMEBOARD_WIDTH) ++GAMEBOARD_XPOS;
	if(key[KEY_I])	//Move the gameboard up
		if(GAMEBOARD_YPOS>0) --GAMEBOARD_YPOS;
	if(key[KEY_K])	///Move the gameboard down
		if(GAMEBOARD_YPOS<SCREEN_H/BLOCK_SIZE-GAMEBOARD_HIEGHT) ++GAMEBOARD_YPOS;
	
	if(key[KEY_M]){	//Music toggle
		if(Paused==1){	//if the music is paused, unpause it
			midi_resume();
			Paused=0;
		}
		else if(Paused==0){	//If the music isnt paused, pause it
			midi_pause();
			Paused=1;
		}
	}
	if(key[KEY_RIGHT]){
		for(x=0;x<Piece.XSize;x++)//Check to see if there is a block blocking the blocks path
			for(y=0;y<Piece.YSize;y++)
				if((GameBoard[Piece.XPos+x+1][Piece.YPos+y]==1)&&(Piece.Block[x][y]==1)) CanMove=0;
		if((Piece.XPos+Piece.XSize)>=GAMEBOARD_WIDTH) CanMove=0;	//Don't let the piece leave the boundries
		if(CanMove==1) Piece.XPos+=1;	//If there isn't a block blocking the block, than move the block
	}
	if(key[KEY_LEFT]){
		for(x=0;x<Piece.XSize;x++)	//First, check and see if the move is possible
			for(y=0;y<Piece.YSize;y++)
				if((GameBoard[Piece.XPos+x-1][Piece.YPos+y]==1)&&(Piece.Block[x][y]==1)) CanMove=0;	//If there is a block to the left of the piece, disallow player to move
		if(Piece.XPos<=0) CanMove=0;	//Don't let the piece leave the boundries
		if(CanMove==1) Piece.XPos-=1; //If nothing is in the way of the piece, then move the piece to the left one position
	}
	//MOVES PIECE DOWN
	if(key[KEY_DOWN]) Piece.YPos++;
		else if(Game_Timer<50-Stats.Level*5) Game_Timer++;	//If the block is not ready to drop, increment timer
			else if(Game_Timer>=50-Stats.Level*5){	//If the timer is >= than it should be...
					Piece.YPos+=1;	//...Than drop the piece,
					Game_Timer=0;	//and reset the counter
			}
	clear_keybuf();	//Clearing the keyboard buffer seems to slow things down a bit, because then the user can't load the buffer with keys
}

void Make_Piece(struct Piece_Struct *Ptr){	//This function fills certain parts of the block structure with ones, making a piece
	Clear_Piece_Array(Ptr);
	switch(Ptr->Kind){
		case 1: Ptr->Block[0][0]=Ptr->Block[0][1]=Ptr->Block[0][2]=Ptr->Block[0][3]=1;break; //Long shape
		case 2: Ptr->Block[0][0]=Ptr->Block[1][0]=Ptr->Block[0][1]=Ptr->Block[1][1]=1;break; //Box shape
		case 3: Ptr->Block[0][0]=Ptr->Block[0][1]=Ptr->Block[0][2]=Ptr->Block[1][2]=1;break; //L-Shape
		case 4: Ptr->Block[1][0]=Ptr->Block[1][1]=Ptr->Block[1][2]=Ptr->Block[0][2]=1;break; //Backwards L
		case 5: Ptr->Block[0][0]=Ptr->Block[1][0]=Ptr->Block[2][0]=Ptr->Block[1][1]=1;break; //T-shape
		case 6: Ptr->Block[1][0]=Ptr->Block[2][0]=Ptr->Block[0][1]=Ptr->Block[1][1]=1;break; //_/- shape
		case 7: Ptr->Block[0][0]=Ptr->Block[1][0]=Ptr->Block[1][1]=Ptr->Block[2][1]=1;break; //-\_ shape
	}
	Ptr->XSize=Find_Piece_XSize();	//Find the x size of the piece
	Ptr->YSize=Find_Piece_YSize();	//Find the y size of the piece
	Ptr->YPos=0;	//Put the piece on the top part of the gameboard
	Ptr->XPos=4;	//Place it kind of in the middle
	for(x=0;x<Piece.XSize;x++)		//Check to see if the piece can be placed on the gameboard
		for(y=0;y<Piece.YSize;y++)
			if((GameBoard[4+x][0+y]==1)&&(Piece.Block[x][y]==1)){
				play_sample((SAMPLE *)DataFile[CRY_SOUND].dat,255,128,1000,0);	//Play the crying sound effect
				Game_Init();	//Restart the game
				break;
			}

}

void Put_Block(){
	play_sample((SAMPLE *)DataFile[POP_SOUND].dat,255,128,1000,0);	//Play the sound effect
	for(x=0;x<Piece.XSize;x++)	//Go through the piece and copy it to the gameboard
		for(y=0;y<Piece.YSize;y++)
			if(Piece.Block[x][y]==1) GameBoard[Piece.XPos+x][Piece.YPos+y]=1;  //Copy the piece to the gameboard
	Piece.Kind=Next_Piece.Kind;	//The next four lines basicly create a new piece
	Next_Piece.Kind=Choose_Random_Piece();
	Make_Piece(&Next_Piece);	//Make the next piece
	Make_Piece(&Piece);  //Create a new piece
}

int Rotate_Piece(){ //Rotates a piece. This is my favorite function.
	int Temp,TempPiece[MAX_PIECE_SIZE][MAX_PIECE_SIZE];
	Temp=Piece.XSize;	//Temp int for future swap
	if((Piece.XPos+Piece.YSize>GAMEBOARD_WIDTH)||(Piece.YPos+Piece.XSize>GAMEBOARD_HIEGHT)) return 0;	//If rotation will put the piece out of bounds, exit the	
	for(x=0;x<Piece.XSize;x++)
		for(y=0;y<Piece.YSize;y++){
			TempPiece[Piece.YSize-1-y][x]=Piece.Block[x][y];	//Copy the current horizontal row into the tempPiece vertical row
			if((GameBoard[Piece.XPos+y][Piece.YPos+x]==1)&&(TempPiece[y][x]==1)) return 0;	//If the new piece rotation conflicts with a 'dead' piece, than exit the function before it rotates the piece	
		}			
	Piece.XSize=Piece.YSize;	//Swap the X and Y Sizes
	Piece.YSize=Temp;	
	Clear_Piece_Array(&Piece);	//Clear the piece array
	for(x=0;x<Piece.XSize;x++)
		for(y=0;y<Piece.YSize;y++)
			Piece.Block[x][y]=TempPiece[x][y];	//Copy the new rotated piece from the temp_piece_array to the piece array
}

void Update_Graphics(){	//This function copies the virtual screen to the actual screen
	vsync();	//Wait for the vertical retrace
	if(key[KEY_S]) save_bmp("ScrShot.bmp",Virtual,NULL);	//Saves virtual screen to file (Screenshot)
	blit(Virtual,screen,0,0,0,0,SCREEN_W,SCREEN_H);	//Blit the virtual screen to the screen
	clear(Virtual);	//Clear the virtual screen
}