//Written by Justin Todd.
//The code is well commented and I would recommend it to any beginners just learning to program games with allegro

#include<allegro.h>
#include"ttt.h"

int GameBoard[MAX_SQUARES][MAX_SQUARES];	//Create the gameboard array

void Change_Turn(){	//This function changes the turn.  ex. If it was just player X's turn, make it 0's 
	if(WhosTurn==PLAYER_X) WhosTurn=PLAYER_O;
		else WhosTurn=PLAYER_X;
}

int Check_Win(){	//Returns the winner
	for(x=PLAYER_X;x<=PLAYER_O;x++){
		//CHECK ROWS FOR A LINE
		if((GameBoard[0][0]==x)&&(GameBoard[1][0]==x)&&(GameBoard[2][0]==x)) return x;
		if((GameBoard[0][1]==x)&&(GameBoard[1][1]==x)&&(GameBoard[2][1]==x)) return x;
		if((GameBoard[0][2]==x)&&(GameBoard[1][2]==x)&&(GameBoard[2][2]==x)) return x;
		//CHECK COLUMNS FOR A LINE
		if((GameBoard[0][0]==x)&&(GameBoard[0][1]==x)&&(GameBoard[0][2]==x)) return x;
		if((GameBoard[1][0]==x)&&(GameBoard[1][1]==x)&&(GameBoard[1][2]==x)) return x;
		if((GameBoard[2][0]==x)&&(GameBoard[2][1]==x)&&(GameBoard[2][2]==x)) return x;
		//CHECK '\' DIAGONAL FOR A LINE
		if((GameBoard[0][0]==x)&&(GameBoard[1][1]==x)&&(GameBoard[2][2]==x)) return x;
		//CHECK '/' DIAGONAL FOR A LINE
		if((GameBoard[0][2]==x)&&(GameBoard[1][1]==x)&&(GameBoard[2][0]==x)) return x;
	}
	return FALSE;	//If nobody has won yet, return false
}

void Clear_GameBoard(){
	for(x=0;x<MAX_SQUARES;x++)
		for(y=0;y<MAX_SQUARES;y++) GameBoard[x][y]=0;	//Clear off the gameboard. (Reset all elements to 0)
}

void DeInit(){	//Unload allegro and destroy the virtual bitmap
	destroy_bitmap(Virtual);
	allegro_exit();
}

