Fixed conflictsHEADmaster

19 files changed, 720 insertions, 721 deletions

diff --git a/include/board_state_parser.hpp b/include/board_state_parser.hpp
new file mode 100644
index 0000000..b054007
--- /dev/null
+++ b/include/board_state_parser.hpp
@@ -0,0 +1,44 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 15/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Parser that takes in the board state and outputs it into a format that the
+ * Chess Board class can read
+ *
+ */
+
+#ifndef YMH_BOARD_STATE_PARSER_HPP
+#define YMH_BOARD_STATE_PARSER_HPP
+
+#include <string>
+#include <vector>
+#include <fstream>
+
+namespace ymhChessAI {
+class BoardStateParser;
+
+typedef std::vector<std::string> boardStateData;
+
+class BoardStateParser {
+public:
+	BoardStateParser();
+	BoardStateParser(const std::string& boardFileName);
+	~BoardStateParser();
+
+	void populateBoardState();
+
+	static unsigned stringToInt(const std::string& str);
+	static std::string getStateFromLine(const std::string& str);
+protected:
+private:
+	boardStateData boardStateVector;
+	std::ifstream boardFile;
+};
+}
+
+#endif
diff --git a/include/chess_ai.hpp b/include/chess_ai.hpp
deleted file mode 100644
index 06cbd43..0000000
--- a/include/chess_ai.hpp
+++ /dev/null
@@ -1,240 +0,0 @@
-#ifndef CHESS_AI_HPP
-#define CHESS_AI_HPP
-
-#define CHESS_BOARD_SIZE 8
-
-#include <iostream>
-#include <vector>
-#include <string>
-
-namespace chess_ai {
-
-    // Describes the different types of chess pieces there are on the board
-    enum piece_type : unsigned;
-
-    // Describes the colour of the pieces
-    enum piece_colour : unsigned;
-
-    // just describes if the board is full or empty
-    enum board_state : unsigned;
-
-    // defines the errors that can happen when moving a piece
-    enum move_error : unsigned;
-
-    // The chess board that will be played on
-    class chess_board;
-
-    // Any chess piece in the game
-    class chess_piece;
-
-    // typedefs for iterators to access elements easier
-
-    typedef std::vector<std::vector<chess_ai::chess_piece> >::
-    iterator vector_iterator;
-
-    typedef std::vector<chess_ai::chess_piece>::iterator square_iterator;
-
-    enum piece_type : unsigned {
-        // A pawn can only move forward twice on the first move, otherwise only
-        // once. It only take pieces that are on the diagonals in front of it,
-        // or through en passant.
-        // They are chess_initially placed as a line in front of the other pieces.
-        pawn,
-
-        // A rook can only move vertically or horizontally and they are placed
-        // in the corners of the board.
-        rook,
-
-        // A knight can only move to 8 locations around it which are specified
-        // by moving twice horizontally or vertically in a row and once
-        // diagonally. These are placed next to the rook.
-        knight,
-
-        // A Bishop can only move diagonally and are placed next to the knight
-        bishop,
-
-        // The queen combines the bishop and the rook and is placed on either
-        // d1 or d8
-        queen,
-
-        // The king moves like the queen but only for one square and is placed
-        // on e1 or e8
-        king,
-
-        // empty square
-        empty
-    };
-
-    enum piece_colour : unsigned {
-        // Looking at the board white will be at the bottom
-        white,
-        // Black will be at the top
-        black,
-        // no colour
-        none
-    };
-
-    enum board_state : unsigned {
-        // The starting position of the board with all pieces in the right
-        // position
-        initial,
-        // While the game is going this will be the state
-        playing,
-        // When the game is over
-        finished,
-        // When the board is completely empty
-        clear
-    };
-
-    enum move_error : unsigned {
-        // when king is in check there are limited possibilities
-        move_error_KingInCheckAfterMove,
-        // when there is a friendly piece in the way
-        move_error_FriendlyPieceOnDestination,
-        // when there is an enemy piece blocking the way
-        move_error_EnemyPieceOnDestination,
-        // illegal move for chose piece
-        move_error_IllegalMove,
-
-        // when the move is successful
-        move_Success,
-        // when a move leads to a check
-        move_Check,
-        // when a move leads to a checkmate
-        move_Checkmate,
-    };
-
-    class chess_board {
-    public:
-
-        // Create an empty chess board
-        chess_board();
-
-        // Create a chess board depending on the state
-        chess_board(board_state state);
-
-        // destructor to clean up the variables
-        ~chess_board();
-
-        // prints the current board state
-        void print_board();
-
-        // returns the piece at the location
-        chess_piece at(unsigned x, unsigned y);
-
-        // Set a piece somewhere on the board replacing anything that was there
-        // previously
-        void set_piece(chess_piece piece);
-
-        // set piece directly on board
-        void set_piece(piece_type type, piece_colour colour, unsigned x,
-            unsigned y);
-
-        // removes a piece from the board at location
-        void remove_piece(chess_piece piece);
-
-        // remove piece at a specific location only
-        void remove_piece(unsigned x, unsigned y);
-
-        // move a piece according to the chess rules
-        move_error move_piece(chess_piece piece);
-
-        // move piece using only x and y (for pawns)
-        move_error move_piece(unsigned x, unsigned y);
-
-        // moves a piece to an x, y coordinate
-        move_error move_piece(chess_piece piece, unsigned x, unsigned y);
-
-        // move piece with x and y as original and final destination
-        move_error move_piece(unsigned orig_x, unsigned orig_y,
-            unsigned dest_x, unsigned dest_y);
-
-        // move piece and return a piece that has been captured
-        move_error move_piece(unsigned orig_x, unsigned orig_y,
-            unsigned dest_x, unsigned dest_y, chess_piece& taken_piece);
-
-        // iterate through the list and return the pointer to change
-        square_iterator& iterate_board(square_iterator& it, unsigned x,
-            unsigned y);
-
-
-    private:
-
-        // initialises vector
-        void init_board_vector();
-
-        // moves the pawn and tests all the cases that it should.
-        move_error move_pawn(square_iterator it, square_iterator new_it,
-            chess_piece& taken_piece);
-
-        // The size of the chess board is a constant and hence defined by a
-        // preprocessed define statement.
-        const unsigned SIZE;
-
-        // The actual board where the values of the pieces will be changed.
-        std::vector<std::vector<chess_piece> > grid;
-    };
-
-    class chess_piece {
-        friend class chess_board;
-    public:
-
-        // Initialises the chess piece to an empty square on the board
-        chess_piece() : type(empty), colour(none), x(0), y(0) {}
-
-        // Otherwise initialise the chess piece to a king or queen where the
-        // location is alreay known
-        chess_piece(piece_type type, piece_colour colour);
-
-        // Finally initialise the chess piece to a specified piece
-        chess_piece(piece_type type, piece_colour colour, unsigned x,
-            unsigned y);
-
-        // destructor to clean up the variables
-        ~chess_piece();
-
-        // overload == operator
-        friend bool operator==(const chess_piece& p1, const chess_piece& p2) {
-            if(p1.type == p2.type && p1.colour == p2.colour && p1.x == p2.x &&
-                p1.y == p2.y) {
-
-                return true;
-            }
-            return false;
-        }
-
-        // Set the type of the chess_piece
-        void set_type(piece_type type);
-
-        // set the colour of the piece
-        void set_colour(piece_colour colour);
-
-        // set the x coordinate of the piece
-        void set_x(unsigned x);
-
-        // set the y coordinate of the piece
-        void set_y(unsigned y);
-
-        // set the different values
-        void set(piece_type type, piece_colour colour, unsigned x, unsigned y);
-
-        // return a printable version of the square
-        std::string str();
-
-    private:
-
-        // Type of the chess piece, eg. bishop or queen
-        piece_type type;
-
-        // Colour of the chess piece
-        piece_colour colour;
-
-        // x location of the chess piece
-        unsigned x;
-
-        // y location of the chess piece
-        unsigned y;
-    };
-}
-
-#endif
diff --git a/include/chess_board.hpp b/include/chess_board.hpp
new file mode 100644
index 0000000..fdaf46e
--- /dev/null
+++ b/include/chess_board.hpp
@@ -0,0 +1,41 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 14/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Chess Board class that will have all the chess pieces on it
+ *
+ */
+
+#ifndef YMH_CHESS_BOARD_HPP
+#define YMH_CHESS_BOARD_HPP
+
+#include "chess_piece.hpp"
+
+#include <vector>
+#include <memory>
+
+namespace ymhChessAI {
+class ChessBoard;
+
+typedef std::vector<std::unique_ptr<ChessPiece> >::iterator boardIterator;
+typedef std::vector<std::unique_ptr<ChessPiece> > boardVector;
+typedef std::unique_ptr<ChessPiece> chessPiecePtr;
+
+class ChessBoard {
+public:
+	ChessBoard();
+
+	bool populateBoard();
+	bool printBoard();
+protected:
+private:
+	boardVector board;
+};
+}
+
+#endif
diff --git a/include/chess_constants.hpp b/include/chess_constants.hpp
new file mode 100644
index 0000000..cb50a37
--- /dev/null
+++ b/include/chess_constants.hpp
@@ -0,0 +1,28 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 23/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Chess Piece class with header for all the pieces as well that inherit
+ * from the Chess Piece class.
+ *
+ */
+
+#ifndef YMH_CHESS_CONSTANTS
+#define YMH_CHESS_CONSTANTS
+
+class ChessConstants {
+public:
+	static const unsigned BOARD_SIZE = 64;
+
+	static const unsigned WHITE_PAWN_ROW = 6;
+	static const unsigned BLACK_PAWN_ROW = 1;
+protected:
+private:
+};
+
+#endif
diff --git a/include/chess_piece.hpp b/include/chess_piece.hpp
new file mode 100644
index 0000000..1838af8
--- /dev/null
+++ b/include/chess_piece.hpp
@@ -0,0 +1,155 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 13/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Chess Piece class with header for all the pieces as well that inherit
+ * from the Chess Piece class.
+ *
+ */
+
+#ifndef YMH_CHESS_PIECE_HPP
+#define YMH_CHESS_PIECE_HPP
+
+
+// defining seperate namespace so that I don't have to worry with duplicate
+// names
+
+namespace ymhChessAI {
+enum class Colour;
+class ChessPiece;
+class King;
+class Queen;
+class Rook;
+class Bishop;
+class Knight;
+class Pawn;
+class EmptyPiece;
+
+typedef unsigned int boardPosition;
+
+// Colour enum class so that we can have the colours in the Chess Piece and not
+// using normal enums because of undefined errors
+
+enum class Colour {
+	White,
+	Black,
+	None
+};
+
+
+// Base Chess Piece class that is inherited by all other chess pieces
+
+class ChessPiece {
+public:
+	// constructor sets the initial position of the chess piece to 0, 0
+	ChessPiece();
+	// initialise piece at a specific location on the board to save code
+	ChessPiece(const int& x, const int& y, const Colour& colour);
+
+	// pure virtual function to move a piece as it depends completely on the
+	// implementation of the piece
+	virtual void move(const int& x, const int& y) = 0;
+protected:
+	// current location of the piece which is protected as it can still be
+	// inherited by the piece classes
+	boardPosition m_x, m_y;
+
+	// defines what colour the piece is
+	Colour m_colour;
+};
+
+
+// King class
+
+class King : public ChessPiece {
+public:
+	King();
+	King(const int& x, const int& y, const Colour& colour);
+
+	virtual void move(const int& x, const int& y);
+protected:
+private:
+};
+
+
+// Queen class
+
+class Queen : public ChessPiece {
+public:
+	Queen();
+	Queen(const int& x, const int& y, const Colour& colour);
+
+	virtual void move(const int& x, const int& y);
+protected:
+private:
+};
+
+
+// Rook class
+
+class Rook : public ChessPiece {
+public:
+	Rook();
+	Rook(const int& x, const int& y, const Colour& colour);
+
+	virtual void move(const int& x, const int& y);
+protected:
+private:
+};
+
+
+// Bishop class
+
+class Bishop : public ChessPiece {
+public:
+	Bishop();
+	Bishop(const int& x, const int& y, const Colour& colour);
+
+	virtual void move(const int& x, const int& y);
+protected:
+private:
+};
+
+
+// Knight class
+
+class Knight : public ChessPiece {
+public:
+	Knight();
+	Knight(const int& x, const int& y, const Colour& colour);
+
+	virtual void move(const int& x, const int& y);
+protected:
+private:
+};
+
+
+// Pawn class
+
+class Pawn : public ChessPiece {
+public:
+	Pawn();
+	Pawn(const int& x, const int& y, const Colour& colour);
+
+	virtual void move(const int& x, const int& y);
+protected:
+private:
+};
+
+class EmptyPiece : public ChessPiece {
+public:
+	EmptyPiece();
+	EmptyPiece(const int& x, const int& y);
+
+	virtual void move(const int& x, const int& y);
+protected:
+private:
+};
+}
+
+#endif
diff --git a/include/chess_tester.hpp b/include/chess_tester.hpp
index d2994ad..f121ec8 100644
--- a/include/chess_tester.hpp
+++ b/include/chess_tester.hpp
@@ -11,79 +11,78 @@
 #include <algorithm>
 #include <iostream>
 
