From d64552743a65318da557d6ec156f1032b11aebaf Mon Sep 17 00:00:00 2001
From: Rebecca Schofield <scho4077@tamu.edu>
Date: Mon, 19 Oct 2015 15:36:20 -0500
Subject: [PATCH] restructuring main.cpp

---
 Board.cpp      | 500 ++++++++++++++++++++++++++++++++++++++++++
 Board.h        | 390 +++++++++++++++++++++++++++++++++
 GameEngine.cpp | 560 +++++++++++++++++++++++++++++++++++++++++++++++
 GameEngine.h   |  34 +++
 a.out          | Bin 0 -> 37669 bytes
 main.cpp       | 583 +------------------------------------------------
 6 files changed, 1485 insertions(+), 582 deletions(-)
 create mode 100755 Board.cpp
 create mode 100755 Board.h
 create mode 100755 GameEngine.cpp
 create mode 100755 GameEngine.h
 create mode 100755 a.out

diff --git a/Board.cpp b/Board.cpp
new file mode 100755
index 0000000..78b82b3
--- /dev/null
+++ b/Board.cpp
@@ -0,0 +1,500 @@
+class Board
+{
+	char boardArray [8][8];
+	char turn = 'O'; 
+	
+	public:
+	
+	Board()
+	{
+		for (int i = 0; i < 2; ++i)
+		{
+			for (int j = 0; j < 8; ++j)
+			{
+				boardArray[i][j] = 'X'; 
+			}
+		}
+		
+		
+		for (int i = 2; i < 6; ++i)
+		{
+			for (int j = 0; j < 8; ++j)
+			{
+				boardArray[i][j] = '_'; 
+			}
+		}
+		
+		
+		for (int i = 6; i <= 7; ++i)
+		{
+			for (int j = 0; j < 8; ++j)
+			{
+				boardArray[i][j] = 'O'; 
+			}
+		}
+		
+
+			
+	}
+	
+	moves parse(string input)
+	{
+		
+		input = myToUpper(input);
+		
+		cout<<input<<endl;
+		
+		int temp1;
+		char temp2; 
+		string temp3;
+		
+		temp2 = input[0];
+		temp1 = input[1] - '0';
+		
+		if (input[3] == 'L')
+		{
+			temp3 = "LEFT";
+		}
+		
+		else if (input[3] == 'R')
+		{
+			temp3 = "RIGHT";
+		}
+		
+		else
+		{
+			temp3 = "FWD";
+		}
+		
+		moves output(temp1,temp2,temp3);
+		
+		return output;
+		
+	}
+	
+	char getTurn()
+	{
+		return turn;
+	}
+	
+	bool isGameOver()
+	{
+		for (int i = 0; i < 8; ++i)
+		{
+		
+			if (boardArray[0][i] == 'O')
+			{
+				cout<<"\n\n\nplayer O wins!\n\n\n"<<endl;
+				return true;
+			}
+			
+			if (boardArray[7][i] == 'X')
+			{
+				cout<<"\n\n\nplayer X wins!\n\n\n"<<endl;
+				return true;
+			}
+			
+			// else return false;	this line was making this function return false no matter what, apparently...
+		}
+	}
+	
+	
+	void changeTurns()
+	{
+		if (turn == 'O') turn = 'X';
+		else turn = 'O';
+	}
+	
+	
+	
+	
+	
+	void displayBoard()
+	{	
+		cout<<"\n\n";
+		cout<<"  A  B  C  D  E  F  G  H"<<endl;
+		for (int i = 0; i < 8; ++i)
+		{
+			int mango = 8 - i;
+			cout<<mango<<" ";
+			for (int j = 0; j < 8; ++j)
+			{
+				cout<<boardArray[i][j]<<"  ";
+			}
+			cout<<endl;
+		}
+		cout<<'\n'<<endl;
+		cout<<"turn : "<<turn;
+	}
+	
+	
+	int charToIntColumn(char input)	//converts column number to int
+	{
+		int kolumn;
+		
+		switch (input)
+		{
+			case 'A': kolumn = 0; break;
+			case 'B': kolumn = 1; break;
+			case 'C': kolumn = 2; break;
+			case 'D': kolumn = 3; break;
+			case 'E': kolumn = 4; break;
+			case 'F': kolumn = 5; break;
+			case 'G': kolumn = 6; break;
+			case 'H': kolumn = 7; break;
+		}
+		
+		return kolumn;
+	}
+	
+	
+	char intToCharColumn(int input)	//converts column number to int
+	{
+		char kolumn;
+		
+		switch (input)
+		{
+			case 1: kolumn = 'A'; break;
+			case 2: kolumn = 'B'; break;
+			case 3: kolumn = 'C'; break;
+			case 4: kolumn = 'D'; break;
+			case 5: kolumn = 'E'; break;
+			case 6: kolumn = 'F'; break;
+			case 7: kolumn = 'G'; break;
+			case 8: kolumn = 'H'; break;
+		}
+		
+		return kolumn;
+	}
+	
+	
+	
+	void move(string inputMove)	
+	{
+		
+		moves jugada = parse(inputMove);
+		
+		int row = 8 - (jugada.row);
+		int kolumn = charToIntColumn(jugada.column);
+		int temp = boardArray[row][kolumn];
+		int reflector = 1;
+		
+		if (row > 8 || row < 0 || kolumn > 8 || kolumn < 0)
+		{
+			cout<<"ERROR: index out of bound!"<<endl;
+		}
+		
+		else if (temp != turn)
+		{
+			cout<<"you can't move that piece at this turn!"<<endl; 
+		}
+		
+		else if (temp == '_')
+		{
+			cout<<"there's no piece in that spot!"<<endl;
+		}
+		
+		else if (temp == 'X' || temp == 'O')
+		{
+				
+			if (temp == 'O')
+			{
+				reflector *= -1;
+			}
+			
+			
+			if (jugada.moveType == "FWD")
+			{
+				
+				if(boardArray[row+reflector][kolumn] != '_')
+				{
+					cout<<"you can't move that piece forward"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn] = temp;
+					
+					changeTurns();
+					displayBoard();
+					
+				}	
+			}
+			
+			else if (jugada.moveType == "LEFT")
+			{
+				if (kolumn == 0)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn-1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn-1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else if (jugada.moveType == "RIGHT")
+			{
+				if (kolumn == 7)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn+1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn+1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else
+			{
+					cout<<"Unrecognized movetype!"<<endl;	
+			}
+
+				
+		}
+		
+		else
+		{
+			cout<<"Invalid piece!"<<endl;	
+		}	
+		
+	
+	}
+	
+	
+	void move(moves jugada)	
+	{
+		
+		int row = 8 - (jugada.row);
+		int kolumn = charToIntColumn(jugada.column);
+		
+		if (row > 8 || row < 0 || kolumn > 8 || kolumn < 0)
+		{
+			cout<<"ERROR: index out of bound!"<<endl;
+		}
+		
+		int temp = boardArray[row][kolumn];
+		if (temp != turn)
+		{
+			cout<<"you can't move that piece at this turn!"<<endl; 
+		}
+		
+		else if (temp == '_')
+		{
+			cout<<"there's no piece in that spot!"<<endl;
+		}
+		
+		int reflector = 1;
+		
+		if (temp == 'X' || temp == 'O')
+		{
+				
+			if (temp == 'O')
+			{
+				reflector *= -1;
+			}
+			
+			
+			if (jugada.moveType == "FWD")
+			{
+				
+				if(boardArray[row+reflector][kolumn] != '_')
+				{
+					cout<<"you can't move that piece forward"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn] = temp;
+					
+					changeTurns();
+					displayBoard();
+					
+				}	
+			}
+			
+			else if (jugada.moveType == "LEFT")
+			{
+				if (kolumn == 0)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn-1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn-1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else if (jugada.moveType == "RIGHT")
+			{
+				if (kolumn == 7)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn+1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn+1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else
+			{
+					cout<<"Unrecognized movetype!"<<endl;	
+			}	
+		}
+		
+		else
+		{
+			cout<<"Invalid piece!"<<endl;	
+		}	
+		
+	}
+	
+	
+	
+	bool isThisMovePossible(int r, int c, string moveType)
+	{
+		char pieceToMove = boardArray[r][c];
+		
+		if (pieceToMove != turn) //trying to move invalid piece
+		{
+			return false;
+		}
+		
+		int reflector = 1;
+		
+		if (pieceToMove == 'O')
+		{
+			reflector *= -1;
+		}
+		
+		else
+		{
+			if (moveType == "FWD")
+			{
+				
+				if (boardArray[r+reflector][c] == '_') return true;
+				else return false;
+		
+			}
+			
+			else if (moveType == "RIGHT")
+			{				
+				if (boardArray[r+reflector][c+1] != pieceToMove && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 <= 7) ) return true;
+				else return false;
+			}
+			
+			else if (moveType == "LEFT")
+			{
+				if (boardArray[r+reflector][c-1] != pieceToMove && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 >= 0) ) return true;
+				else return false;
+			}
+			
+			else return false;
+		}
+	}
+	
+
+	
+	
+	vector<moves> viewPossibleMoves()
+	{
+		vector<moves> output;
+		
+		for (int r = 0; r < 8; ++r)
+		{
+			for (int c = 0; c < 8; ++c)
+			{
+				if (boardArray[r][c] == turn)
+				{
+					if (isThisMovePossible(r,c,"FWD"))
+					{
+						moves temp(8-r,intToCharColumn(c+1),"FWD");
+						output.push_back(temp);
+					}
+					
+					if (isThisMovePossible(r,c,"LEFT"))
+					{
+						moves temp(8-r,intToCharColumn(c+1),"LEFT");
+						output.push_back(temp);
+					}
+					
+					if (isThisMovePossible(r,c,"RIGHT"))
+					{
+						moves temp(8-r,intToCharColumn(c+1),"RIGHT");
+						output.push_back(temp);
+					}
+					
+				}
+			}
+		}
+		
+		return output;
+	}
+	
+	
+	void easyAI()
+	{
+	
+		//1) see all possible movements
+		
+		vector<moves> listOfMoves = viewPossibleMoves();
+		
+		//2) pick a movement
+		
+		srand(time(NULL));
+		int randomChoice = rand() % (listOfMoves.size()-1) - 0; // choose a move betwen listOfMoves[0] to last element
+		
+		//3) execute movement
+		
+		int temp = randomChoice;
+		
+		move(listOfMoves[randomChoice]);
+		
+		//cout<<"\n\nMove executed by AI: "<<listOfMoves[temp].column<<" "<<listOfMoves[temp].row<<" "<<listOfMoves[temp].moveType<<endl;	uncomment for debugging purposes
+	
+	}
+	
+};
\ No newline at end of file
diff --git a/Board.h b/Board.h
new file mode 100755
index 0000000..84ba214
--- /dev/null
+++ b/Board.h
@@ -0,0 +1,390 @@
+#pragma once
+
+using namespace std;
+
+class Board {
+	char boardArray [8][8];
+	char turn = 'O'; 
+	
+public:
+	Board();
+	
+	moves parse(string input);
+	
+	char getTurn() { return turn; }
+	
+	bool isGameOver();
+	void changeTurns();
+	void displayBoard();
+	
+	
+	int charToIntColumn(char input)	//converts column number to int
+	{
+		int kolumn;
+		
+		switch (input)
+		{
+			case 'A': kolumn = 0; break;
+			case 'B': kolumn = 1; break;
+			case 'C': kolumn = 2; break;
+			case 'D': kolumn = 3; break;
+			case 'E': kolumn = 4; break;
+			case 'F': kolumn = 5; break;
+			case 'G': kolumn = 6; break;
+			case 'H': kolumn = 7; break;
+		}
+		
+		return kolumn;
+	}
+	
+	
+	char intToCharColumn(int input)	//converts column number to int
+	{
+		char kolumn;
+		
+		switch (input)
+		{
+			case 1: kolumn = 'A'; break;
+			case 2: kolumn = 'B'; break;
+			case 3: kolumn = 'C'; break;
+			case 4: kolumn = 'D'; break;
+			case 5: kolumn = 'E'; break;
+			case 6: kolumn = 'F'; break;
+			case 7: kolumn = 'G'; break;
+			case 8: kolumn = 'H'; break;
+		}
+		
+		return kolumn;
+	}
+	
+	
+	
+	void move(string inputMove)	
+	{
+		
+		moves jugada = parse(inputMove);
+		
+		int row = 8 - (jugada.row);
+		int kolumn = charToIntColumn(jugada.column);
+		int temp = boardArray[row][kolumn];
+		int reflector = 1;
+		
+		if (row > 8 || row < 0 || kolumn > 8 || kolumn < 0)
+		{
+			cout<<"ERROR: index out of bound!"<<endl;
+		}
+		
+		else if (temp != turn)
+		{
+			cout<<"you can't move that piece at this turn!"<<endl; 
+		}
+		
+		else if (temp == '_')
+		{
+			cout<<"there's no piece in that spot!"<<endl;
+		}
+		
+		else if (temp == 'X' || temp == 'O')
+		{
+				
+			if (temp == 'O')
+			{
+				reflector *= -1;
+			}
+			
+			
+			if (jugada.moveType == "FWD")
+			{
+				
+				if(boardArray[row+reflector][kolumn] != '_')
+				{
+					cout<<"you can't move that piece forward"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn] = temp;
+					
+					changeTurns();
+					displayBoard();
+					
+				}	
+			}
+			
+			else if (jugada.moveType == "LEFT")
+			{
+				if (kolumn == 0)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn-1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn-1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else if (jugada.moveType == "RIGHT")
+			{
+				if (kolumn == 7)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn+1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn+1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else
+			{
+					cout<<"Unrecognized movetype!"<<endl;	
+			}
+
+				
+		}
+		
+		else
+		{
+			cout<<"Invalid piece!"<<endl;	
+		}	
+		
+	
+	}
+	
+	
+	void move(moves jugada)	
+	{
+		
+		int row = 8 - (jugada.row);
+		int kolumn = charToIntColumn(jugada.column);
+		
+		if (row > 8 || row < 0 || kolumn > 8 || kolumn < 0)
+		{
+			cout<<"ERROR: index out of bound!"<<endl;
+		}
+		
+		int temp = boardArray[row][kolumn];
+		if (temp != turn)
+		{
+			cout<<"you can't move that piece at this turn!"<<endl; 
+		}
+		
+		else if (temp == '_')
+		{
+			cout<<"there's no piece in that spot!"<<endl;
+		}
+		
+		int reflector = 1;
+		
+		if (temp == 'X' || temp == 'O')
+		{
+				
+			if (temp == 'O')
+			{
+				reflector *= -1;
+			}
+			
+			
+			if (jugada.moveType == "FWD")
+			{
+				
+				if(boardArray[row+reflector][kolumn] != '_')
+				{
+					cout<<"you can't move that piece forward"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn] = temp;
+					
+					changeTurns();
+					displayBoard();
+					
+				}	
+			}
+			
+			else if (jugada.moveType == "LEFT")
+			{
+				if (kolumn == 0)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn-1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn-1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else if (jugada.moveType == "RIGHT")
+			{
+				if (kolumn == 7)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn+1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn+1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else
+			{
+					cout<<"Unrecognized movetype!"<<endl;	
+			}	
+		}
+		
+		else
+		{
+			cout<<"Invalid piece!"<<endl;	
+		}	
+		
+	}
+	
+	
+	
+	bool isThisMovePossible(int r, int c, string moveType)
+	{
+		char pieceToMove = boardArray[r][c];
+		
+		if (pieceToMove != turn) //trying to move invalid piece
+		{
+			return false;
+		}
+		
+		int reflector = 1;
+		
+		if (pieceToMove == 'O')
+		{
+			reflector *= -1;
+		}
+		
+		else
+		{
+			if (moveType == "FWD")
+			{
+				
+				if (boardArray[r+reflector][c] == '_') return true;
+				else return false;
+		
+			}
+			
+			else if (moveType == "RIGHT")
+			{				
+				if (boardArray[r+reflector][c+1] != pieceToMove && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 <= 7) ) return true;
+				else return false;
+			}
+			
+			else if (moveType == "LEFT")
+			{
+				if (boardArray[r+reflector][c-1] != pieceToMove && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 >= 0) ) return true;
+				else return false;
+			}
+			
+			else return false;
+		}
+	}
+	
+
+	
+	
+	vector<moves> viewPossibleMoves()
+	{
+		vector<moves> output;
+		
+		for (int r = 0; r < 8; ++r)
+		{
+			for (int c = 0; c < 8; ++c)
+			{
+				if (boardArray[r][c] == turn)
+				{
+					if (isThisMovePossible(r,c,"FWD"))
+					{
+						moves temp(8-r,intToCharColumn(c+1),"FWD");
+						output.push_back(temp);
+					}
+					
+					if (isThisMovePossible(r,c,"LEFT"))
+					{
+						moves temp(8-r,intToCharColumn(c+1),"LEFT");
+						output.push_back(temp);
+					}
+					
+					if (isThisMovePossible(r,c,"RIGHT"))
+					{
+						moves temp(8-r,intToCharColumn(c+1),"RIGHT");
+						output.push_back(temp);
+					}
+					
+				}
+			}
+		}
+		
+		return output;
+	}
+	
+	
+	void easyAI()
+	{
+	
+		//1) see all possible movements
+		
+		vector<moves> listOfMoves = viewPossibleMoves();
+		
+		//2) pick a movement
+		
+		srand(time(NULL));
+		int randomChoice = rand() % (listOfMoves.size()-1) - 0; // choose a move betwen listOfMoves[0] to last element
+		
+		//3) execute movement
+		
+		int temp = randomChoice;
+		
+		move(listOfMoves[randomChoice]);
+		
+		//cout<<"\n\nMove executed by AI: "<<listOfMoves[temp].column<<" "<<listOfMoves[temp].row<<" "<<listOfMoves[temp].moveType<<endl;	uncomment for debugging purposes
+	
+	}
+	
+};
\ No newline at end of file
diff --git a/GameEngine.cpp b/GameEngine.cpp
new file mode 100755
index 0000000..a5c7506
--- /dev/null
+++ b/GameEngine.cpp
@@ -0,0 +1,560 @@
+#include <iostream>
+#include <vector>
+#include <stdlib.h>
+#include <stdio.h>
+#include "GameEngine.h"
+
+using namespace std;
+
+string myToUpper(string input)
+{
+	string output;
+	
+	for (int i = 0 ; i < input.size(); ++i)
+	{
+		int numeric;
+		
+		if ((input[i] - 0 >= 97) && (input[i] - 0 <= 122))
+		{
+			numeric = input[i] - 32;
+			output.push_back((char)numeric);// = 'Q';//(char) numeric;
+		}
+		else output.push_back(input[i]);
+	}
+	
+	for (int i = 0; i < output.size(); ++i)
+	{
+		cout<<output[i]<<endl;
+	}
+	
+	return output;
+	
+}
+
+
+
+
+struct moves
+{
+	int row;
+	char column;
+	string moveType;
+	
+	moves(int linea, int columna, string m)
+	{
+		row = linea;
+		column = columna;
+		moveType = m;
+	}
+};
+
+class Board
+{
+	char boardArray [8][8];
+	char turn = 'O'; 
+	
+	public:
+	
+	Board()
+	{
+		for (int i = 0; i < 2; ++i)
+		{
+			for (int j = 0; j < 8; ++j)
+			{
+				boardArray[i][j] = 'X'; 
+			}
+		}
+		
+		
+		for (int i = 2; i < 6; ++i)
+		{
+			for (int j = 0; j < 8; ++j)
+			{
+				boardArray[i][j] = '_'; 
+			}
+		}
+		
+		
+		for (int i = 6; i <= 7; ++i)
+		{
+			for (int j = 0; j < 8; ++j)
+			{
+				boardArray[i][j] = 'O'; 
+			}
+		}
+		
+
+			
+	}
+	
+	moves parse(string input)
+	{
+		
+		input = myToUpper(input);
+		
+		cout<<input<<endl;
+		
+		int temp1;
+		char temp2; 
+		string temp3;
+		
+		temp2 = input[0];
+		temp1 = input[1] - '0';
+		
+		if (input[3] == 'L')
+		{
+			temp3 = "LEFT";
+		}
+		
+		else if (input[3] == 'R')
+		{
+			temp3 = "RIGHT";
+		}
+		
+		else
+		{
+			temp3 = "FWD";
+		}
+		
+		moves output(temp1,temp2,temp3);
+		
+		return output;
+		
+	}
+	
+	char getTurn()
+	{
+		return turn;
+	}
+	
+	bool isGameOver()
+	{
+		for (int i = 0; i < 8; ++i)
+		{
+		
+			if (boardArray[0][i] == 'O')
+			{
+				cout<<"\n\n\nplayer O wins!\n\n\n"<<endl;
+				return true;
+			}
+			
+			if (boardArray[7][i] == 'X')
+			{
+				cout<<"\n\n\nplayer X wins!\n\n\n"<<endl;
+				return true;
+			}
+			
+			// else return false;	this line was making this function return false no matter what, apparently...
+		}
+	}
+	
+	
+	void changeTurns()
+	{
+		if (turn == 'O') turn = 'X';
+		else turn = 'O';
+	}
+	
+	
+	
+	
+	
+	void displayBoard()
+	{	
+		cout<<"\n\n";
+		cout<<"  A  B  C  D  E  F  G  H"<<endl;
+		for (int i = 0; i < 8; ++i)
+		{
+			int mango = 8 - i;
+			cout<<mango<<" ";
+			for (int j = 0; j < 8; ++j)
+			{
+				cout<<boardArray[i][j]<<"  ";
+			}
+			cout<<endl;
+		}
+		cout<<'\n'<<endl;
+		cout<<"turn : "<<turn;
+	}
+	
+	
+	int charToIntColumn(char input)	//converts column number to int
+	{
+		int kolumn;
+		
+		switch (input)
+		{
+			case 'A': kolumn = 0; break;
+			case 'B': kolumn = 1; break;
+			case 'C': kolumn = 2; break;
+			case 'D': kolumn = 3; break;
+			case 'E': kolumn = 4; break;
+			case 'F': kolumn = 5; break;
+			case 'G': kolumn = 6; break;
+			case 'H': kolumn = 7; break;
+		}
+		
+		return kolumn;
+	}
+	
+	
+	char intToCharColumn(int input)	//converts column number to int
+	{
+		char kolumn;
+		
+		switch (input)
+		{
+			case 1: kolumn = 'A'; break;
+			case 2: kolumn = 'B'; break;
+			case 3: kolumn = 'C'; break;
+			case 4: kolumn = 'D'; break;
+			case 5: kolumn = 'E'; break;
+			case 6: kolumn = 'F'; break;
+			case 7: kolumn = 'G'; break;
+			case 8: kolumn = 'H'; break;
+		}
+		
+		return kolumn;
+	}
+	
+	
+	
+	void move(string inputMove)	
+	{
+		
+		moves jugada = parse(inputMove);
+		
+		int row = 8 - (jugada.row);
+		int kolumn = charToIntColumn(jugada.column);
+		int temp = boardArray[row][kolumn];
+		int reflector = 1;
+		
+		if (row > 8 || row < 0 || kolumn > 8 || kolumn < 0)
+		{
+			cout<<"ERROR: index out of bound!"<<endl;
+		}
+		
+		else if (temp != turn)
+		{
+			cout<<"you can't move that piece at this turn!"<<endl; 
+		}
+		
+		else if (temp == '_')
+		{
+			cout<<"there's no piece in that spot!"<<endl;
+		}
+		
+		else if (temp == 'X' || temp == 'O')
+		{
+				
+			if (temp == 'O')
+			{
+				reflector *= -1;
+			}
+			
+			
+			if (jugada.moveType == "FWD")
+			{
+				
+				if(boardArray[row+reflector][kolumn] != '_')
+				{
+					cout<<"you can't move that piece forward"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn] = temp;
+					
+					changeTurns();
+					displayBoard();
+					
+				}	
+			}
+			
+			else if (jugada.moveType == "LEFT")
+			{
+				if (kolumn == 0)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn-1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn-1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else if (jugada.moveType == "RIGHT")
+			{
+				if (kolumn == 7)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn+1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn+1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else
+			{
+					cout<<"Unrecognized movetype!"<<endl;	
+			}
+
+				
+		}
+		
+		else
+		{
+			cout<<"Invalid piece!"<<endl;	
+		}	
+		
+	
+	}
+	
+	
+	void move(moves jugada)	
+	{
+		
+		int row = 8 - (jugada.row);
+		int kolumn = charToIntColumn(jugada.column);
+		
+		if (row > 8 || row < 0 || kolumn > 8 || kolumn < 0)
+		{
+			cout<<"ERROR: index out of bound!"<<endl;
+		}
+		
+		int temp = boardArray[row][kolumn];
+		if (temp != turn)
+		{
+			cout<<"you can't move that piece at this turn!"<<endl; 
+		}
+		
+		else if (temp == '_')
+		{
+			cout<<"there's no piece in that spot!"<<endl;
+		}
+		
+		int reflector = 1;
+		
+		if (temp == 'X' || temp == 'O')
+		{
+				
+			if (temp == 'O')
+			{
+				reflector *= -1;
+			}
+			
+			
+			if (jugada.moveType == "FWD")
+			{
+				
+				if(boardArray[row+reflector][kolumn] != '_')
+				{
+					cout<<"you can't move that piece forward"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn] = temp;
+					
+					changeTurns();
+					displayBoard();
+					
+				}	
+			}
+			
+			else if (jugada.moveType == "LEFT")
+			{
+				if (kolumn == 0)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn-1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn-1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else if (jugada.moveType == "RIGHT")
+			{
+				if (kolumn == 7)
+				{
+					cout<<"Destination Spot out of range!"<<endl;
+				}
+				
+				else if (boardArray[row+reflector][kolumn+1] == temp)
+				{
+					cout<<"you hate your own team or something? you can't do that!"<<endl;
+				}
+				
+				else
+				{
+					boardArray[row][kolumn] = '_';
+					boardArray[row+reflector][kolumn+1] = temp;
+			
+					changeTurns();
+					displayBoard();
+				}	
+			}
+			
+			else
+			{
+					cout<<"Unrecognized movetype!"<<endl;	
+			}	
+		}
+		
+		else
+		{
+			cout<<"Invalid piece!"<<endl;	
+		}	
+		
+	}
+	
+	
+	
+	bool isThisMovePossible(int r, int c, string moveType)
+	{
+		char pieceToMove = boardArray[r][c];
+		
+		if (pieceToMove != turn) //trying to move invalid piece
+		{
+			return false;
+		}
+		
+		int reflector = 1;
+		
+		if (pieceToMove == 'O')
+		{
+			reflector *= -1;
+		}
+		
+		else
+		{
+			if (moveType == "FWD")
+			{
+				
+				if (boardArray[r+reflector][c] == '_') return true;
+				else return false;
+		
+			}
+			
+			else if (moveType == "RIGHT")
+			{				
+				if (boardArray[r+reflector][c+1] != pieceToMove && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 <= 7) ) return true;
+				else return false;
+			}
+			
+			else if (moveType == "LEFT")
+			{
+				if (boardArray[r+reflector][c-1] != pieceToMove && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 >= 0) ) return true;
+				else return false;
+			}
+			
+			else return false;
+		}
+	}
+	
+
+	
+	
+	vector<moves> viewPossibleMoves()
+	{
+		vector<moves> output;
+		
+		for (int r = 0; r < 8; ++r)
+		{
+			for (int c = 0; c < 8; ++c)
+			{
+				if (boardArray[r][c] == turn)
+				{
+					if (isThisMovePossible(r,c,"FWD"))
+					{
+						moves temp(8-r,intToCharColumn(c+1),"FWD");
+						output.push_back(temp);
+					}
+					
+					if (isThisMovePossible(r,c,"LEFT"))
+					{
+						moves temp(8-r,intToCharColumn(c+1),"LEFT");
+						output.push_back(temp);
+					}
+					
+					if (isThisMovePossible(r,c,"RIGHT"))
+					{
+						moves temp(8-r,intToCharColumn(c+1),"RIGHT");
+						output.push_back(temp);
+					}
+					
+				}
+			}
+		}
+		
+		return output;
+	}
+	
+	
+	void easyAI()
+	{
+	
+		//1) see all possible movements
+		
+		vector<moves> listOfMoves = viewPossibleMoves();
+		
+		//2) pick a movement
+		
+		srand(time(NULL));
+		int randomChoice = rand() % (listOfMoves.size()-1) - 0; // choose a move betwen listOfMoves[0] to last element
+		
+		//3) execute movement
+		
+		int temp = randomChoice;
+		
+		move(listOfMoves[randomChoice]);
+		
+		//cout<<"\n\nMove executed by AI: "<<listOfMoves[temp].column<<" "<<listOfMoves[temp].row<<" "<<listOfMoves[temp].moveType<<endl;	uncomment for debugging purposes
+	
+	}
+	
+};
+
+
+void displayPossibleMoves(vector<moves> input)
+{
+	cout<<"\n\nList of possible Moves:"<<endl;
+	for (int i = 0; i < input.size(); ++i)
+	{
+		cout<<"possible move: "<<input[i].row<<" "<<input[i].column<<" "<<input[i].moveType<<endl;
+	}
+}
\ No newline at end of file
diff --git a/GameEngine.h b/GameEngine.h
new file mode 100755
index 0000000..ec74850
--- /dev/null
+++ b/GameEngine.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <vector>
+#include "Board.h"
+
+using namespace std;
+
+string myToUpper(string input);
+
+struct moves
+{
+	int row;
+	char column;
+	string moveType;
+	
+	moves(int linea, int columna, string m)
+	{
+		row = linea;
+		column = columna;
+		moveType = m;
+	}
+};
+
+
+
+
+void displayPossibleMoves(vector<moves> input)
+{
+	cout<<"\n\nList of possible Moves:"<<endl;
+	for (int i = 0; i < input.size(); ++i)
+	{
+		cout<<"possible move: "<<input[i].row<<" "<<input[i].column<<" "<<input[i].moveType<<endl;
+	}
+}
\ No newline at end of file
diff --git a/a.out b/a.out
new file mode 100755
index 0000000000000000000000000000000000000000..32beef92fb87a4020ba9cd7a240480f6d646485f
GIT binary patch
literal 37669
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
agQ*)%^Gvl2EQ?q(+R5iLw71%G8UF`gqZph3

literal 0
HcmV?d00001

diff --git a/main.cpp b/main.cpp
index e365e5b..6e8a8e0 100644
--- a/main.cpp
+++ b/main.cpp
@@ -2,591 +2,10 @@
 #include <vector>
 #include <stdlib.h>
 #include <stdio.h>
-
+#include "GameEngine.h"
 
 using namespace std;
 
-// class piece
-// {
-	// char color;	//w for white, b for white, e for empty
-	// int xpos;
-	// int ypos;
-	
-	// public:
-	
-	// piece(int x, int y)
-	// {
-		// xpos = x;
-		// ypos = y;
-	// }
-	
-	// void setColor(char kolor)
-	// {
-		// color = kolor;
-	// }
-	
-	// char getColor()
-	// {
-		// return color;
-	// }
-// };
-
-
-string myToUpper(string input)
-{
-	string output;
-	
-	for (int i = 0 ; i < input.size(); ++i)
-	{
-		int numeric;
-		
-		if ((input[i] - 0 >= 97) && (input[i] - 0 <= 122))
-		{
-			numeric = input[i] - 32;
-			output.push_back((char)numeric);// = 'Q';//(char) numeric;
-		}
-		else output.push_back(input[i]);
-	}
-	
-	for (int i = 0; i < output.size(); ++i)
-	{
-		cout<<output[i]<<endl;
-	}
-	
-	return output;
-	
-}
-
-
-
-
-struct moves
-{
-	int row;
-	char column;
-	string moveType;
-	
-	moves(int linea, int columna, string m)
-	{
-		row = linea;
-		column = columna;
-		moveType = m;
-	}
-};
-
-class Board
-{
-	char boardArray [8][8];
-	char turn = 'O'; 
-	
-	public:
-	
-	Board()
-	{
-		for (int i = 0; i < 2; ++i)
-		{
-			for (int j = 0; j < 8; ++j)
-			{
-				boardArray[i][j] = 'X'; 
-			}
-		}
-		
-		
-		for (int i = 2; i < 6; ++i)
-		{
-			for (int j = 0; j < 8; ++j)
-			{
-				boardArray[i][j] = '_'; 
-			}
-		}
-		
-		
-		for (int i = 6; i <= 7; ++i)
-		{
-			for (int j = 0; j < 8; ++j)
-			{
-				boardArray[i][j] = 'O'; 
-			}
-		}
-		
-
-			
-	}
-	
-	moves parse(string input)
-	{
-		
-		input = myToUpper(input);
-		
-		cout<<input<<endl;
-		
-		int temp1;
-		char temp2; 
-		string temp3;
-		
-		temp2 = input[0];
-		temp1 = input[1] - '0';
-		
-		if (input[3] == 'L')
-		{
-			temp3 = "LEFT";
-		}
-		
-		else if (input[3] == 'R')
-		{
-			temp3 = "RIGHT";
-		}
-		
-		else
-		{
-			temp3 = "FWD";
-		}
-		
-		moves output(temp1,temp2,temp3);
-		
-		return output;
-		
-	}
-	
-	char getTurn()
-	{
-		return turn;
-	}
-	
-	bool isGameOver()
-	{
-		for (int i = 0; i < 8; ++i)
-		{
-		
-			if (boardArray[0][i] == 'O')
-			{
-				cout<<"\n\n\nplayer O wins!\n\n\n"<<endl;
-				return true;
-			}
-			
-			if (boardArray[7][i] == 'X')
-			{
-				cout<<"\n\n\nplayer X wins!\n\n\n"<<endl;
-				return true;
-			}
-			
-			// else return false;	this line was making this function return false no matter what, apparently...
-		}
-	}
-	
-	
-	void changeTurns()
-	{
-		if (turn == 'O') turn = 'X';
-		else turn = 'O';
-	}
-	
-	
-	
-	
-	
-	void displayBoard()
-	{	
-		cout<<"\n\n";
-		cout<<"  A  B  C  D  E  F  G  H"<<endl;
-		for (int i = 0; i < 8; ++i)
-		{
-			int mango = 8 - i;
-			cout<<mango<<" ";
-			for (int j = 0; j < 8; ++j)
-			{
-				cout<<boardArray[i][j]<<"  ";
-			}
-			cout<<endl;
-		}
-		cout<<'\n'<<endl;
-		cout<<"turn : "<<turn;
-	}
-	
-	
-	int charToIntColumn(char input)	//converts column number to int
-	{
-		int kolumn;
-		
-		switch (input)
-		{
-			case 'A': kolumn = 0; break;
-			case 'B': kolumn = 1; break;
-			case 'C': kolumn = 2; break;
-			case 'D': kolumn = 3; break;
-			case 'E': kolumn = 4; break;
-			case 'F': kolumn = 5; break;
-			case 'G': kolumn = 6; break;
-			case 'H': kolumn = 7; break;
-		}
-		
-		return kolumn;
-	}
-	
-	
-	char intToCharColumn(int input)	//converts column number to int
-	{
-		char kolumn;
-		
-		switch (input)
-		{
-			case 1: kolumn = 'A'; break;
-			case 2: kolumn = 'B'; break;
-			case 3: kolumn = 'C'; break;
-			case 4: kolumn = 'D'; break;
-			case 5: kolumn = 'E'; break;
-			case 6: kolumn = 'F'; break;
-			case 7: kolumn = 'G'; break;
-			case 8: kolumn = 'H'; break;
-		}
-		
-		return kolumn;
-	}
-	
-	
-	
-	void move(string inputMove)	
-	{
-		
-		moves jugada = parse(inputMove);
-		
-		int row = 8 - (jugada.row);
-		int kolumn = charToIntColumn(jugada.column);
-		int temp = boardArray[row][kolumn];
-		int reflector = 1;
-		
-		if (row > 8 || row < 0 || kolumn > 8 || kolumn < 0)
-		{
-			cout<<"ERROR: index out of bound!"<<endl;
-		}
-		
-		else if (temp != turn)
-		{
-			cout<<"you can't move that piece at this turn!"<<endl; 
-		}
-		
-		else if (temp == '_')
-		{
-			cout<<"there's no piece in that spot!"<<endl;
-		}
-		
-		else if (temp == 'X' || temp == 'O')
-		{
-				
-			if (temp == 'O')
-			{
-				reflector *= -1;
-			}
-			
-			
-			if (jugada.moveType == "FWD")
-			{
-				
-				if(boardArray[row+reflector][kolumn] != '_')
-				{
-					cout<<"you can't move that piece forward"<<endl;
-				}
-				
-				else
-				{
-					boardArray[row][kolumn] = '_';
-					boardArray[row+reflector][kolumn] = temp;
-					
-					changeTurns();
-					displayBoard();
-					
-				}	
-			}
-			
-			else if (jugada.moveType == "LEFT")
-			{
-				if (kolumn == 0)
-				{
-					cout<<"Destination Spot out of range!"<<endl;
-				}
-				
-				else if (boardArray[row+reflector][kolumn-1] == temp)
-				{
-					cout<<"you hate your own team or something? you can't do that!"<<endl;
-				}
-				
-				else
-				{
-					boardArray[row][kolumn] = '_';
-					boardArray[row+reflector][kolumn-1] = temp;
-			
-					changeTurns();
-					displayBoard();
-				}	
-			}
-			
-			else if (jugada.moveType == "RIGHT")
-			{
-				if (kolumn == 7)
-				{
-					cout<<"Destination Spot out of range!"<<endl;
-				}
-				
-				else if (boardArray[row+reflector][kolumn+1] == temp)
-				{
-					cout<<"you hate your own team or something? you can't do that!"<<endl;
-				}
-				
-				else
-				{
-					boardArray[row][kolumn] = '_';
-					boardArray[row+reflector][kolumn+1] = temp;
-			
-					changeTurns();
-					displayBoard();
-				}	
-			}
-			
-			else
-			{
-					cout<<"Unrecognized movetype!"<<endl;	
-			}
-
-				
-		}
-		
-		else
-		{
-			cout<<"Invalid piece!"<<endl;	
-		}	
-		
-	
-	}
-	
-	
-	void move(moves jugada)	
-	{
-		
-		int row = 8 - (jugada.row);
-		int kolumn = charToIntColumn(jugada.column);
-		
-		if (row > 8 || row < 0 || kolumn > 8 || kolumn < 0)
-		{
-			cout<<"ERROR: index out of bound!"<<endl;
-		}
-		
-		int temp = boardArray[row][kolumn];
-		if (temp != turn)
-		{
-			cout<<"you can't move that piece at this turn!"<<endl; 
-		}
-		
-		else if (temp == '_')
-		{
-			cout<<"there's no piece in that spot!"<<endl;
-		}
-		
-		int reflector = 1;
-		
-		if (temp == 'X' || temp == 'O')
-		{
-				
-			if (temp == 'O')
-			{
-				reflector *= -1;
-			}
-			
-			
-			if (jugada.moveType == "FWD")
-			{
-				
-				if(boardArray[row+reflector][kolumn] != '_')
-				{
-					cout<<"you can't move that piece forward"<<endl;
-				}
-				
-				else
-				{
-					boardArray[row][kolumn] = '_';
-					boardArray[row+reflector][kolumn] = temp;
-					
-					changeTurns();
-					displayBoard();
-					
-				}	
-			}
-			
-			else if (jugada.moveType == "LEFT")
-			{
-				if (kolumn == 0)
-				{
-					cout<<"Destination Spot out of range!"<<endl;
-				}
-				
-				else if (boardArray[row+reflector][kolumn-1] == temp)
-				{
-					cout<<"you hate your own team or something? you can't do that!"<<endl;
-				}
-				
-				else
-				{
-					boardArray[row][kolumn] = '_';
-					boardArray[row+reflector][kolumn-1] = temp;
-			
-					changeTurns();
-					displayBoard();
-				}	
-			}
-			
-			else if (jugada.moveType == "RIGHT")
-			{
-				if (kolumn == 7)
-				{
-					cout<<"Destination Spot out of range!"<<endl;
-				}
-				
-				else if (boardArray[row+reflector][kolumn+1] == temp)
-				{
-					cout<<"you hate your own team or something? you can't do that!"<<endl;
-				}
-				
-				else
-				{
-					boardArray[row][kolumn] = '_';
-					boardArray[row+reflector][kolumn+1] = temp;
-			
-					changeTurns();
-					displayBoard();
-				}	
-			}
-			
-			else
-			{
-					cout<<"Unrecognized movetype!"<<endl;	
-			}	
-		}
-		
-		else
-		{
-			cout<<"Invalid piece!"<<endl;	
-		}	
-		
-	}
-	
-	
-	
-	bool isThisMovePossible(int r, int c, string moveType)
-	{
-		char pieceToMove = boardArray[r][c];
-		
-		if (pieceToMove != turn) //trying to move invalid piece
-		{
-			return false;
-		}
-		
-		int reflector = 1;
-		
-		if (pieceToMove == 'O')
-		{
-			reflector *= -1;
-		}
-		
-		else
-		{
-			if (moveType == "FWD")
-			{
-				
-				if (boardArray[r+reflector][c] == '_') return true;
-				else return false;
-		
-			}
-			
-			else if (moveType == "RIGHT")
-			{				
-				if (boardArray[r+reflector][c+1] != pieceToMove && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 <= 7) ) return true;
-				else return false;
-			}
-			
-			else if (moveType == "LEFT")
-			{
-				if (boardArray[r+reflector][c-1] != pieceToMove && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 >= 0) ) return true;
-				else return false;
-			}
-			
-			else return false;
-		}
-	}
-	
-
-	
-	
-	vector<moves> viewPossibleMoves()
-	{
-		vector<moves> output;
-		
-		for (int r = 0; r < 8; ++r)
-		{
-			for (int c = 0; c < 8; ++c)
-			{
-				if (boardArray[r][c] == turn)
-				{
-					if (isThisMovePossible(r,c,"FWD"))
-					{
-						moves temp(8-r,intToCharColumn(c+1),"FWD");
-						output.push_back(temp);
-					}
-					
-					if (isThisMovePossible(r,c,"LEFT"))
-					{
-						moves temp(8-r,intToCharColumn(c+1),"LEFT");
-						output.push_back(temp);
-					}
-					
-					if (isThisMovePossible(r,c,"RIGHT"))
-					{
-						moves temp(8-r,intToCharColumn(c+1),"RIGHT");
-						output.push_back(temp);
-					}
-					
-				}
-			}
-		}
-		
-		return output;
-	}
-	
-	
-	void easyAI()
-	{
-	
-		//1) see all possible movements
-		
-		vector<moves> listOfMoves = viewPossibleMoves();
-		
-		//2) pick a movement
-		
-		srand(time(NULL));
-		int randomChoice = rand() % (listOfMoves.size()-1) - 0; // choose a move betwen listOfMoves[0] to last element
-		
-		//3) execute movement
-		
-		int temp = randomChoice;
-		
-		move(listOfMoves[randomChoice]);
-		
-		//cout<<"\n\nMove executed by AI: "<<listOfMoves[temp].column<<" "<<listOfMoves[temp].row<<" "<<listOfMoves[temp].moveType<<endl;	uncomment for debugging purposes
-	
-	}
-	
-};
-
-
-void displayPossibleMoves(vector<moves> input)
-{
-	cout<<"\n\nList of possible Moves:"<<endl;
-	for (int i = 0; i < input.size(); ++i)
-	{
-		cout<<"possible move: "<<input[i].row<<" "<<input[i].column<<" "<<input[i].moveType<<endl;
-	}
-}
-
-
-
 int main()
 {