#include <dos.h>
#include <math.h>
#include <conio.h>
#include <stdio.h>
#include <iostream.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "tree.h"

#include <graphics.h>

#define ESC	   0x1b  /* Define the escape key	*/
#define PERSON     0
#define COMPUTER   1
#define BREADTH_FIRST 1
#define DEPTH_FIRST   2

int    GraphDriver;		/* The Graphics device driver		*/
int    GraphMode;		/* The Graphics mode value		*/
double AspectRatio;		/* Aspect ratio of a pixel on the screen*/
int    MaxX, MaxY;		/* The maximum resolution of the screen */
int    MaxColors;		/* The maximum # of colors available	*/
int    ErrorCode;		/* Reports any graphics errors		*/
struct palettetype palette;	/* Used to read palette info		*/

typedef enum {false,true} bool;
bool   piece_chosen = false,
       is_winner    = false,
       is_tie       = false;
int    person_or_puter = PERSON,
       search_method = 0;
char   buf,buf2,winning_piece;
Tree   TTT_Tree;

void createTree()
{
   Leaf *tempPtr,*previousPtr;
   Tree *treePtr = &TTT_Tree;
   int row,col;

   treePtr->rootPtr = new Leaf(0,0);
   treePtr->rootPtr->parentPtr = 0;
   tempPtr = treePtr->rootPtr;
   previousPtr = tempPtr;

   tempPtr->downPtr = new Leaf(1,0);
   tempPtr = tempPtr->downPtr;
   tempPtr->parentPtr = previousPtr;
   tempPtr->acrossPtr = 0;
   previousPtr = tempPtr;

   tempPtr->downPtr = new Leaf(2,0);
   tempPtr = tempPtr->downPtr;
   tempPtr->parentPtr = previousPtr;
   tempPtr->acrossPtr = 0;
   previousPtr = tempPtr;

   tempPtr->downPtr = new Leaf(3,0);
   tempPtr = tempPtr->downPtr;
   tempPtr->parentPtr = previousPtr;
   tempPtr->downPtr = 0;
   tempPtr->acrossPtr = 0;
   tempPtr->diagPtr = 0;

   tempPtr = tempPtr->parentPtr;
   tempPtr->diagPtr = new Leaf(3,1);
   tempPtr = tempPtr->diagPtr;
   tempPtr->parentPtr = previousPtr;
   tempPtr->downPtr = 0;
   tempPtr->acrossPtr = 0;
   tempPtr->diagPtr = 0;

   tempPtr = tempPtr->parentPtr->parentPtr;
   previousPtr = tempPtr;

   tempPtr->diagPtr = new Leaf(2,1);
   tempPtr = tempPtr->diagPtr;
   tempPtr->parentPtr = previousPtr;
   previousPtr = tempPtr;
   tempPtr->downPtr = 0;
   tempPtr->acrossPtr = 0;

   tempPtr->diagPtr = new Leaf(3,2);
   tempPtr = tempPtr->diagPtr;
   tempPtr->parentPtr = previousPtr;
   tempPtr->downPtr = 0;
   tempPtr->acrossPtr = 0;
   tempPtr->diagPtr = 0;

   tempPtr = treePtr->rootPtr;
   previousPtr = tempPtr;

   tempPtr->diagPtr = new Leaf(1,1);
   tempPtr = tempPtr->diagPtr;
   tempPtr->parentPtr = previousPtr;
   previousPtr = tempPtr;
   tempPtr->downPtr = 0;

   tempPtr->diagPtr = new Leaf(2,2);
   tempPtr = tempPtr->diagPtr;
   tempPtr->parentPtr = previousPtr;
   previousPtr = tempPtr;
   tempPtr->downPtr = 0;

   tempPtr->diagPtr = new Leaf(3,3);
   tempPtr = tempPtr->diagPtr;
   tempPtr->parentPtr = previousPtr;
   tempPtr->downPtr = 0;
   tempPtr->acrossPtr = 0;
   tempPtr->diagPtr = 0;

   tempPtr = tempPtr->parentPtr;
   previousPtr = tempPtr;

   tempPtr->acrossPtr = new Leaf(2,3);
   tempPtr = tempPtr->acrossPtr;
   tempPtr->parentPtr = previousPtr;
   tempPtr->downPtr = 0;
   tempPtr->acrossPtr = 0;
   tempPtr->diagPtr = 0;

   tempPtr = tempPtr->parentPtr;
   tempPtr = tempPtr->parentPtr;
   previousPtr = tempPtr;

   tempPtr->acrossPtr = new Leaf(1,2);
   tempPtr = tempPtr->acrossPtr;
   tempPtr->parentPtr = previousPtr;
   previousPtr = tempPtr;
   tempPtr->downPtr = 0;
   tempPtr->diagPtr = 0;

   tempPtr->acrossPtr = new Leaf(1,3);
   tempPtr = tempPtr->acrossPtr;
   tempPtr->parentPtr = previousPtr;
   tempPtr->downPtr = 0;
   tempPtr->acrossPtr = 0;
   tempPtr->diagPtr = 0;

   tempPtr = treePtr->rootPtr;
   previousPtr = tempPtr;

   tempPtr->acrossPtr = new Leaf(0,1);
   tempPtr = tempPtr->acrossPtr;
   tempPtr->parentPtr = previousPtr;
   previousPtr = tempPtr;
   tempPtr->downPtr = 0;
   tempPtr->diagPtr = 0;

   tempPtr->acrossPtr = new Leaf(0,2);
   tempPtr = tempPtr->acrossPtr;
   tempPtr->parentPtr = previousPtr;
   previousPtr = tempPtr;
   tempPtr->downPtr = 0;
   tempPtr->diagPtr = 0;

   tempPtr->acrossPtr = new Leaf(0,3);
   tempPtr = tempPtr->acrossPtr;
   tempPtr->parentPtr = previousPtr;
   tempPtr->downPtr = 0;
   tempPtr->acrossPtr = 0;
   tempPtr->diagPtr = 0;
}