int Do_Computer_Move(){	//This function is really bulky, but I don't know any other way to do it this good.
// The defensive moves section is broken into 4 similar parts.  Im only going comment 2 of the 4 because they are neary identical
int Empty_X=0,Empty_O=0,X_Ctr=0,Done=0;
	//DEFENSIVE - Check to see if the computer is in danger of losing first before making an offensive move
	//CHECK DIAGONAL \ FOR POSSIBLE LOSS
	for(x=0;x<MAX_SQUARES;x++){	
		if(GameBoard[x][x]==EMPTY) Empty_X=x;	//record the position of the empty spot in this diagonal line
		else if(GameBoard[x][x]==PLAYER_X) X_Ctr++;	//Count how many x's are in this row
	}
	if((X_Ctr==MAX_SQUARES-1)&&(GameBoard[Empty_X][Empty_X]==EMPTY)){	//If there are 2 x's in this row then computer is in danger
		GameBoard[Empty_X][Empty_X]=PLAYER_O;	//Intercept the human move. (Put an O in the empty space, in order to block the x's)
		Change_Turn();	//Switch turns
		return 0;	//In this function, the returns are used only as a means of breaking from the loop
	}
	X_Ctr=0;	//Reset the counter
	//CHECK DIAGONAL / FOR POSSIBLE LOSS - For comments, refer to the above section
	for(x=0;x<MAX_SQUARES;x++){
		if(GameBoard[x][MAX_SQUARES-x-1]==EMPTY) Empty_X=x;
		else if(GameBoard[x][MAX_SQUARES-x-1]==PLAYER_X) X_Ctr++;
	}
	if((X_Ctr==MAX_SQUARES-1)&&(GameBoard[Empty_X][MAX_SQUARES-Empty_X-1]==EMPTY)){
		GameBoard[Empty_X][MAX_SQUARES-Empty_X-1]=PLAYER_O;
		Change_Turn();
		return 0;
	}
	X_Ctr=0;
	//CHECK COLUMNS FOR A POSSIBLE LOSS
	for(x=0;x<MAX_SQUARES;x++){	//Go through the columns 1 by 1
		for(y=0;y<MAX_SQUARES;y++){
			if(GameBoard[x][y]==EMPTY){	//if this position of the gameboard is empty...
				Empty_X=x;	//record the x-axis
				Empty_O=y;	//record the y-axis
			}else if(GameBoard[x][y]==PLAYER_X) X_Ctr++;	//If there is an x in this position, increment the counter
		}
		if((X_Ctr==MAX_SQUARES-1)&&(GameBoard[Empty_X][Empty_O]==EMPTY)){	//If there are 2 x's in this row...
			GameBoard[Empty_X][Empty_O]=PLAYER_O;	//Put an o in this position
			Change_Turn();	//Switch turns
			return 0;	//exit the function
		}
		X_Ctr=0;	//reset the counter
	}
	//CHECK ROWS FOR A POSSIBLE LOSS
	for(y=0;y<MAX_SQUARES;y++){
		for(x=0;x<MAX_SQUARES;x++){
			if(GameBoard[x][y]==EMPTY){
				Empty_X=x;
				Empty_O=y;
			}else if(GameBoard[x][y]==PLAYER_X) X_Ctr++;
		}
		if((X_Ctr==MAX_SQUARES-1)&&(GameBoard[Empty_X][Empty_O]==EMPTY)){
			GameBoard[Empty_X][Empty_O]=PLAYER_O;
			Change_Turn();
			return 0;
		}
		X_Ctr=0;
	}

	//RANDOM MOVE - If none of the above moves apply, move to a random empty space. This makes the computer appear more human-like
	while(Done!=TRUE){ //While an empty space hasn't been found yet...
		x=random()%MAX_SQUARES;	//make the x-axis a random number
		y=random()%MAX_SQUARES;	//make the y-axis a random number
		if(GameBoard[x][y]==EMPTY){	//If this randomly selected position is empty...
			GameBoard[x][y]=PLAYER_O;	//Place an o there
			Done=TRUE;	//exit the while loop...
		}	//...or else keep on going until an empty space is found
	}
	Change_Turn();	//Switch the turns
}

void Draw_GameBoard(){	//Draw the gameboard (#), the x's and the o's
	for(x=0;x<MAX_SQUARES;x++)
		for(y=0;y<MAX_SQUARES;y++){
			if(GameBoard[x][y]==PLAYER_X) draw_sprite(Virtual,(BITMAP *)DataFile[TTT_X].dat,x*SQUARE_SIZE,y*SQUARE_SIZE); //If this gameboard position contains PLAYER_X (1), Draw an x
			if(GameBoard[x][y]==PLAYER_O) draw_sprite(Virtual,(BITMAP *)DataFile[TTT_O].dat,x*SQUARE_SIZE,y*SQUARE_SIZE); //If this gameboard position contains PLAYER_O (2), Draw an o
			rect(Virtual,x*SQUARE_SIZE,y*SQUARE_SIZE,(x+1)*SQUARE_SIZE,(y+1)*SQUARE_SIZE,132);	//Draw the gameboard using seperate rectangles
		}
}

void Draw_Misc(){	//Draws the text 
	char Text_String[30];
	textout(Virtual,font,"CIPHERSOFT presents... Tic Tac Toe",310,1,15);
	textout(Virtual,font,"Programming and art by Justin Todd",310,20,15);
	textout(Virtual,font,"Copyright 2000 by Justin Todd",310,40,15);
	sprintf(Text_String,"Computer wins: %d\0",AI_Points);	//Write to a string instead of stdout, so that you can print integers on to the screen
	textout(Virtual,font,Text_String,450,300,15);	//Print out the computer points
	sprintf(Text_String,"Human wins: %d\0", Human_Points);	//Write the human points to a string
	textout(Virtual,font,Text_String,450,320,15);	//Print out the human points
}


void Draw_Selected_Square(){	//Draws the highlighted square
	rect(Virtual,Selected_H*SQUARE_SIZE,Selected_V*SQUARE_SIZE,(Selected_H+1)*SQUARE_SIZE,(Selected_V+1)*SQUARE_SIZE,16);	//Draw the gameboard using seperate rectangles
}

