REGISTER_MINIGAME(ttt, "Tic Tac Toe");

const int TTT_TURN_PLACE = 0x0100; // player has to place a piece on the board
const int TTT_TURN_WIN   = 0x0200; // player has won
const int TTT_TURN_DRAW  = 0x0400; // no moves are possible
const int TTT_TURN_NEXT  = 0x0800; // a player wants to start a new match
const int TTT_TURN_TYPE  = 0x0f00; // turn type mask

const int TTT_TURN_TEAM1 = 0x0001;
const int TTT_TURN_TEAM2 = 0x0002;
const int TTT_TURN_TEAM  = 0x000f; // turn team mask

// send flags
const int TTT_SF_PLAYERSCORE  = MINIG_SF_CUSTOM;   // send minigame_player scores (won matches)
const int TTT_SF_SINGLEPLAYER = MINIG_SF_CUSTOM<<1;// send minigame.ttt_ai

const int TTT_LET_CNT = 3;
const int TTT_NUM_CNT = 3;
const int TTT_TILE_SIZE = 3;

.int ttt_npieces; // (minigame) number of pieces on the board (simplifies checking a draw)
.int ttt_nexteam; // (minigame) next team (used to change the starting team on following matches)
.int ttt_ai;      // (minigame) when non-zero, singleplayer vs AI

// find tic tac toe piece given its tile name
entity ttt_find_piece(entity minig, string tile)
{
	entity e = NULL;
	while ( ( e = findentity(e,owner,minig) ) )
		if ( e.classname == "minigame_board_piece" && e.netname == tile )
			return e;
	return NULL;
}

// Checks if the given piece completes a row
bool ttt_winning_piece(entity piece)
{
	int number = minigame_tile_number(piece.netname);
	int letter = minigame_tile_letter(piece.netname);

	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,number)).team == piece.team )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,number)).team == piece.team )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,number)).team == piece.team )
		return true;

	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,0)).team == piece.team )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,1)).team == piece.team )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,2)).team == piece.team )
		return true;

	if ( number == letter )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,0)).team == piece.team )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,1)).team == piece.team )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,2)).team == piece.team )
		return true;

	if ( number == 2-letter )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,2)).team == piece.team )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,1)).team == piece.team )
	if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,0)).team == piece.team )
		return true;

	return false;
}

// check if the tile name is valid (3x3 grid)
bool ttt_valid_tile(string tile)
{
	if ( !tile )
		return 0;
	int number = minigame_tile_number(tile);
	int letter = minigame_tile_letter(tile);
	return 0 <= number && number < TTT_NUM_CNT && 0 <= letter && letter < TTT_LET_CNT;
}

// make a move
void ttt_move(entity minigame, entity player, string pos )
{
	if ( minigame.minigame_flags & TTT_TURN_PLACE )
	if ( pos && player.team == (minigame.minigame_flags & TTT_TURN_TEAM) )
	{
		if ( ttt_valid_tile(pos) )
		if ( !ttt_find_piece(minigame,pos) )
		{
			entity piece = msle_spawn(minigame,"minigame_board_piece");
			piece.team = player.team;
			piece.netname = strzone(pos);
			minigame_server_sendflags(piece,MINIG_SF_ALL);
			minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
			minigame.ttt_npieces++;
			minigame.ttt_nexteam = minigame_next_team(player.team,2);
			if ( ttt_winning_piece(piece) )
			{
				player.minigame_flags++;
				minigame_server_sendflags(player, TTT_SF_PLAYERSCORE);
				minigame.minigame_flags = TTT_TURN_WIN | player.team;
			}
			else if ( minigame.ttt_npieces >= (TTT_LET_CNT * TTT_NUM_CNT) )
				minigame.minigame_flags = TTT_TURN_DRAW;
			else
				minigame.minigame_flags = TTT_TURN_PLACE | minigame.ttt_nexteam;
		}
	}
}

// request a new match
void ttt_next_match(entity minigame, entity player)
{
#ifdef SVQC
	// on multiplayer matches, wait for both players to agree
	if ( minigame.minigame_flags & (TTT_TURN_WIN|TTT_TURN_DRAW) )
	{
		minigame.minigame_flags = TTT_TURN_NEXT | player.team;
		minigame.SendFlags |= MINIG_SF_UPDATE;
	}
	else if ( (minigame.minigame_flags & TTT_TURN_NEXT) &&
			!( minigame.minigame_flags & player.team ) )
#endif
	{
		minigame.minigame_flags = TTT_TURN_PLACE | minigame.ttt_nexteam;
		minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
		minigame.ttt_npieces = 0;
		entity e = NULL;
		while ( ( e = findentity(e,owner,minigame) ) )
			if ( e.classname == "minigame_board_piece" )
				remove(e);
	}
}