int insert_into_tree(int row, int col, char piece)
{
   Tree *treePtr = &TTT_Tree;
   Leaf *tempPtr = treePtr->rootPtr;
   int ret = 0;

   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->downPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->downPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->downPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->parentPtr;
   tempPtr = tempPtr->diagPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->parentPtr->parentPtr;
   tempPtr = tempPtr->diagPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->diagPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }

   tempPtr = treePtr->rootPtr;

   tempPtr = tempPtr->diagPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->diagPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->diagPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->parentPtr;
   tempPtr = tempPtr->acrossPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->parentPtr->parentPtr;
   tempPtr = tempPtr->acrossPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->acrossPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }

   tempPtr = treePtr->rootPtr;

   tempPtr = tempPtr->acrossPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->acrossPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }
   tempPtr = tempPtr->acrossPtr;
   if(tempPtr->row == row && tempPtr->col == col)
   {
	 tempPtr->piece = piece;
	 ret = 1;
   }

   return ret;
}

int CheckColWinBFS(int col)
{
   Tree *treePtr = &TTT_Tree;
   Leaf *currentPtr;
   char piece;
   int count=0,ret=0,x,y;

// CHECKING THE FIRST LEVEL OF THE TREE (I.E., THE ROOT LEAF)
   currentPtr = treePtr->rootPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

// CHECKING THE SECOND LEVEL OF THE TREE
   currentPtr = currentPtr->downPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}


   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}


// CHECKING THE THIRD LEVEL OF THE TREE
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->downPtr->downPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}


   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