+namespace ymhChessAI {
 struct tested_pieces {
-    std::string piece_name;
-    int num_passed;
-    int num_failed;
-
-    friend bool operator==(const tested_pieces& tp1, const tested_pieces& tp2) {
-        if(tp1.piece_name == tp2.piece_name) {
-            return true;
-        }
-        return false;
-    }
-
-    friend bool operator<(const tested_pieces& tp1, const tested_pieces& tp2) {
-        if(tp1.piece_name < tp2.piece_name) {
-            return true;
-        }
-        return false;
-    }
+	std::string piece_name;
+	int			num_passed;
+	int			num_failed;
+
+	friend bool operator==(const tested_pieces& tp1, const tested_pieces& tp2) {
+		if(tp1.piece_name == tp2.piece_name)
+			return true;
+		return false;
+	}
+
+	friend bool operator<(const tested_pieces& tp1, const tested_pieces& tp2) {
+		if(tp1.piece_name < tp2.piece_name)
+			return true;
+		return false;
+	}
 };
 
 class chess_tester {
-
 public:
 
-    // sets all the initial values for the tester
-    chess_tester();
+	// sets all the initial values for the tester
+	chess_tester();
 
-    // begins the test suite so that this class can record the results and
-    // analyse them
-    void chess_begin_test_suite();
+	// begins the test suite so that this class can record the results and
+	// analyse them
+	void chess_begin_test_suite();
 
-    // begins the test
-    int chess_begin_test(std::string test_name);
+	// begins the test
+	int chess_begin_test(std::string test_name);
 
-    // records the result of the test
-    void chess_end_test(int test_id, bool passed);
+	// records the result of the test
+	void chess_end_test(int test_id, bool passed);
 
-    // analyses the results and prints them out
-    void chess_end_test_suite();
+	// analyses the results and prints them out
+	void chess_end_test_suite();
 
-    // see if the test is acceptable
-    bool is_in_arr(const std::string& test_piece) const;
+	// see if the test is acceptable
+	bool is_in_arr(const std::string& test_piece) const;
 
-    // see if test is in vector
-    bool is_in_vec(const tested_pieces& piece) const;
+	// see if test is in vector
+	bool is_in_vec(const tested_pieces& piece) const;
 
 private:
 
-    // checks if the test suite is running
-    bool ts_begin;
+	// checks if the test suite is running
+	bool ts_begin;
 
-    // list of pieces to test
-    const std::string chess_test_pieces[CHESS_TEST_SIZE] = {
-        "<INTERNAL>",
-        "PAWN",
-        "ROOK",
-        "KNIGHT",
-        "BISHOP",
-        "QUEEN",
-        "KING"
-    };
+	// list of pieces to test
+	const std::string chess_test_pieces[CHESS_TEST_SIZE] = {
+		"<INTERNAL>",
+		"PAWN",
+		"ROOK",
+		"KNIGHT",
+		"BISHOP",
+		"QUEEN",
+		"KING"
+	};
 
-    // vector that contains the tested pieces
-    std::vector<tested_pieces> test_piece;
+	// vector that contains the tested pieces
+	std::vector<tested_pieces> test_piece;
 
-    // the test_id of the current instruction
-    int test_id;
+	// the test_id of the current instruction
+	int test_id;
 
-    // the test id of the test that has been started
-    int test_id_test;
+	// the test id of the test that has been started
+	int test_id_test;
 
-    // the current test that is being tested
-    std::string current_test;
+	// the current test that is being tested
+	std::string current_test;
 };
+}
 
 #endif