#ifdef SVQC


// required function, handle server side events
int ttt_server_event(entity minigame, string event, ...)
{
	switch(event)
	{
		case "start":
		{
			minigame.minigame_flags = (TTT_TURN_PLACE | TTT_TURN_TEAM1);
			return true;
		}
		case "end":
		{
			entity e = NULL;
			while( (e = findentity(e, owner, minigame)) )
			if(e.classname == "minigame_board_piece")
			{
				if(e.netname) { strunzone(e.netname); }
				remove(e);
			}
			return false;
		}
		case "join":
		{
			int pl_num = minigame_count_players(minigame);

			// Don't allow joining a single player match
			if ( (minigame.ttt_ai) && pl_num > 0 )
				return false;

			// Don't allow more than 2 players
			if(pl_num >= 2) { return false; }

			// Get the right team
			if(minigame.minigame_players)
				return minigame_next_team(minigame.minigame_players.team, 2);

			// Team 1 by default
			return 1;
		}
		case "cmd":
		{
			switch(argv(0))
			{
				case "move":
					ttt_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
					return true;
				case "next":
					ttt_next_match(minigame,...(0,entity));
					return true;
				case "singleplayer":
					if ( minigame_count_players(minigame) == 1 )
					{
						minigame.ttt_ai = minigame_next_team(minigame.minigame_players.team, 2);
						minigame.SendFlags = TTT_SF_SINGLEPLAYER;
					}
					return true;
			}

			return false;
		}
		case "network_send":
		{
			entity sent = ...(0,entity);
			int sf = ...(1,int);
			if ( sent.classname == "minigame_player" && (sf & TTT_SF_PLAYERSCORE ) )
			{
				WriteByte(MSG_ENTITY,sent.minigame_flags);
			}
			else if ( sent.classname == "minigame" && (sf & TTT_SF_SINGLEPLAYER) )
			{
				WriteByte(MSG_ENTITY,sent.ttt_ai);
			}
			return false;
		}
	}

	return false;
}


#elif defined(CSQC)

string ttt_curr_pos; // identifier of the tile under the mouse
vector ttt_boardpos; // HUD board position
vector ttt_boardsize;// HUD board size
.int ttt_checkwin; // Used to optimize checks to display a win

// Required function, draw the game board
void ttt_hud_board(vector pos, vector mySize)
{
	minigame_hud_fitsqare(pos, mySize);
	ttt_boardpos = pos;
	ttt_boardsize = mySize;

	minigame_hud_simpleboard(pos,mySize,minigame_texture("ttt/board"));

	vector tile_size = minigame_hud_denormalize_size('1 1 0'/TTT_TILE_SIZE,pos,mySize);
	vector tile_pos;

	if ( (active_minigame.minigame_flags & TTT_TURN_TEAM) == minigame_self.team )
	if ( ttt_valid_tile(ttt_curr_pos) )
	{
		tile_pos = minigame_tile_pos(ttt_curr_pos,TTT_LET_CNT,TTT_NUM_CNT);
		tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
		minigame_drawpic_centered( tile_pos,
				minigame_texture(strcat("ttt/piece",ftos(minigame_self.team))),
				tile_size, '1 1 1', panel_fg_alpha/2, DRAWFLAG_NORMAL );
	}

	entity e;
	FOREACH_MINIGAME_ENTITY(e)
	{
		if ( e.classname == "minigame_board_piece" )
		{
			tile_pos = minigame_tile_pos(e.netname,TTT_LET_CNT,TTT_NUM_CNT);
			tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);

			if ( active_minigame.minigame_flags & TTT_TURN_WIN )
			if ( !e.ttt_checkwin )
				e.ttt_checkwin = ttt_winning_piece(e) ? 1 : -1;

			float icon_color = 1;
			if ( e.ttt_checkwin == -1 )
				icon_color = 0.4;
			else if ( e.ttt_checkwin == 1 )
			{
				icon_color = 2;
				minigame_drawpic_centered( tile_pos, minigame_texture("ttt/winglow"),
						tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_ADDITIVE );
			}

			minigame_drawpic_centered( tile_pos,
					minigame_texture(strcat("ttt/piece",ftos(e.team))),
					tile_size, '1 1 1'*icon_color, panel_fg_alpha, DRAWFLAG_NORMAL );
		}
	}
}