// CHECKING THE FOURTH LEVEL
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->downPtr;
   currentPtr = currentPtr->downPtr;
   currentPtr = currentPtr->downPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   if (count == 4)
   {
      y = 80;
      winning_piece = piece;
      struct viewporttype vp;
      getviewsettings( &vp );
      setlinestyle( SOLID_LINE, 0, THICK_WIDTH );

      if(col == 0)
	 x = 222;
      else if(col == 1)
	 x = 279;
      else if(col == 2)
	 x = 336;
      else if(col == 3)
	 x = 393;
      line( x, y, x, vp.bottom-80 );

      ret = 1;
   }
   return ret;
}

int CheckRowWinBFS(int row)
{
   Tree *treePtr = &TTT_Tree;
   Leaf *currentPtr;
   char piece;
   int count=0,ret=0,x,y;

// CHECKING THE FIRST LEVEL OF THE TREE (I.E., THE ROOT LEAF)
   currentPtr = treePtr->rootPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

// CHECKING THE SECOND LEVEL OF THE TREE
   currentPtr = currentPtr->downPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}


   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}


// CHECKING THE THIRD LEVEL OF THE TREE
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->downPtr->downPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}


   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

// CHECKING THE FOURTH LEVEL
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->downPtr;
   currentPtr = currentPtr->downPtr;
   currentPtr = currentPtr->downPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   if (count == 4)
   {
      winning_piece = piece;
      struct viewporttype vp;
      getviewsettings( &vp );
      setlinestyle( SOLID_LINE, 0, THICK_WIDTH );
      if(row == 0)
	 y = 112;
      else if(row == 1)
	 y = 169;
      else if(row == 2)
	 y = 226;
      else if(row == 3)
	 y = 283;

      line( vp.left+185, y, vp.left+425, y );

      ret = 1;
   }
   return ret;
}

int CheckDiagWinBFS(int diag)
{
   Tree *treePtr = &TTT_Tree;
   Leaf *currentPtr;
   char piece;
   int count=0,ret=0,x,y;

// CHECKING THE FIRST LEVEL OF THE TREE (I.E., THE ROOT LEAF)
   currentPtr = treePtr->rootPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

// CHECKING THE SECOND LEVEL OF THE TREE
   currentPtr = currentPtr->downPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}


   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}


// CHECKING THE THIRD LEVEL OF THE TREE
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->downPtr->downPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}


   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

// CHECKING THE FOURTH LEVEL
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->downPtr;
   currentPtr = currentPtr->downPtr;
   currentPtr = currentPtr->downPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   currentPtr = currentPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   if (count == 4)
   {
      winning_piece = piece;
      struct viewporttype vp;
      getviewsettings( &vp );
      setlinestyle( SOLID_LINE, 0, THICK_WIDTH );
      if(diag == 0)
      {
	 x = 200;
	 y = 80;
	 line( x, y, x+190, vp.bottom-80 );
      }
      else
      {
	 x = 390;
	 y = 80;
	 line( x, y, x-190, vp.bottom-80 );
      }

      ret = 1;
   }
   return ret;
}