diff --git a/res/default.board b/res/default.board
new file mode 100644
index 0000000..d4ea5b0
--- /dev/null
+++ b/res/default.board
@@ -0,0 +1,4 @@
+0 0br 1bn 2bb 3bq 4bk 5bb 6bn 7br
+1 0bp 1bp 2bp 3bp 4bp 5bp 6bp 7bp
+6 0wp 1wp 2wp 3wp 4wp 5wp 6wp 7wp
+7 0wr 1wn 2wb 3wq 4wk 5wb 6wn 7wr
diff --git a/src/bishop.cpp b/src/bishop.cpp
new file mode 100644
index 0000000..849db19
--- /dev/null
+++ b/src/bishop.cpp
@@ -0,0 +1,26 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 13/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Bishop class implementation
+ *
+ */
+
+#include "chess_piece.hpp"
+
+using namespace ymhChessAI;
+
+
+Bishop::Bishop() : ChessPiece() {
+}
+
+Bishop::Bishop(const int& x, const int& y, const Colour& colour) : ChessPiece(x, y, colour) {
+}
+
+void Bishop::move(const int& x, const int& y) {
+}
diff --git a/src/board_state_parser.cpp b/src/board_state_parser.cpp
new file mode 100644
index 0000000..288a491
--- /dev/null
+++ b/src/board_state_parser.cpp
@@ -0,0 +1,61 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 15/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Implementation of the Board state class
+ *
+ */
+
+#include "board_state_parser.hpp"
+#include "chess_constats.hpp"
+
+using namespace ymhChessAI;
+
+
+BoardStateParser::BoardStateParser() : boardFile("res/default.board", std::ifstream::in) {
+}
+
+BoardStateParser::BoardStateParser(const std::string& boardFileName) : boardFile(boardFileName.c_str()) {
+}
+
+BoardStateParser::~BoardStateParser() {
+	boardFile.close();
+}
+
+void BoardStateParser::populateBoardState() {
+	std::string currentLine;
+
+	boardStateVector.reserve(ChessConstants::BOARD_SIZE);
+
+	if(!boardFile.is_open())
+		throw "Error: Can't open file";
+
+	while(getline(boardFile, currentLine))
+		boardStateVector[stringToInt(currentLine)] = getStateFromLine(currentLine);
+}
+
+unsigned BoardStateParser::stringToInt(const std::string& str) {
+	unsigned finalInt = 0;
+	bool foundWhiteSpace = false;
+
+	for(char character : str)
+		if(character == ' ')
+			foundWhiteSpace = true;
+		else if(!foundWhiteSpace && character >= '0' && character <= '9')
+			finalInt = finalInt * 10 + character - '0';
+
+	return finalInt;
+}
+
+std::string BoardStateParser::getStateFromLine(const std::string& str) {
+	std::string state;
+
+	state = str.substr(2, str.length() - 2);
+
+	return state;
+}
diff --git a/src/chess_board.cpp b/src/chess_board.cpp
index de21015..e0967ad 100644
--- a/src/chess_board.cpp
+++ b/src/chess_board.cpp
@@ -1,244 +1,43 @@
-#include "chess_ai.hpp"
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 14/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Chess Board class implementation
+ *
+ */
 