// Required function, draw the game status panel
void ttt_hud_status(vector pos, vector mySize)
{
	HUD_Panel_DrawBg(1);
	vector ts;
	ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
		hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);

	pos_y += ts_y;
	mySize_y -= ts_y;

	vector player_fontsize = hud_fontsize * 1.75;
	ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
	ts_x = mySize_x;
	vector mypos;
	vector tile_size = '48 48 0';

	entity e;
	FOREACH_MINIGAME_ENTITY(e)
	{
		if ( e.classname == "minigame_player" )
		{
			mypos = pos;
			if ( e.team == 2 )
				mypos_y  += player_fontsize_y + ts_y;
			minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
				(e.minigame_playerslot ? entcs_GetName(e.minigame_playerslot-1) : _("AI")),
				player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);

			mypos_y += player_fontsize_y;
			drawpic( mypos,
					minigame_texture(strcat("ttt/piece",ftos(e.team))),
					tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );

			mypos_x += tile_size_x;

			drawstring(mypos,ftos(e.minigame_flags),tile_size,
					   '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
		}
	}
}

// Turn a set of flags into a help message
string ttt_turn_to_string(int turnflags)
{
	if ( turnflags & TTT_TURN_DRAW )
		return _("Draw");

	if ( turnflags & TTT_TURN_WIN )
	{
		if ( (turnflags&TTT_TURN_TEAM) != minigame_self.team )
			return _("You lost the game!\nSelect \"^1Next Match^7\" on the menu for a rematch!");
		return _("You win!\nSelect \"^1Next Match^7\" on the menu to start a new match!");
	}

	if ( turnflags & TTT_TURN_NEXT )
	{
		if ( (turnflags&TTT_TURN_TEAM) != minigame_self.team )
			return _("Select \"^1Next Match^7\" on the menu to start a new match!");
		return _("Wait for your opponent to confirm the rematch");
	}

	if ( (turnflags & TTT_TURN_TEAM) != minigame_self.team )
		return _("Wait for your opponent to make their move");

	if ( turnflags & TTT_TURN_PLACE )
		return _("Click on the game board to place your piece");

	return "";
}

const int TTT_AI_POSFLAG_A1 = 0x0001;
const int TTT_AI_POSFLAG_A2 = 0x0002;
const int TTT_AI_POSFLAG_A3 = 0x0004;
const int TTT_AI_POSFLAG_B1 = 0x0008;
const int TTT_AI_POSFLAG_B2 = 0x0010;
const int TTT_AI_POSFLAG_B3 = 0x0020;
const int TTT_AI_POSFLAG_C1 = 0x0040;
const int TTT_AI_POSFLAG_C2 = 0x0080;
const int TTT_AI_POSFLAG_C3 = 0x0100;

// convert a flag to a position
string ttt_ai_piece_flag2pos(int pieceflag)
{
	switch(pieceflag)
	{
		case TTT_AI_POSFLAG_A1:
			return "a1";
		case TTT_AI_POSFLAG_A2:
			return "a2";
		case TTT_AI_POSFLAG_A3:
			return "a3";

		case TTT_AI_POSFLAG_B1:
			return "b1";
		case TTT_AI_POSFLAG_B2:
			return "b2";
		case TTT_AI_POSFLAG_B3:
			return "b3";

		case TTT_AI_POSFLAG_C1:
			return "c1";
		case TTT_AI_POSFLAG_C2:
			return "c2";
		case TTT_AI_POSFLAG_C3:
			return "c3";

		default:
			return string_null;
	}
}

bool ttt_ai_checkmask(int piecemask, int checkflags)
{
	return checkflags && (piecemask & checkflags) == checkflags;
}

// get the third flag if the mask matches two of them
int ttt_ai_1of3(int piecemask, int flag1, int flag2, int flag3)
{
	if ( ttt_ai_checkmask(piecemask,flag1|flag2|flag3) )
		return 0;

	if ( ttt_ai_checkmask(piecemask,flag1|flag2) )
		return flag3;

	if ( ttt_ai_checkmask(piecemask,flag3|flag2) )
		return flag1;

	if ( ttt_ai_checkmask(piecemask,flag3|flag1) )
		return flag2;

	return 0;
}

// Select a random flag in the mask
int ttt_ai_random(int piecemask)
{
	if ( !piecemask )
		return 0;

	int f = 1;

	RandomSelection_Init();

	for ( int i = 0; i < 9; i++ )
	{
		if ( piecemask & f )
			RandomSelection_Add(NULL, f, string_null, 1, 1);
		f <<= 1;
	}

	LOG_TRACE(sprintf("TTT AI: selected %x from %x\n",
			RandomSelection_chosen_float, piecemask) );
	return RandomSelection_chosen_float;
}

