// Depth to which minimax algorithm shud go

// try 2 first then 4 then 6 and so on till crash

int D = 2;
// current board position
// string beginning with "b.."
// string beginning with "w.."
// K is king, Q is Queen, C is
// string board[1][x] is row 1
string board[8][8];

are black pieces

are white
castle, B is Bishop, K is knight, P is pawn
of the board

// "true" if it can, else "false"

bool canpiecemove(string piece_name);
// set Board according to start of game
void setBoard_for_startgame();
// will clear screen and print board
void printBoard()
{
clearscreen();
// print out board
....
}
String modify_global_board(Node *N)
{
currentNode = N;
currentNode->depth=0;
currentNode->parent=null;
// modify global board
..
}
// if depth=0, eval_func for global board
// if depth=1, eval_func for global board with Node*N proposed position on globa
l board
int eval_function(Node *N);
// int eval_function(String a[8][8]);
struct Node
{
int depth;
// piece to be moved
string piece_name;
// original position
int oposx, oposy;
// new position
int nposx, nposy;
// value from computer's perspective (trying to become max)
int eval_func_val;
Node *parent;
} *global, *currentNode;
global->depth = 0;
global->eval_func_val = eval_function(board[8][8]);
global->parent = NULL;
currentNode = global;
// fit in alpha-beta pruning here

Node *create_legal_Node(Node *N, int D)

{
// create all legal child nodes possible
// Node child->depth = (N->dep)+1;
// child->parent = N;
// assign eval_func to all root nodes only (D == Node->depth)
// for each child node possible, if (D - child->depth > 0) create all it
's legal nodes
// best_N_child = create_legal_Node(child)
// compare the eval_func_val of all the returned best_N_child
// best_N = (highest) best_N_child
// after finding best node, free all other nodes, other than the nodes i
n the "best node" tree
// goto all child of Node N, and free it's children except for the one p
ointed by best_N
// return the best child node in this tree
return best_N;
}
// do a minimax analysis for depth D (global variable)
// always of the current board position
void minimax()
{
Node *best_N = new Node();
best_N = create_legal_nodes(currentNode, D);
// apply Node best_N to global Board and give handle back to human
modify_global_board(best_N);
return;
}
// only for human user
bool is_move_legal(Node *N)
{
// for currentNode check all it's children and see if any of the childre
n have the same below things when compared to user input
// a. string piece_name
// b. oposx, oposy
// c. nposx, nposy
// if all of the above requirements meet, then return true, else false
...
return ..;
}
// human's input at each turn shud be a valid command
bool is_command_valid(String command);
int main()
{
setBoard_for_startgame();
printBoard();
printf ("What color do u want to be - Black or White?")

if (cin << 'B')

{
printf ("Computer starts first");
// decide computer's next move
minimax();
printBoard();
}
while(1)
{
// human plays
while(1)
{
string input;
printf ("What is your next move?");
cin << input;
// Check if move is a valid command
if (!is_command_valid(input))
{
printf ("invalid string)";
printf("Try again");
continue;
}
Node *N = new Node;
N->depth = -1;
N->parent = null;
/* set all other variables, no need to set eval_func_val
*/
if(is_move_legal(N))
{
// move confirmed legal
// place human's move on the global board
modify_global_board(N);
freeNode(N);
printBoard();
break;
}
else
{
freeNode(N);
printf ("This move is not possible");
printf("Try again");
}
}
// computer plays
minimax();
printBoard();
}
}