int CheckColWinDFS(int col)
{
   Tree *treePtr = &TTT_Tree;
   Leaf *currentPtr;
   char piece;
   int count=0,ret=0,x,y;

   currentPtr = treePtr->rootPtr;

   while(currentPtr->downPtr != 0)
      currentPtr = currentPtr->downPtr;

   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   while(currentPtr->diagPtr != 0)
      currentPtr = currentPtr->diagPtr;

   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->parentPtr->acrossPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;

   while(currentPtr->acrossPtr != 0)
      currentPtr = currentPtr->acrossPtr;

   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;

   currentPtr = currentPtr->downPtr->downPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->diagPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->acrossPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->downPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr->diagPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr->acrossPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   if( (currentPtr->row == 0 && currentPtr->col == col) ||
       (currentPtr->row == 1 && currentPtr->col == col) ||
       (currentPtr->row == 2 && currentPtr->col == col) ||
       (currentPtr->row == 3 && currentPtr->col == col) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   if (count == 4)
   {
      y = 80;
      winning_piece = piece;
      struct viewporttype vp;
      getviewsettings( &vp );
      setlinestyle( SOLID_LINE, 0, THICK_WIDTH );

      if(col == 0)
	 x = 222;
      else if(col == 1)
	 x = 279;
      else if(col == 2)
	 x = 336;
      else if(col == 3)
	 x = 393;
      line( x, y, x, vp.bottom-80 );

      ret = 1;
   }
   return ret;
}

int CheckRowWinDFS(int row)
{
   Tree *treePtr = &TTT_Tree;
   Leaf *currentPtr;
   char piece;
   int count=0,ret=0,x,y;

   currentPtr = treePtr->rootPtr;

   while(currentPtr->downPtr != 0)
      currentPtr = currentPtr->downPtr;

   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   while(currentPtr->diagPtr != 0)
      currentPtr = currentPtr->diagPtr;

   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->parentPtr->acrossPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;

   while(currentPtr->acrossPtr != 0)
      currentPtr = currentPtr->acrossPtr;

   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;

   currentPtr = currentPtr->downPtr->downPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->diagPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->acrossPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->downPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr->diagPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr->acrossPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   if( (currentPtr->col == 0 && currentPtr->row == row) ||
       (currentPtr->col == 1 && currentPtr->row == row) ||
       (currentPtr->col == 2 && currentPtr->row == row) ||
       (currentPtr->col == 3 && currentPtr->row == row) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   if (count == 4)
   {
      winning_piece = piece;
      struct viewporttype vp;
      getviewsettings( &vp );
      setlinestyle( SOLID_LINE, 0, THICK_WIDTH );
      if(row == 0)
	 y = 112;
      else if(row == 1)
	 y = 169;
      else if(row == 2)
	 y = 226;
      else if(row == 3)
	 y = 283;

      line( vp.left+185, y, vp.left+425, y );

      ret = 1;
   }
   return ret;
}

int CheckDiagWinDFS(int diag)
{
   Tree *treePtr = &TTT_Tree;
   Leaf *currentPtr;
   char piece;
   int count=0,ret=0,x,y;

   currentPtr = treePtr->rootPtr;

   while(currentPtr->downPtr != 0)
      currentPtr = currentPtr->downPtr;

   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   while(currentPtr->diagPtr != 0)
      currentPtr = currentPtr->diagPtr;

   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->parentPtr->acrossPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;

   while(currentPtr->acrossPtr != 0)
      currentPtr = currentPtr->acrossPtr;

   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;

   currentPtr = currentPtr->downPtr->downPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->diagPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = currentPtr->parentPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->acrossPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->downPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr->diagPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr->acrossPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   currentPtr = treePtr->rootPtr;
   if( (currentPtr->col == (abs(0 - diag)) && currentPtr->row == 0) ||
       (currentPtr->col == (abs(0 - (abs(diag-1)))) && currentPtr->row == 1) ||
       (currentPtr->col == (abs(0 - (abs(diag-2)))) && currentPtr->row == 2) ||
       (currentPtr->col == (abs(0 - (abs(diag-3)))) && currentPtr->row == 3) )
	if(currentPtr->piece == '*')
		ret = 0;
	else
	{
		if (count == 0)
		   piece = currentPtr->piece;

		if(piece == currentPtr->piece)
			count++;
	}

   if (count == 4)
   {
      winning_piece = piece;
      struct viewporttype vp;
      getviewsettings( &vp );
      setlinestyle( SOLID_LINE, 0, THICK_WIDTH );
      if(diag == 0)
      {
	 x = 200;
	 y = 80;
	 line( x, y, x+190, vp.bottom-80 );
      }
      else
      {
	 x = 390;
	 y = 80;
	 line( x, y, x-190, vp.bottom-80 );
      }

      ret = 1;
   }
   return ret;
}

int IsWinner()
{
   // execute the goal functions
   if(search_method == BREADTH_FIRST)
   {
      if(CheckColWinBFS(0))
	 return 1;
      else if(CheckColWinBFS(1))
	 return 1;
      else if(CheckColWinBFS(2))
	 return 1;
      else if(CheckColWinBFS(3))
	 return 1;
      else if(CheckRowWinBFS(0))
	 return 1;
      else if(CheckRowWinBFS(1))
	 return 1;
      else if(CheckRowWinBFS(2))
	 return 1;
      else if(CheckRowWinBFS(3))
	 return 1;
      else if(CheckDiagWinBFS(0))
	 return 1;
      else if(CheckDiagWinBFS(3))
	 return 1;
   }
   else if(search_method == DEPTH_FIRST)
   {
      if(CheckColWinDFS(0))
	 return 1;
      else if(CheckColWinDFS(1))
	 return 1;
      else if(CheckColWinDFS(2))
	 return 1;
      else if(CheckColWinDFS(3))
	 return 1;
      else if(CheckRowWinDFS(0))
	 return 1;
      else if(CheckRowWinDFS(1))
	 return 1;
      else if(CheckRowWinDFS(2))
	 return 1;
      else if(CheckRowWinDFS(3))
	 return 1;
      else if(CheckDiagWinDFS(0))
	 return 1;
      else if(CheckDiagWinDFS(3))
	 return 1;
   }
   return 0;
}


void Initialize(void)
{
  int xasp, yasp;			/* Used to read the aspect ratio*/

  createTree();

  GraphDriver = DETECT; 		/* Request auto-detection */
  initgraph( &GraphDriver, &GraphMode, "" );
  ErrorCode = graphresult();		/* Read result of initialization */
  if( ErrorCode != grOk )		/* Error occured during init */
  {
    printf(" Graphics System Error: %s\n", grapherrormsg( ErrorCode ) );
    exit( 1 );
  }

  getpalette( &palette );		/* Read the palette from board */
  MaxColors = getmaxcolor() + 1;	/* Read maximum number of colors */
  MaxX = getmaxx();
  MaxY = 400;
  getaspectratio( &xasp, &yasp );	/* read the hardware aspect */
  AspectRatio = (double)xasp / (double)yasp; /* Get correction factor */
}

/*                                                                      */
/*	GPRINTF: Used like PRINTF except the output is sent to the      */
/*	screen in graphics mode at the specified co-ordinate.           */
/*									*/

int gprintf( int *xloc, int *yloc, char *fmt, ... )
{
  va_list  argptr;			/* Argument list pointer	*/
  char str[140];			/* Buffer to build sting into	*/
  int cnt;				/* Result of SPRINTF for return */

  va_start( argptr, fmt );		/* Initialize va_ functions	*/
  cnt = vsprintf( str, fmt, argptr );	/* prints string to buffer	*/
  outtextxy( *xloc, *yloc, str );	/* Send string in graphics mode */
//  *yloc += textheight( "H" ) + 2;       /* Advance to next line         */
  va_end( argptr );			/* Close va_ functions		*/

  return( cnt );			/* Return the conversion count	*/

}

void changetextstyle(int font, int direction, int charsize)
{
  int ErrorCode;

  graphresult();			/* clear error code		*/
  settextstyle(font, direction, charsize);
  ErrorCode = graphresult();		/* check result 		*/
  if( ErrorCode != grOk )		/* if error occured		*/
  {
    closegraph();
    printf(" Graphics System Error: %s\n", grapherrormsg( ErrorCode ) );
    exit( 1 );
  }
}

void Pause(void)
{
//  static char msg[] = "Esc aborts or press a key...";
  int c;

//  StatusLine( msg );			/* Put msg at bottom of screen */

  c = getch();				/* Read a character from kbd */

  if( ESC == c ){			/* Does user wish to leave? */
    closegraph();			/* Change to text mode */
    exit( 1 );				/* Return to OS */
  }

  if( 0 == c ){ 			/* Did use hit a non-ASCII key? */
    c = getch();			/* Read scan code for keyboard */
  }

  cleardevice();			/* Clear the screen */
}

void DrawBorder(void)
{
  struct viewporttype vp;

  setcolor( MaxColors - 1 );		/* Set current color to white	*/
  setlinestyle( SOLID_LINE, 0, NORM_WIDTH );
  getviewsettings( &vp );
  rectangle( 0, 0, vp.right-vp.left, vp.bottom-vp.top );
}

void MainWindow( char *header )
{
  int height;

  cleardevice();			/* Clear graphics screen	*/
  setcolor( MaxColors - 1 );		/* Set current color to white	*/
  setviewport( 0, 0, MaxX, MaxY, 1 );	/* Open port to full screen	*/
  height = textheight( "H" );           /* Get basic text height        */
  changetextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );
  settextjustify( CENTER_TEXT, TOP_TEXT );
  outtextxy( MaxX/2, 2, header );
  setviewport( 0, height+4, MaxX, MaxY-(height+4), 1 );
  DrawBorder();
  setviewport( 1, height+5, MaxX-1, MaxY-(height+5), 1 );
}

void DrawBoard(void)
{
  int style, step;
  int x, y, w;
  struct viewporttype vp;
  char buffer[40];

  if(search_method == BREADTH_FIRST)
     MainWindow( "Mark's 4x4 Tic-Tac-Toe Game using Breadth-First Search" );
  else if (search_method == DEPTH_FIRST)
     MainWindow( "Mark's 4x4 Tic-Tac-Toe Game using Depth-First Search" );

  getviewsettings( &vp );
  w = vp.right	- vp.left;
  x = 250;
  y = 30;
  step = w / 11;
  setlinestyle( SOLID_LINE, 0, THICK_WIDTH );
  for( style=0 ; style<3 ; ++style )
  {
    line( x, y+50, x, vp.bottom-80 );
    x += step;
  }
  y = 140;
  for( style=0 ; style<3 ; ++style )
  {
    line( vp.left+185, y, vp.left+425, y );
    y += step;
  }
  x = 220;
  y = 25;
  for (style=0;style<4;++style)
  {
	gprintf(&x,&y,"%d",style);
	x += step;
  }
  x = 130;
  y = 110;
  for (style=0;style<4;++style)
  {
	gprintf(&x,&y,"%d",style);
	y += step;
  }
//  Pause();				/* Wait for user's response     */
}

void DrawX(int px,int py)
{
  int x,y,w,step,x1=40,y1=40;
  struct viewporttype vp;

  getviewsettings( &vp );
  w = vp.right	- vp.left;
  step = w / 11;
  x = (vp.left+200) + (step * px);
  y = (vp.top+78) + (step * py);
  setlinestyle( SOLID_LINE, 0, THICK_WIDTH );
  line( x, y, x+x1, y+y1 );
  line( x,y+y1,x+x1,y );
}

void DrawO(int px, int py)
{
  int x,y,w,step;
  struct viewporttype vp;

  getviewsettings( &vp );
  w = vp.right	- vp.left;
  step = w / 11;
  x = (vp.left+221) + (step * px);
  y = (vp.top+98) + (step * py);
  setlinestyle( SOLID_LINE, 0, THICK_WIDTH );
  circle(x,y,20);
}

void ChoosePiece()
{
   int x,y,key;
   struct viewporttype vp;
   char temp_buf[1];

   getviewsettings( &vp );
   x = vp.left + 300;
   y = vp.bottom - 60;
   gprintf(&x,&y,"Would you like to be X or O? ");
   gotoxy(54,22);
   scanf("%c",temp_buf);
   buf = toupper(temp_buf[0]);

   if(buf == 'X' || buf == 'O')
   {
	gotoxy(2,22);
	printf("                                                                              ");
	if(buf == 'X')
	   buf2 = 'O';
	else
	   buf2 = 'X';

	piece_chosen = true;
   }
}

int find_free_spot(int *r, int *c)
{
   Tree *treePtr = &TTT_Tree;
   Leaf *currentPtr;
   int ret;

   currentPtr = treePtr->rootPtr;

   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }

   currentPtr = currentPtr->downPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->downPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->downPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->diagPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }

   currentPtr = currentPtr->parentPtr->parentPtr->diagPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->diagPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }

   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->diagPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->diagPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->diagPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->parentPtr;
   currentPtr = currentPtr->acrossPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->acrossPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = treePtr->rootPtr;
   currentPtr = currentPtr->acrossPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->acrossPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   currentPtr = currentPtr->acrossPtr;
   if(currentPtr->piece != 'X' && currentPtr->piece != 'O')
   {
      *r = currentPtr->row;
      *c = currentPtr->col;
      return 1;
   }
   return 0;
}