// Block/complete a 3 i na row
int ttt_ai_block3 ( int piecemask, int piecemask_free )
{
	int r = 0;

	r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A1,TTT_AI_POSFLAG_A2,TTT_AI_POSFLAG_A3);
	r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_B1,TTT_AI_POSFLAG_B2,TTT_AI_POSFLAG_B3);
	r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_C1,TTT_AI_POSFLAG_C2,TTT_AI_POSFLAG_C3);
	r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A1,TTT_AI_POSFLAG_B1,TTT_AI_POSFLAG_C1);
	r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A2,TTT_AI_POSFLAG_B2,TTT_AI_POSFLAG_C2);
	r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A3,TTT_AI_POSFLAG_B3,TTT_AI_POSFLAG_C3);
	r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A1,TTT_AI_POSFLAG_B2,TTT_AI_POSFLAG_C3);
	r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A3,TTT_AI_POSFLAG_B2,TTT_AI_POSFLAG_C1);
	LOG_TRACE(sprintf("TTT AI: possible 3 in a rows in %x: %x (%x)\n",piecemask,r, r&piecemask_free));
	r &= piecemask_free;
	return ttt_ai_random(r);
}

// Simple AI
// 1) tries to win the game if possible
// 2) tries to block the opponent if they have 2 in a row
// 3) places a piece randomly
string ttt_ai_choose_simple(int piecemask_self, int piecemask_opponent, int piecemask_free )
{
	int move = 0;

	LOG_TRACE("TTT AI: checking winning move\n");
	if (( move = ttt_ai_block3(piecemask_self,piecemask_free) ))
		return ttt_ai_piece_flag2pos(move); // place winning move

	LOG_TRACE("TTT AI: checking opponent's winning move\n");
	if (( move = ttt_ai_block3(piecemask_opponent,piecemask_free) ))
		return ttt_ai_piece_flag2pos(move); // block opponent

	LOG_TRACE("TTT AI: random move\n");
	return ttt_ai_piece_flag2pos(ttt_ai_random(piecemask_free));
}

// AI move (if it's AI's turn)
void ttt_aimove(entity minigame)
{
	if ( minigame.minigame_flags == (TTT_TURN_PLACE|minigame.ttt_ai) )
	{
		entity aiplayer = NULL;
		while ( ( aiplayer = findentity(aiplayer,owner,minigame) ) )
			if ( aiplayer.classname == "minigame_player" && !aiplayer.minigame_playerslot )
				break;

		/*
		 * Build bit masks for the board pieces
		 * .---.---.---.
		 * | 4 | 32|256| 3
		 * |---+---+---|
		 * | 2 | 16|128| 2
		 * |---+---+---|
		 * | 1 | 8 | 64| 1
		 * '---'---'---'
		 *   A   B   C
		 */
		int piecemask_self = 0;
		int piecemask_opponent = 0;
		int piecemask_free = 0;
		int pieceflag = 1;
		string pos;
		for ( int i = 0; i < 3; i++ )
		{
			for ( int j = 0; j < 3; j++ )
			{
				pos = minigame_tile_buildname(i,j);
				entity piece = ttt_find_piece(minigame,pos);
				if ( piece )
				{
					if ( piece.team == aiplayer.team )
						piecemask_self |= pieceflag;
					else
						piecemask_opponent |= pieceflag;
				}
				else
					piecemask_free |= pieceflag;
				pieceflag <<= 1;
			}
		}

		// TODO multiple AI difficulties
		LOG_TRACE(sprintf("TTT AI: self: %x opponent: %x free: %x\n",
				piecemask_self, piecemask_opponent, piecemask_free));
		pos = ttt_ai_choose_simple(piecemask_self, piecemask_opponent, piecemask_free);
		LOG_TRACE("TTT AI: chosen move: ",pos,"\n\n");
		if ( !pos )
			LOG_TRACE("Tic Tac Toe AI has derped!\n");
		else
			ttt_move(minigame,aiplayer,pos);
	}
	minigame.message = ttt_turn_to_string(minigame.minigame_flags);
}

// Make the correct move
void ttt_make_move(entity minigame)
{
	if ( minigame.minigame_flags == (TTT_TURN_PLACE|minigame_self.team) )
	{
		if ( minigame.ttt_ai  )
		{
			ttt_move(minigame, minigame_self, ttt_curr_pos );
			ttt_aimove(minigame);
		}
		else
			minigame_cmd("move ",ttt_curr_pos);
	}
}