-chess_ai::chess_board::chess_board() : SIZE(CHESS_BOARD_SIZE) {
-    init_board_vector();
-}
-
-chess_ai::chess_board::chess_board(board_state state) : SIZE(CHESS_BOARD_SIZE) {
-    unsigned vec_index, sqr_index;
-
-    init_board_vector();
-
-    if(state == initial) {
-
-        for(vector_iterator it_vec = grid.begin(); it_vec != grid.end();
-            ++it_vec) {
-
-            for(square_iterator it_sqr = (*it_vec).begin();
-                it_sqr != (*it_vec).end(); ++it_sqr) {
-                chess_piece piece;
-
-                piece_colour colour;
+#include "chess_board.hpp"
+#include "chess_constants.hpp"
 
-                if(vec_index < 3) {
-                    colour = black;
-                } else {
-                    colour = white;
-                }
+#include <iostream>
 
-                vec_index = it_vec - grid.begin();
-                sqr_index = it_sqr - (*it_vec).begin();
+using namespace ymhChessAI;
 
-                if(vec_index == 1 || vec_index == 6) {
-                    piece.set_type(pawn);
-                } else if(vec_index == 0 || vec_index == 7) {
 
-                    if(sqr_index == 0 || sqr_index == 7)
-                        piece.set_type(rook);
-                    else if(sqr_index == 1 || sqr_index == 6)
-                        piece.set_type(knight);
-                    else if(sqr_index == 2 || sqr_index == 5)
-                        piece.set_type(bishop);
-                    else if(sqr_index == 3)
-                        piece.set_type(queen);
-                    else if(sqr_index == 4)
-                        piece.set_type(king);
-                }
-
-                piece.set_colour(colour);
-                piece.set_x(sqr_index);
-                piece.set_y(vec_index);
-
-                *it_sqr = piece;
-            }
-        }
-    } else {
-        for(auto& row : grid) {
-            for(auto& square : row) {
-                chess_piece piece;
-                square = piece;
-            }
-        }
-    }
-}
-
-chess_ai::chess_board::~chess_board() {}
-
-void chess_ai::chess_board::init_board_vector() {
-    for(unsigned i = 0; i < SIZE; ++i) {
-        std::vector<chess_ai::chess_piece> tmp_vec;
-        for(unsigned j = 0; j < SIZE; ++j) {
-            chess_piece piece;
-            tmp_vec.push_back(piece);
-        }
-        grid.push_back(tmp_vec);
-    }
+ChessBoard::ChessBoard() {
+	for(unsigned i = 0; i < ChessConstants::BOARD_SIZE; ++i)
+		board.emplace_back(new EmptyPiece);
 }
 
-void chess_ai::chess_board::print_board() {
-    std::cout << "  |";
-    for(unsigned i = 0; i < SIZE; ++i) {
-        std::cout << "---|";
-    }
-    std::cout << std::endl << "8 |";
-
-    for(unsigned y = 0; y < SIZE; ++y) {
-        for(unsigned x = 0; x < SIZE; ++x) {
-            std::cout << " " << grid[y][x].str() << " |";
-        }
-
-        std::cout << std::endl << "  |";
-
-
-        if(y == SIZE-1) {
-            std::cout << "---+";
-            for(unsigned i = 0; i < SIZE-2; ++i) {
-                std::cout << "---+";
-            }
-            std::cout << "---|" << std::endl;
-        } else {
-            for(unsigned i = 0; i < SIZE-1; ++i) {
-                std::cout << "---+";
-            }
-            std::cout << "---|" << std::endl;
-            std::cout << 7-y << " |";
-        }
-    }
-    std::cout << "    a   b   c   d   e   f   g   h" << std::endl;
-}
-
-chess_ai::chess_piece chess_ai::chess_board::at(unsigned x,
-    unsigned y) {
-
-    square_iterator it_sqr;
-    chess_piece tmp_piece;
-
-    tmp_piece = *iterate_board(it_sqr, x, y);
-    return tmp_piece;
-}
-
-void chess_ai::chess_board::set_piece(chess_piece piece) {
-    square_iterator it_sqr;
-    *iterate_board(it_sqr, piece.x, piece.y) = piece;
-}
-
-void chess_ai::chess_board::set_piece(piece_type type, piece_colour colour,
-    unsigned x, unsigned y) {
-
-    chess_piece piece(type, colour, x, y);
-    set_piece(piece);
-}
-
-void chess_ai::chess_board::remove_piece(chess_piece piece) {
-    remove_piece(piece.x, piece.y);
-}
-
-void chess_ai::chess_board::remove_piece(unsigned x, unsigned y) {
-    square_iterator it_sqr;
-    *iterate_board(it_sqr, x, y) = chess_piece();
-}
-
-chess_ai::move_error chess_ai::chess_board::move_piece(chess_piece piece) {
-    return move_piece(piece.x, piece.y);
-}
-
-chess_ai::move_error chess_ai::chess_board::move_piece(unsigned x, unsigned y) {
-    square_iterator it;
-    iterate_board(it, x, y);
-
-    if(it->y < 7 && it->y > 0) {
-        if(it->colour == white)
-            return move_piece(x, y, x, y-1);
-        return move_piece(x, y, x, y+1);
-    }
-    return move_error_IllegalMove;
-}
-
-chess_ai::move_error chess_ai::chess_board::move_piece
-(chess_ai::chess_piece piece, unsigned x, unsigned y) {
-
-    return move_piece(piece.x, piece.y, x, y);
-}
-
-chess_ai::move_error chess_ai::chess_board::move_piece
-(unsigned orig_x, unsigned orig_y, unsigned dest_x, unsigned dest_y) {
-
-    chess_piece taken;
-    return move_piece(orig_x, orig_y, dest_x, dest_y, taken);
-}
-
-chess_ai::move_error chess_ai::chess_board::move_piece
-(unsigned orig_x, unsigned orig_y, unsigned dest_x, unsigned dest_y,
- chess_piece& taken_piece) {
-
-    square_iterator it;
-    square_iterator new_it;
-
-    iterate_board(it, orig_x, orig_y);
-    iterate_board(new_it, dest_x, dest_y);
-
-    switch(it->type) {
-    case pawn:
-        return move_pawn(it, new_it, taken_piece);
-    case rook:
-    case knight:
-    case bishop:
-    case queen:
-    case king:
-    default:
-        return move_error_IllegalMove;
-    }
-}
-
-chess_ai::square_iterator& chess_ai::chess_board::iterate_board
-(square_iterator& it, unsigned x, unsigned y) {
-
-    unsigned vec_index, sqr_index;
-    for(vector_iterator it_vec = grid.begin(); it_vec != grid.end(); ++it_vec) {
-        for(square_iterator it_sqr = (*it_vec).begin();
-            it_sqr != (*it_vec).end(); ++it_sqr) {
-            vec_index = it_vec - grid.begin();
-            sqr_index = it_sqr - (*it_vec).begin();
-
-            if(vec_index == y && sqr_index == x) {
-                it = it_sqr;
-                return it;
-            }
-        }
-    }
-    return it;
+bool ChessBoard::populateBoard() {
+	for(auto && piece : board)
+		piece = chessPiecePtr(new Knight);
+	return true;
 }
 
-chess_ai::move_error chess_ai::chess_board::move_pawn
-(square_iterator it, square_iterator new_it, chess_piece& taken_piece) {
+bool ChessBoard::printBoard() {
+	int i = 0;
 
-    chess_piece piece(it->type, it->colour, new_it->x, new_it->y);
+	for(auto && piece : board) {
+		std::cout << i << " ";
+		piece->move(1, 2);
+		++i;
+	}
 
-    if((new_it->y - it->y == 2 && it->y == 1) ||
-       ((int)new_it->y - (int)it->y == -2 && it->y == 6) ||
-       (new_it->y - it->y == 1 && piece.colour == black && it->y < 7) ||
-       ((int)new_it->y - (int)it->y == -1 && piece.colour == white &&
-        it->y > 0)) {
-        if(new_it->x == it->x) {
-            if(new_it->type == empty) {
-                remove_piece(it->x, it->y);
-                set_piece(piece);
-                return move_Success;
-            } else if(new_it->colour == it->colour) {
-                return move_error_FriendlyPieceOnDestination;
-            }
-            return move_error_EnemyPieceOnDestination;
-        } else if(new_it->x - it->x == 1 || (int)new_it->x - (int)it->x == -1) {
-            if(new_it->colour != it->colour && new_it->colour != none) {
-                taken_piece.set(new_it->type, new_it->colour, new_it->x,
-                                new_it->y);
-                remove_piece(it->x, it->y);
-                set_piece(piece);
-                return move_Success;
-            } else if(new_it->colour == it->colour) {
-                return move_error_FriendlyPieceOnDestination;
-            }
-        }
-    }
-    return move_error_IllegalMove;
+	return true;
 }
diff --git a/src/chess_piece.cpp b/src/chess_piece.cpp
index f73d4c1..33ce34f 100644
--- a/src/chess_piece.cpp
+++ b/src/chess_piece.cpp
@@ -1,63 +1,32 @@
-#include "chess_ai.hpp"
-
-chess_ai::chess_piece::chess_piece(piece_type type, piece_colour colour) :
-    type(type), colour(colour) {
-
-    if(colour == black) {
-        y = 0;
-    } else {
-        y = 7;
-    }
-
-    if(type == king) {
-        x = 4;
-    } else {
-        x = 3;
-    }
-}
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 13/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Chess Piece class implementation
+ *
+ */
 
-chess_ai::chess_piece::chess_piece(piece_type type, piece_colour colour,
-                                   unsigned x, unsigned y) :
-    type(type), colour(colour), x(x), y(y) {}
+#include "chess_piece.hpp"
 
-chess_ai::chess_piece::~chess_piece() {}
+using namespace ymhChessAI;
 
-void chess_ai::chess_piece::set_type(piece_type type) {
-    this->type = type;
-}
 
-void chess_ai::chess_piece::set_colour(piece_colour colour) {
-    this->colour = colour;
+ChessPiece::ChessPiece() : m_x(0), m_y(0), m_colour(Colour::White) {
 }
 
-void chess_ai::chess_piece::set_x(unsigned x) {
-    this->x = x;
+ChessPiece::ChessPiece(const int& x, const int& y, const Colour& colour) : m_x(x), m_y(y), m_colour(colour) {
 }
 
-void chess_ai::chess_piece::set_y(unsigned y) {
-    this->y = y;
+EmptyPiece::EmptyPiece() : ChessPiece() {
 }
 
-void chess_ai::chess_piece::set(piece_type type, piece_colour colour,
-                                unsigned x, unsigned y) {
-    set_type(type);
-    set_colour(colour);
-    set_x(x);
-    set_y(y);
+EmptyPiece::EmptyPiece(const int& x, const int& y) : ChessPiece(x, y, Colour::None) {
 }
 
-std::string chess_ai::chess_piece::str() {
-    if(type == empty)
-        return " ";
-    else if(type == pawn)
-        return "p";
-    else if(type == rook)
-        return "r";
-    else if(type == knight)
-        return "n";
-    else if(type == bishop)
-        return "b";
-    else if(type == queen)
-        return "q";
-    return "k";
+void EmptyPiece::move(const int& x, const int& y) {
 }
diff --git a/src/chess_tester.cpp b/src/chess_tester.cpp
index 6f3745c..a8ec0b5 100644
--- a/src/chess_tester.cpp
+++ b/src/chess_tester.cpp
@@ -1,125 +1,119 @@
 #include "chess_tester.hpp"
 
-chess_tester::chess_tester() : ts_begin(false) {
-    srand(time(NULL));
+using namespace ymhChessAI;
 
-    test_id = rand() % 0xffffffff;
-    test_id_test = test_id;
+chess_tester::chess_tester() : ts_begin(false) {
+	srand(time(NULL));
 
+	test_id = rand() % 0xffffffff;
+	test_id_test = test_id;
 }
 
 void chess_tester::chess_begin_test_suite() {
-    if(ts_begin) {
-        fprintf(stderr, "Error: already started test suite\n");
-        exit(1);
-    }
+	if(ts_begin)
+		fprintf(stderr, "Error: already started test suite\n");
+	exit(1);
 
-    ts_begin = true;
+	ts_begin = true;
 }
 
 int chess_tester::chess_begin_test(std::string test_name) {
-    if(!ts_begin) {
-        fprintf(stderr, "Error: the test suite hasn't been started yet\n");
-        exit(1);
-    }
+	if(!ts_begin) {
+		fprintf(stderr, "Error: the test suite hasn't been started yet\n");
+		exit(1);
+	}
 
-    if(!is_in_arr(test_name)) {
-        fprintf(stderr, "Error: the test name does not exist\n");
-        exit(1);
-    }
+	if(!is_in_arr(test_name)) {
+		fprintf(stderr, "Error: the test name does not exist\n");
+		exit(1);
+	}
 
-    current_test = test_name;
+	current_test = test_name;
 
-    test_id = rand() % 0xffffffff;
-    test_id_test = test_id;
+	test_id = rand() % 0xffffffff;
+	test_id_test = test_id;
 
-    return test_id;
+	return test_id;
 }
 
 void chess_tester::chess_end_test(int test_id, bool passed) {
-    if(test_id != test_id_test) {
-        fprintf(stderr , "Error: the test from before has not been ended\n");
-        exit(1);
-    }
-
-    tested_pieces tmp;
-    tmp.piece_name = current_test;
-
-    if(passed) {
-        tmp.num_passed = 1;
-        tmp.num_failed = 0;
-    } else {
-        tmp.num_passed = 0;
-        tmp.num_failed = 1;
-    }
-
-    if(test_piece.empty() || !is_in_vec(tmp)) {
-        test_piece.push_back(tmp);
-    } else {
-        for(unsigned i = 0; i < test_piece.size(); ++i) {
-            if(test_piece[i] == tmp) {
-                if(passed) {
-                    test_piece[i].num_passed++;
-                } else {
-                    test_piece[i].num_failed++;
-                }
-            }
-        }
-    }
+	if(test_id != test_id_test) {
+		fprintf(stderr, "Error: the test from before has not been ended\n");
+		exit(1);
+	}
+
+	tested_pieces tmp;
+	tmp.piece_name = current_test;
+
+	if(passed) {
+		tmp.num_passed = 1;
+		tmp.num_failed = 0;
+	} else {
+		tmp.num_passed = 0;
+		tmp.num_failed = 1;
+	}
+
+	if(test_piece.empty() || !is_in_vec(tmp)) {
+		test_piece.push_back(tmp);
+	} else {
+		for(unsigned i = 0; i < test_piece.size(); ++i) {
+			if(test_piece[i] == tmp) {
+				if(passed)
+					test_piece[i].num_passed++;
+				else
+					test_piece[i].num_failed++;
+			}
+		}
+	}
 }
 
 void chess_tester::chess_end_test_suite() {
-    std::sort(test_piece.begin(), test_piece.end());
-
-    int pieces_passed = 0;
-    int pieces_partial = 0;
-    int pieces_fail = 0;
-
-    fprintf(stderr, "+-%10s-+-%5s-+-%6s-+-%8s-+\n", "----------", "-----",
-            "------", "--------");
-    fprintf(stderr, "| %10s | %5s | %6s | %8s |\n", "Piece  ", "Total", "Passed",
-            "Passed %");
-    fprintf(stderr, "+-%10s-+-%5s-+-%6s-+-%8s-+\n", "----------", "-----",
-            "------", "--------");
-    for(unsigned i = 0; i < test_piece.size(); ++i) {
-        fprintf(stderr, "| %10s | %5d | %6d | %7.3f%% |\n",
-                test_piece[i].piece_name.c_str(), test_piece[i].num_passed +
-                test_piece[i].num_failed, test_piece[i].num_passed,
-                100.0*(double)test_piece[i].num_passed /
-                (double)(test_piece[i].num_passed + test_piece[i].num_failed));
-
-        if(test_piece[i].num_passed == 0) {
-            pieces_fail++;
-        } else if(test_piece[i].num_failed == 0) {
-            pieces_passed++;
-        } else {
-            pieces_partial++;
-        }
-    }
-    fprintf(stderr, "+-%10s-+-%5s-+-%6s-+-%8s-+\n", "----------", "-----",
-            "------", "--------");
-
-    fprintf(stderr, "\nTotal pieces tested: %lu\n", test_piece.size());
-    fprintf(stderr, "Passed: %d\n", pieces_passed);
-    fprintf(stderr, "Partially working: %d\n", pieces_partial);
-    fprintf(stderr, "Failed: %d\n", pieces_fail);
+	std::sort(test_piece.begin(), test_piece.end());
+
+	int pieces_passed = 0;
+	int pieces_partial = 0;
+	int pieces_fail = 0;
+
+	fprintf(stderr, "+-%10s-+-%5s-+-%6s-+-%8s-+\n", "----------", "-----",
+			"------", "--------");
+	fprintf(stderr, "| %10s | %5s | %6s | %8s |\n", "Piece  ", "Total", "Passed",
+			"Passed %");
+	fprintf(stderr, "+-%10s-+-%5s-+-%6s-+-%8s-+\n", "----------", "-----",
+			"------", "--------");
+	for(unsigned i = 0; i < test_piece.size(); ++i) {
+		fprintf(stderr, "| %10s | %5d | %6d | %7.3f%% |\n",
+				test_piece[i].piece_name.c_str(), test_piece[i].num_passed +
+				test_piece[i].num_failed, test_piece[i].num_passed,
+				100.0 * (double)test_piece[i].num_passed /
+				(double)(test_piece[i].num_passed + test_piece[i].num_failed));
+
+		if(test_piece[i].num_passed == 0)
+			pieces_fail++;
+		else if(test_piece[i].num_failed == 0)
+			pieces_passed++;
+		else
+			pieces_partial++;
+	}
+	fprintf(stderr, "+-%10s-+-%5s-+-%6s-+-%8s-+\n", "----------", "-----",
+			"------", "--------");
+
+	fprintf(stderr, "\nTotal pieces tested: %lu\n", test_piece.size());
+	fprintf(stderr, "Passed: %d\n", pieces_passed);
+	fprintf(stderr, "Partially working: %d\n", pieces_partial);
+	fprintf(stderr, "Failed: %d\n", pieces_fail);
 }
 
 bool chess_tester::is_in_arr(const std::string& test_piece) const {
-    for(unsigned i = 0; i < CHESS_TEST_SIZE; ++i) {
-        if(chess_test_pieces[i] == test_piece) {
-            return true;
-        }
-    }
+	for(unsigned i = 0; i < CHESS_TEST_SIZE; ++i)
+		if(chess_test_pieces[i] == test_piece)
+			return true;
 
-    return false;
+	return false;
 }
 
 bool chess_tester::is_in_vec(const tested_pieces& piece) const {
-    for(unsigned i = 0; i < test_piece.size(); ++i) {
-        if(test_piece[i] == piece) {
-            return true;
-        }
-    }
-    return false;
+	for(unsigned i = 0; i < test_piece.size(); ++i)
+		if(test_piece[i] == piece)
+			return true;
+	return false;
 }
diff --git a/src/king.cpp b/src/king.cpp
new file mode 100644
index 0000000..1d297d3
--- /dev/null
+++ b/src/king.cpp
@@ -0,0 +1,28 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 13/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * King class implementation
+ *
+ */
+
+#include "chess_piece.hpp"
+#include <iostream>
+
+using namespace ymhChessAI;
+
+
+King::King() : ChessPiece() {
+}
+
+King::King(const int& x, const int& y, const Colour& colour) : ChessPiece(x, y, colour) {
+}
+
+void King::move(const int& x, const int& y) {
+	std::cout << "This is the king" << std::endl;
+}
diff --git a/src/knight.cpp b/src/knight.cpp
new file mode 100644
index 0000000..25e5ab9
--- /dev/null
+++ b/src/knight.cpp
@@ -0,0 +1,28 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 13/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Knight class implementation
+ *
+ */
+
+#include "chess_piece.hpp"
+#include <iostream>
+
+using namespace ymhChessAI;
+
+
+Knight::Knight() : ChessPiece() {
+}
+
+Knight::Knight(const int& x, const int& y, const Colour& colour) : ChessPiece(x, y, colour) {
+}
+
+void Knight::move(const int& x, const int& y) {
+	std::cout << "This is a Knight" << std::endl;
+}
diff --git a/src/main.cpp.bck b/src/main.cpp.bck
deleted file mode 100644
index 2fd9be2..0000000
--- a/src/main.cpp.bck
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-
-  description: This is the main file for the chess_ai
-
-  author: Yann Herklotz <ymherklotz@gmail.com>
-  date created: DD-MM-YYYY
-
- */
-
-#include "chess_ai.hpp"
-#include "chess_tester.hpp"
-
-#include <iostream>
-
-using namespace std;
-using namespace chess_ai;
-
-int main(int argc, char** argv) {
-    (void)argc;
-    (void)argv;
-
-    return 0;
-}
diff --git a/src/pawn.cpp b/src/pawn.cpp
new file mode 100644
index 0000000..5c5f1f6
--- /dev/null
+++ b/src/pawn.cpp
@@ -0,0 +1,44 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 13/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Pawn class implementation, checking if there is a piece in the way of the
+ * one that is currently moving will be the chess boards concern
+ *
+ * Update: Checking if a piece is in the way will be the concern of this class
+ * because the move function has to perform the whole move.
+ *
+ */
+
+#include "chess_piece.hpp"
+#include "chess_constants.hpp"
+
+#include <cmath>
+
+using namespace ymhChessAI;
+
+
+Pawn::Pawn() : ChessPiece() {
+}
+
+Pawn::Pawn(const int& x, const int& y, const Colour& colour) : ChessPiece(x, y, colour) {
+}
+
+void Pawn::move(const int& x, const int& y) {
+	int move_length = y - (int)m_y;
+
+	// First check what colour the pawn is
+	if(m_colour == Colour::White) {
+		// if this condition is met the pawn can move
+		if(move_length == -2 && m_y == ChessConstants::WHITE_PAWN_ROW) {
+			// we now have to check if there is a piece in between the pawn and
+			// it's desination
+		}
+	} else {
+	}
+}
diff --git a/src/queen.cpp b/src/queen.cpp
new file mode 100644
index 0000000..897237a
--- /dev/null
+++ b/src/queen.cpp
@@ -0,0 +1,26 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 13/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Queen class implementation
+ *
+ */
+
+#include "chess_piece.hpp"
+
+using namespace ymhChessAI;
+
+
+Queen::Queen() : ChessPiece() {
+}
+
+Queen::Queen(const int& x, const int& y, const Colour& colour) : ChessPiece(x, y, colour) {
+}
+
+void Queen::move(const int& x, const int& y) {
+}
diff --git a/src/rook.cpp b/src/rook.cpp
new file mode 100644
index 0000000..cd72029
--- /dev/null
+++ b/src/rook.cpp
@@ -0,0 +1,26 @@
+/*
+ *
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 13/01/17
+ *
+ * -----------------------------------------------------------------------------
+ *
+ * Rook class implementation
+ *
+ */
+
+#include "chess_piece.hpp"
+
+using namespace ymhChessAI;
+
+
+Rook::Rook() : ChessPiece() {
+}
+
+Rook::Rook(const int& x, const int& y, const Colour& colour) : ChessPiece(x, y, colour) {
+}
+
+void Rook::move(const int& x, const int& y) {
+}
diff --git a/src/test_bench.cpp b/src/test_bench.cpp
index 8c79568..b1fe4ba 100644
--- a/src/test_bench.cpp
+++ b/src/test_bench.cpp
@@ -1,45 +1,35 @@
 /*
  *
- * description: This is the test_bench file for the chess_ai
+ * author: Yann Herklotz
+ * username: ymherklotz
+ * email: ymherklotz@gmail.com
+ * date created: 13/01/17
  *
- * author: Yann Herklotz <ymherklotz@gmail.com>
- * date created: DD-MM-YYYY
+ * -----------------------------------------------------------------------------
+ *
+ * Main file that tests the chess ai
  *
  */
 
-#include "chess_ai.hpp"
 #include "chess_tester.hpp"
+#include "chess_piece.hpp"
+#include "chess_board.hpp"
+#include "board_state_parser.hpp"
 
 #include <iostream>
 
 using namespace std;
-using namespace chess_ai;
+using namespace ymhChessAI;
 
 int main(int argc, char **argv) {
-	int test_id;
-	bool passed;
-
-	chess_tester test_bench;
-
-	chess_board empty_board(clear);
-	chess_board initial_board(initial);
-
-	test_bench.chess_begin_test_suite();
+	cout << "Program name: " << argv[0] << endl;
+	cout << "Arguments: " << argc - 1 << endl;
 
-	test_id = test_bench.chess_begin_test("PAWN");
-	chess_piece piece(pawn, white, 1, 6);
-	empty_board.set_piece(piece);
-	empty_board.print_board();
-	cout << empty_board.move_piece(1, 6, 1, 4) << endl;
-	piece.set(pawn, white, 1, 4);
-	if(empty_board.at(1, 4) == piece)
-		passed = true;
-	else
-		passed = false;
-	empty_board.print_board();
-	test_bench.chess_end_test(test_id, passed);
+	ChessBoard cb;
+	cb.populateBoard();
+	cb.printBoard();
 
-	test_bench.chess_end_test_suite();
+	cout << endl << "====== Executed Successfully ======" << endl;
 
 	return 0;
 }