minmax structure done

Board.cpp

@@ -250,7 +250,7 @@ void Board::move(string inputMove){
 	move(m);
 }
 
-void Board::move(moves m){
+Board Board::move(moves m){
 	int row = 8 - (m.row);
 	int column = m.column;
 	
@@ -258,7 +258,7 @@ void Board::move(moves m){
 	
 	if (row > 8 || row < 0 || column > 8 || column < 0) {
 		cout<<"ERROR: index out of bound."<<endl;
-		return;
+		return *this;
 	}
 	
 	Piece* piece;
@@ -268,7 +268,7 @@ void Board::move(moves m){
 	
 	else{
 		cout<<"ERROR: attempting to move an invalid piece.\n";
-		return;
+		return *this;
 	}
 	//cout << piece->getX() << piece->getY() << "\n\n";
 	if (piece->getType() != turn) {
@@ -334,6 +334,8 @@ void Board::move(moves m){
 			setValidFalse();
 		}
 	}
+
+	return *this;
 }
 	
 bool Board::isThisMovePossible(int r, int c, string moveType){

Board.h

@@ -11,6 +11,12 @@ struct moves {
 	int column;
 	string moveType;
 
+	moves() {
+		row = -1;
+		column = -1;
+		moveType = "";
+	}
+	
 	moves(int linea, int columna, string m) {
 		row = linea;
 		column = columna;
@@ -47,8 +53,7 @@ public:
 	int charToIntColumn(char input);
 	char intToCharColumn(int input);
 	void move(string inputMove);
-	void move(moves jugada);
-	void moveWOPrint(moves jugada);
+	Board move(moves m);
 	bool isThisMovePossible(int r, int c, string moveType);
 	vector<moves> viewPossibleMoves();
 	string myToUpper(string input);

Engine.cpp

@@ -43,7 +43,8 @@ void Engine::startGame(){
 		}
 		
 		while(b->getTurn() == 'X' ){
-			AI();
+			easyAI();
+			//AI(3);
 		}
 		
 		gameOver = b->isGameOver();
@@ -64,10 +65,9 @@ void Engine::easyAI(){
 }
 
 void Engine::AI(int depth){
-	vector<moves> listOfMoves = b->viewPossibleMoves();
 	Board* temp = new Board(*b);
-	
-	//create node with current board state
+	moves empty;
+	MNode* root = new MNode(*temp, empty, 0);
 	
 	//only doing 1 branch right now because testing
 	/*for (int i = 0; i < listOfMoves.size(); ++i){
@@ -75,33 +75,23 @@ void Engine::AI(int depth){
 	}*/
 	
 	//remove this soon
-	b->move(minMax(temp, listOfMoves[0], 0, 0));
+	//b->move(minMax(temp, listOfMoves[0], 0, 0));
 	
 	b->changeTurns();	
-	
-	//verification of correct turn
-	/*
-	if (b->getTurn() != 'O'){
-		cout << "ERROR in Engine::AI: b is on the wrong turn. \n";
-	}
-	*/
-	
 	b->displayBoard();
 }
 
-moves Engine::minMax(Board* temp, moves m, int c, int r){
-	//testing purposes only, c = finite depth
-	//cout << "c: " << c << "\n\n";
-	//cout << "current turn: " << temp->getTurn() << "\n";
-	vector<moves> listOfMoves = temp->viewPossibleMoves();
-	
-	if (temp->isGameOver() == true){
+moves Engine::minMax(MNode* node, int depth){
+	Board current = node->getState();
+	vector<moves> listOfMoves = current.viewPossibleMoves();
+	/*
+	if (current.isGameOver() == true){
 		cout << "END OF PATH REACHED\n\n";
 		return m;
 	}
 
 	else {
-		if(temp->getPiece(8 - m.row, m.column)->getType() == temp->getTurn() && temp->isThisMovePossible(8 - m.row, m.column, m.moveType)){
+		if(current.getPiece(8 - m.row, m.column)->getType() == current.getTurn() && current.isThisMovePossible(8 - m.row, m.column, m.moveType)){
 			temp->move(m);
 			temp->evaluate('X', 'O');
 			temp->changeTurns();
@@ -114,4 +104,5 @@ moves Engine::minMax(Board* temp, moves m, int c, int r){
 		minMax(temp, listOfMoves[0], 0, 0);
 		return m;
 	}
+	*/
 }

Engine.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Board.h"
+#include "MNode.h"
 
 using namespace std;
 
@@ -13,5 +14,5 @@ public:
 	void startGame();
 	void easyAI();
 	void AI(int depth);
-	moves minMax(Board* temp, moves m, int c, int r);
+	moves minMax(MNode* node, int depth);
 };

MNode.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <vector>
+#include "MNode.h"
+
+using namespace std;
+
+MNode::MNode(){
+	children.clear();
+	minimax_val = -1;
+}
+
+MNode::MNode(Board s, moves m, int mmval){
+	state = s;
+	mvs = m;
+	minimax_val = mmval;
+}
+
+MNode::MNode(const MNode& n){
+	children = n.getChildren();
+	minimax_val = n.getMMVal();
+}
+
+void MNode::setMMVal(int mmval) {
+	minimax_val = mmval; 
+}
+
+bool MNode::hasChildren(){
+	if (children.size() != 0)
+		return true;
+	else
+		return false;
+}
+
+void printTree(int depth, const MNode& n){
+	vector<MNode*> children;
+	cout << "depth " << depth << " :" << n.getMMVal() << " ";
+	children = n.getChildren();
+
+	//print out root
+	for (int i = 0; i < children.size(); ++i){
+		printTree(++depth, *children[i]);
+	}
+}

MNode.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <iostream>
+#include <vector>
+#include "Board.h"
+
+using namespace std;
+
+class MNode {
+	vector<MNode*> children;
+	Board state;
+	moves mvs;
+	int minimax_val;
+	
+public:
+	MNode();
+	MNode(Board s, moves m, int mmval);
+	MNode(const MNode& n);
+	vector<MNode*> getChildren() const { return children; }
+	void addChild(MNode* n) { children.push_back(n); }
+	int getMMVal() const { return minimax_val; }
+	void setMMVal(int mmval);
+	Board getState() { return state; }
+	void setState(Board s) { state = s; }
+	moves getMove() { return mvs; }
+	void setMove(moves m) { mvs = m; }
+	bool hasChildren();
+};
+
+void printTree(int depth, const MNode& n);

makefile

@@ -3,13 +3,13 @@
 all: test server
 
 server: Server.o
-	g++ -std=c++11 -o server Server.o Engine.o Piece.o Board.o
+	g++ -std=c++11 -o server Server.o Engine.o Piece.o Board.o MNode.o
 	
-Server.o: Server.cpp Engine.cpp Board.cpp Piece.cpp
-	g++ -std=c++11 -c -g Server.cpp Engine.cpp Board.cpp Piece.cpp
+Server.o: Server.cpp Engine.cpp Board.cpp Piece.cpp MNode.cpp
+	g++ -std=c++11 -c -g Server.cpp Engine.cpp Board.cpp Piece.cpp MNode.cpp
 	
 test: test.o
-	g++ -std=c++11 -o test test.o Engine.o Piece.o Board.o
+	g++ -std=c++11 -o test test.o Engine.o Piece.o Board.o MNode.o
 	
-test.o: test.cpp Engine.cpp Board.cpp Piece.cpp
-	g++ -std=c++11 -c -g test.cpp Engine.cpp Board.cpp Piece.cpp
+test.o: test.cpp Engine.cpp Board.cpp Piece.cpp MNode.cpp
+	g++ -std=c++11 -c -g test.cpp Engine.cpp Board.cpp Piece.cpp MNode.cpp