void ttt_set_curr_pos(string s)
{
	if ( ttt_curr_pos )
		strunzone(ttt_curr_pos);
	if ( s )
		s = strzone(s);
	ttt_curr_pos = s;
}

// Required function, handle client events
int ttt_client_event(entity minigame, string event, ...)
{
	switch(event)
	{
		case "activate":
		{
			ttt_set_curr_pos("");
			minigame.message = ttt_turn_to_string(minigame.minigame_flags);
			return false;
		}
		case "key_pressed":
		{
			if((minigame.minigame_flags & TTT_TURN_TEAM) == minigame_self.team)
			{
				switch ( ...(0,int) )
				{
					case K_RIGHTARROW:
					case K_KP_RIGHTARROW:
						if ( ! ttt_curr_pos )
							ttt_set_curr_pos("a3");
						else
							ttt_set_curr_pos(minigame_relative_tile(ttt_curr_pos,1,0,TTT_LET_CNT,TTT_NUM_CNT));
						return true;
					case K_LEFTARROW:
					case K_KP_LEFTARROW:
						if ( ! ttt_curr_pos )
							ttt_set_curr_pos("c3");
						else
							ttt_set_curr_pos(minigame_relative_tile(ttt_curr_pos,-1,0,TTT_LET_CNT,TTT_NUM_CNT));
						return true;
					case K_UPARROW:
					case K_KP_UPARROW:
						if ( ! ttt_curr_pos )
							ttt_set_curr_pos("a1");
						else
							ttt_set_curr_pos(minigame_relative_tile(ttt_curr_pos,0,1,TTT_LET_CNT,TTT_NUM_CNT));
						return true;
					case K_DOWNARROW:
					case K_KP_DOWNARROW:
						if ( ! ttt_curr_pos )
							ttt_set_curr_pos("a3");
						else
							ttt_set_curr_pos(minigame_relative_tile(ttt_curr_pos,0,-1,TTT_LET_CNT,TTT_NUM_CNT));
						return true;
					case K_ENTER:
					case K_KP_ENTER:
					case K_SPACE:
						ttt_make_move(minigame);
						return true;
				}
			}

			return false;
		}
		case "mouse_pressed":
		{
			if(...(0,int) == K_MOUSE1)
			{
				ttt_make_move(minigame);
				return true;
			}

			return false;
		}
		case "mouse_moved":
		{
			vector mouse_pos = minigame_hud_normalize(mousepos,ttt_boardpos,ttt_boardsize);
			if ( minigame.minigame_flags == (TTT_TURN_PLACE|minigame_self.team) )
				ttt_set_curr_pos(minigame_tile_name(mouse_pos,TTT_LET_CNT,TTT_NUM_CNT));
			if ( ! ttt_valid_tile(ttt_curr_pos) )
				ttt_set_curr_pos("");

			return true;
		}
		case "network_receive":
		{
			entity sent = ...(0,entity);
			int sf = ...(1,int);
			if ( sent.classname == "minigame" )
			{
				if ( sf & MINIG_SF_UPDATE )
				{
					sent.message = ttt_turn_to_string(sent.minigame_flags);
					if ( sent.minigame_flags & minigame_self.team )
						minigame_prompt();
				}

				if ( (sf & TTT_SF_SINGLEPLAYER) )
				{
					int ai = ReadByte();
					bool spawnai = ai && !sent.ttt_ai;
					sent.ttt_ai = ai;

					if ( spawnai )
					{
						entity aiplayer = new(minigame_player);
						aiplayer.owner = minigame;
						aiplayer.team = ai;
						aiplayer.minigame_playerslot = 0;
						aiplayer.minigame_autoclean = 1;
						ttt_aimove(minigame);
					}

				}
			}
			else if ( sent.classname == "minigame_player" && (sf & TTT_SF_PLAYERSCORE ) )
			{
				sent.minigame_flags = ReadByte();
			}

			return false;
		}
		case "menu_show":
		{
			HUD_MinigameMenu_CustomEntry(...(0,entity),_("Next Match"),"next");
			HUD_MinigameMenu_CustomEntry(...(0,entity),_("Single Player"),"singleplayer");
			return false;
		}
		case "menu_click":
		{
			if(...(0,string) == "next")
			{
				if ( minigame.ttt_ai )
				{
					ttt_next_match(minigame,minigame_self);
					ttt_aimove(minigame);
				}
				else
					minigame_cmd("next");
			}
			else if ( ...(0,string) == "singleplayer" && !minigame.ttt_ai )
			{
				if ( minigame_count_players(minigame) == 1 )
					minigame_cmd("singleplayer");
			}
			return false;
		}
	}

	return false;
}

#endif