void ComputerMove()
{
   int row_num,col_num;
   struct viewporttype vp;

   if(find_free_spot(&row_num,&col_num))
   {
	   if(buf2 == 'X')
		DrawX(col_num,row_num);
	   else
		DrawO(col_num,row_num);
	   insert_into_tree(row_num,col_num,buf2);
	   person_or_puter = PERSON;
   }
   else
      is_tie = true;
}

void PersonMove()
{
   int x,y,col,row;
   char temp_col[1], temp_row[1];
   struct viewporttype vp;

   getviewsettings( &vp );
   x = vp.left + 300;
   y = vp.bottom - 60;

   if(!find_free_spot(&row,&col))
   {
      is_tie = true;
      return;
   }

   while(1)
   {
	x = vp.left + 300;
	y = vp.bottom - 60;
	gprintf(&x,&y,"Enter the column where you would like to place your piece: ");
	gotoxy(68,22);
	scanf("%s",temp_col);
	col = atol(temp_col);
	if(col >= 0 && col <= 3)
		break;
	else
		gotoxy(70,22);
		printf("    ");
   }

   gotoxy(2,22);
   printf("                                                                              ");

   while(1)
   {
	x = vp.left + 300;
	y = vp.bottom - 60;
	gprintf(&x,&y,"Enter the row where you would like to place your piece: ");
	gotoxy(67,22);
	scanf("%s",temp_row);
	row = atol(temp_row);
	if(row >= 0 && row <= 3)
		break;
	else
		gotoxy(70,22);
		printf("    ");
   }

   if(buf == 'X')
	DrawX(col,row);
   else
	DrawO(col,row);

   insert_into_tree(row,col,buf);

   person_or_puter = COMPUTER;

   gotoxy(2,22);
   printf("                                                                              ");
}

void Play(int player)
{
	if(player == PERSON)
		PersonMove();
	else if(player == COMPUTER);
		ComputerMove();
}

void CallWinLoseDraw()
{
   int x,y;
   struct viewporttype vp;

   getviewsettings( &vp );

   if(is_tie == true)
   {
	x = vp.left + 300;
	y = vp.bottom - 60;
	gprintf(&x,&y,"Tie game");
   }
   else
   {
	x = vp.left + 300;
	y = vp.bottom - 60;
	gprintf(&x,&y,"The winner is %c!",winning_piece);
   }
   Pause();
}

void ChooseSearchMeth()
{
   char temp_method[2];

   printf("\n\n\n\n\n\n\n\nChoose which search method you'd like to use\n");
   printf("1) Breadth-First Search\n");
   printf("2) Depth-First Search\n");
   scanf("%s",temp_method);

   search_method = atol(temp_method);
   clrscr();
}

main()
{
	Initialize();
	ChooseSearchMeth();
	DrawBoard();
	while(piece_chosen == false)
		ChoosePiece();
	while(!IsWinner() && is_tie == false)
		Play(person_or_puter);
	CallWinLoseDraw();

	return 0;
}