void Game_Init(){	//Resets all of the game variables.  Its like a restart_game kind of function
	Clear_GameBoard();	//clear off the gameboard (set all elements in GameBoard[][] to 0
	if(Winner!=FALSE) WhosTurn=Winner;	//Winner goes first
		else WhosTurn=PLAYER_X;	//if there is no winner yet then player x goes first
	Winner=FALSE;	//Reset the winner variable
}

void Init(){	//This function sets the palette, loads the graphics mode, etc.
	allegro_init();	//Initialize the Allegro graphics library
	install_keyboard();	//Install the Allegro keyboard routines
	set_gfx_mode(GFX_AUTODETECT,640,480,0,0);	//Set the graphics mode to 640x480
	Virtual=create_bitmap(SCREEN_W,SCREEN_H);	//Create virtual screen double buffer animation
	DataFile=load_datafile("ttt.dat");			//Load the datafile containing all of the sounds, bitmaps, etc
	Palette=(PALLETE *)DataFile[TTT_PAL].dat;	//Load the palette
	set_palette((RGB *)Palette);	//set the palette
	srandom(time(NULL));	//create a random seed
	text_mode(-1);	//passing -1 means that text background will be transparent
}

void Input(){
	if(key[KEY_ESC]) GameDone=TRUE;	//If the user hits escape, then set the gamedone to true
	if(key[KEY_R]) Game_Init();	//Restart the game if user hits r
	if((key[KEY_LEFT])&&(Selected_H>0)) Selected_H--;	//Move the highlighted square to the left if inbounds
	if((key[KEY_RIGHT])&&(Selected_H<MAX_SQUARES-1)) Selected_H++;	//Move the highlighted square to the right if inbounds
	if((key[KEY_UP])&&(Selected_V>0))Selected_V--;		//Move the highlighted square to the up if inbounds
	if((key[KEY_DOWN])&&(Selected_V<MAX_SQUARES-1)) Selected_V++;	//Move the highlighted square to the down if inbounds
	if((key[KEY_SPACE])&&(WhosTurn==PLAYER_X)&&(GameBoard[Selected_H][Selected_V]==EMPTY)){//If the user hits space and it's his/her turn, and the selected square is empty...
		GameBoard[Selected_H][Selected_V]=PLAYER_X;	//Put an x at the selected square
		Change_Turn();	//switch turns
	}
	clear_keybuf();	//Dissallow user to load up the keyboard buffer
}

int Is_GameBoard_Full(){	//If the gameboard is full, it returns true, if it isn't, it returns false
	for(x=0;x<MAX_SQUARES;x++)
		for(y=0;y<MAX_SQUARES;y++)
			if(GameBoard[x][y]==EMPTY) return FALSE;	//If there is an empty position, then the gameboard is not full
	return TRUE;	//If there are no empty positions then the gameboard is full
}

void Update_Game(){	//This function restarts the game if someone wins or if the gameboard is full
	int Restart_Flag;	//If set to true, Update_Game will restart
	Winner=Check_Win();	//Check for a win
	if(Winner==PLAYER_X){	//If x wins then restart
		textout(screen,font,"Player X wins!",1,1,15);	//Display the victory text string
		Human_Points++;	//If the user wins then increment his points
		Restart_Flag=TRUE;	//Set the restart flag to true
	}
	if(Winner==PLAYER_O){	//If o wins then restart
		textout(screen,font,"Player O wins!",1,1,15);	//Display the victory text
		AI_Points++;	//If the computer wins then increment its points
		Restart_Flag=TRUE;	//Set the restart flag to true
	}
	if(Is_GameBoard_Full()==TRUE) Restart_Flag=TRUE;	//If the gameboard is full, then restart
	if(Restart_Flag==TRUE){	//If the game needs to be restarted...
		textout(screen,font,"Press ENTER to restart...",100,100,15);	//Advise the user that he must hit enter to continue
		while(!key[KEY_ENTER]);	//Wait for user to hit enter
		Game_Init();	//Restart the game
		Restart_Flag=FALSE;	//Reset the flag
	}
}

void Update_Graphics(){	//blits the virtual screen to the screen
	vsync();	//Wait for the vertical retrace
	blit(Virtual,screen,0,0,0,0,SCREEN_W,SCREEN_H);	
	clear_to_color(Virtual,24);	//Clear the virtual screen
}