Bitwise functions/tests now compile.

src/all_moves_bitwise_functions.cpp

@@ -48,12 +48,10 @@ void _add_if_not_blocked(int pos, std::unordered_set<int> *pns, std::array<Piece
 }
 // This function is for non-ray types only, as it ignores the 'ray rules', and just jumps over stuff (e.g. knight), or only moves one space generally (e.g. king)
 void _add_if_not_blocked(int pos, std::unordered_set<int> *pns, std::array<PieceType, 120> *board, Color color_of_piece, Color color_of_opposite){
-	if (is_valid_position(pos)){
-		if (_xy_is_color(pos, board, color_of_piece)){
-			return;
-		} else {
-			pns->insert(pos);
-		}
+	if (_xy_is_color(pos, board, color_of_piece)){
+		return;
+	} else {
+		pns->insert(pos);
 	}
 }
 
@@ -134,7 +132,7 @@ void _get_all_moves_bishop(int pos, std::unordered_set<int> *pns, std::array<Pie
 void _get_all_moves_knight(int pos, std::unordered_set<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc){
 	for (int kn_off : KNIGHT_PIECE_OFFSETS){
 		bool* not_blocked = new bool(true);
-		_add_if_not_blocked(pos+kn_off, pns, board, pc, rc, not_blocked);
+		_add_if_not_blocked(pos+kn_off, pns, board, pc, rc);
 	}
 	/*
 	for (int xo=1;xo<=2;xo++){
@@ -150,7 +148,7 @@ void _get_all_moves_knight(int pos, std::unordered_set<int> *pns, std::array<Pie
 void _get_all_moves_king(int pos, std::unordered_set<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc){
 	for (int kn_off : KING_PIECE_OFFSETS){
 		bool* not_blocked = new bool(true);
-		_add_if_not_blocked(pos+kn_off, pns, board, pc, rc, not_blocked);
+		_add_if_not_blocked(pos+kn_off, pns, board, pc, rc);
 	}
 
 

src/bitwise.h

@@ -2,11 +2,12 @@
 #define BITWISE_H
 
 #include <unordered_set>
+#include "bitwise_constants.h"
 
 // Using macros for ease of use, can also use functons, but I don't see the point.
 
 /*
- * From (Position): 7 bits (2^6 == 64) possibilities
+ * From (Position): 7 bits (2^7 == 128) possibilities
  * To (Position): same as above
  * Captured piece, if any: 4 bits (16) possibilities
  * Promoted to, if any: 4 bits (16) possibilities
@@ -14,13 +15,13 @@
  * pawn starting move flag: 1 bit
  * castle move flag: 1 bit
  *
- *	0000 0000 0000 0000 0011 1111 -> From square position (& 0x3F)
- *	0000 0000 0000 0111 1100 0000 -> To square position (>> 6 & 0x3F)
- *	0000 0000 1111 0000 0000 0000 -> captured piece, if any (>> 12 & 0xF)
- *	0000 1111 0000 0000 0000 0000 -> if prmoted, what to? (>> 16 & 0xF)
- *	0001 0000 0000 0000 0000 0000 -> en passant (& 0x100000)
- *	0010 0000 0000 0000 0000 0000 -> pawn starting move (& 0x200000)
- *	0100 0000 0000 0000 0000 0000 -> castle move (& 0x400000)
+ *	0000 0000 0000 0000 0000 0111 1111 -> From square position (& 0x7F)
+ *	0000 0000 0000 0011 1111 1000 0000 -> To square position (>> 7 & 0x7F)
+ *	0000 0000 0011 1100 0000 0000 0000 -> captured piece, if any (>> 14 & 0xF)
+ *	0000 0011 1100 0000 0000 0000 0000 -> if prmoted, what to? (>> 18 & 0xF)
+ *	0000 0100 0000 0000 0000 0000 0000 -> en passant (& 0x400000)
+ *	0000 1000 0000 0000 0000 0000 0000 -> pawn starting move (& 0x800000)
+ *	0001 0000 0000 0000 0000 0000 0000 -> castle move (& 0x1000000)
  * */
 
 /* OLD, DO NOT USE
@@ -35,38 +36,37 @@
 
 // Redefine as functions for fun :shrug:
 inline int get_from_sq(int mv){
-	return (mv & 0x3f);
+	return (mv & 0x7f);
 }
 inline int get_to_sq(int mv){
-	return ((mv >> 6) & 0x3f);
+	return ((mv >> 7) & 0x7f);
 }
 inline int get_captured_pc(int mv){
-	return ((mv >> 12) & 0xf);
+	return ((mv >> 14) & 0xf);
 }
 inline int get_promoted_to_pc(int mv){
-	return ((mv >> 16) & 0xf);
+	return ((mv >> 18) & 0xf);
 }
 inline int get_en_pass_flag(int mv){
-	return ((mv >> 20) & 0x1);
+	return ((mv >> 22) & 0x1);
 }
 inline int get_pawn_st_flag(int mv){
-	return ((mv >> 21) & 0x1);
+	return ((mv >> 23) & 0x1);
 }
 inline int get_castle_flag(int mv){
-	return ((mv >> 22) & 0x1);
+	return ((mv >> 24) & 0x1);
 }
-
-inline int get_rank(int position){
-	return (position >> 3);
-}
-inline int get_file(int position){
-	return (position & 7);
+// Just trying to get working for now.
+Rank get_rank(int pos){
+	if (pos >30 && pos < 39){
+		return Rank::RANK7;
+	} else if (pos > 80 && pos < 89){
+		return Rank::RANK2;
+	}
+	return Rank::RANK1;
 }
 
 inline bool is_valid_position(int position){
-	return !(position & 0x40);
-}
-inline bool is_invalid_position(int position){
-	return (position & 0x40);
+	return DEFAULT_BOARD[position] == PieceType::INV;
 }
 #endif

src/bitwise_constants.h

@@ -1,8 +1,9 @@
-#ifndef BITWISE_CONSTANTS_H
-#define BITWISE_CONSTANTS_H
+#ifndef BT_CONST_H
+#define BT_CONST_H
 
 #include <array>
 #include <iostream>
+#include <vector>
 
 enum Color {
 	NO_COLOR,
@@ -11,6 +12,7 @@ enum Color {
 };
 
 enum PieceType {
+	INV=-1,
 	NONE,
 	B_PAWN, B_KNIGHT, B_BISHOP, B_ROOK, B_QUEEN, B_KING,
 	W_PAWN, W_KNIGHT, W_BISHOP, W_ROOK, W_QUEEN, W_KING
@@ -31,6 +33,22 @@ enum Position {
 	A1=91, B1, C1, D1, E1, F1, G1, H1
 };
 
+// Access with POSITION_STRING[Position]
+const std::vector<std::string> POSITION_STRING = {
+	"INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", 	
+	"INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", 	
+	"INV", "A8", "B8", "C8", "D8", "E8", "F8", "G8", "H8", "INV",
+	"INV", "A7", "B7", "C7", "D7", "E7", "F7", "G7", "H7", "INV",
+	"INV", "A6", "B6", "C6", "D6", "E6", "F6", "G6", "H6", "INV",
+	"INV", "A5", "B5", "C5", "D5", "E5", "F5", "G5", "H5", "INV",
+	"INV", "A4", "B4", "C4", "D4", "E4", "F4", "G4", "H4", "INV",
+	"INV", "A3", "B3", "C3", "D3", "E3", "F3", "G3", "H3", "INV",
+	"INV", "A2", "B2", "C2", "D2", "E2", "F2", "G2", "H2", "INV",
+	"INV", "A1", "B1", "C1", "D1", "E1", "F1", "G1", "H1", "INV",
+	"INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", 	
+	"INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV", "INV"	
+};
+
 enum Rank{
 	RANK1,
 	RANK2,
@@ -53,24 +71,25 @@ enum File {
 	FILE8
 };
 
-std::array<int, 120> DEFAULT_BOARD = {
-	NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,	
-	NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,	
-	NA, B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK, NA,
-	NA, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, NA, 
-	NA, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NA, 
-	NA, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NA,
-	NA, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NA,
-	NA, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NA,
-	NA, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, NA,
-	NA, W_ROOK, W_KNIGHT, W_BISHOP, W_QUEEN, W_KING, W_BISHOP, W_KNIGHT, W_ROOK, NA,
-	NA,NA,NA,NA,NA,NA,NA,NA,NA,NA,
-	NA,NA,NA,NA,NA,NA,NA,NA,NA,NA
+const std::array<PieceType, 120> DEFAULT_BOARD = {
+	INV,INV,INV,INV,INV,INV,INV,INV,INV,INV,	
+	INV,INV,INV,INV,INV,INV,INV,INV,INV,INV,	
+	INV, B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK, INV,
+	INV, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, INV,
+	INV, W_ROOK, W_KNIGHT, W_BISHOP, W_QUEEN, W_KING, W_BISHOP, W_KNIGHT, W_ROOK, INV,
+	INV,INV,INV,INV,INV,INV,INV,INV,INV,INV,
+	INV,INV,INV,INV,INV,INV,INV,INV,INV,INV
 };
 
-char CHESS_CHARS[13] = {
+const std::array<char, 13> CHESS_CHARS = {
 	' ',
 	'P', 'N', 'B', 'R', 'Q', 'K',
 	'p', 'n', 'b', 'r', 'q', 'k'
 };
 #endif
+

src/bitwise_functions.cpp

@@ -68,11 +68,11 @@ Color get_color(PieceType pt){
 	return Color::NO_COLOR;
 }
 
-Color get_color(int x, int y, std::array<PieceType, 120> board){
-	return get_color(board[pair_to_pos(x, y)]);
+Color get_color(int x, int y, std::array<PieceType, 120> const *board){
+	return get_color((*board)[pair_to_pos(x, y)]);
 }
-Color get_color(Position pn, std::array<PieceType, 120> board){
-	return get_color(board[pn]);
+Color get_color(Position pn, std::array<PieceType, 120> const *board){
+	return get_color((*board)[pn]);
 }
 
 Color rev_color(Color c){
@@ -91,7 +91,7 @@ std::unordered_set<int> get_possible_moves(Position pn, std::array<PieceType, 12
 	return pns;
 }
 
-int get_pos_of(PieceType pt, std::array<PieceType, 120> *board){
+int get_pos_of(PieceType pt, std::array<PieceType, 120> const *board){
 	for (int pn = Position::A8; pn!=Position::H1; pn++){
 		if ((*board)[pn] == pt){
 			return pn;
@@ -100,6 +100,16 @@ int get_pos_of(PieceType pt, std::array<PieceType, 120> *board){
 	return Position::NA;
 }
 
+std::unordered_set<int> get_poss_of(PieceType pt, std::array<PieceType, 120> const *board){
+	std::unordered_set<int> results;
+	for (int pn = Position::A8; pn!=Position::H1; pn++){
+		if ((*board)[pn] == pt){
+			results.insert(pn);
+		}
+	}
+	return results;
+}
+
 void get_poss_of(PieceType pt, std::array<PieceType, 120>* board, std::vector<Position>* pns){
 	for (int pn = Position::A8; pn!=Position::H1; pn++){
 		if ((*board)[pn] == pt){
@@ -109,14 +119,14 @@ void get_poss_of(PieceType pt, std::array<PieceType, 120>* board, std::vector<Po
 }
 
 //TODO: Make faster by running from king squar eonly, instead of running on every piece of opposite team.
-void filter_checked_moves(Position pn, PieceType pt, std::array<PieceType, 120> *board, std::unordered_set<int> *pns){
+void filter_checked_moves(int pos, PieceType pt, std::array<PieceType, 120> *board, std::unordered_set<int> *pns){
 	PieceType my_king = is_white(pt)?PieceType::W_KING:PieceType::B_KING;
 	int my_king_pos = get_pos_of(my_king, board);
 	int attackers = 0;
 	for (auto p_pn= pns->begin(); p_pn!=pns->end();){
 		// Make move
-		int move_int = pn + (*p_pn >> 6);
-		std::array<PieceType, 120> moved_board = dumb_move(move_int, board);
+		int move_int = pos + (*p_pn >> 7);
+		std::array<PieceType, 120> moved_board = dumb_move(move_int, *board);
 		// Get all piecetypes of other team
 		std::array<PieceType, 6> other_team = is_white(pt)?Pieces::BLACK:Pieces::WHITE;
 		bool checks_king = false;
@@ -158,11 +168,8 @@ void filter_checked_moves(Position pn, PieceType pt, std::array<PieceType, 120>
 	}
 }
 
-void get_all_moves(Position pn, std::array<PieceType, 120>* board, std::unordered_set<int>* moves, bool recursive, int en_passant){
-	PieceType pt = (*board)[pn];
-	int pos = pn;
-	int x = pos_to_pair(pn).first;
-	int y = pos_to_pair(pn).second;
+void get_all_moves(int pos, std::array<PieceType, 120>* board, std::unordered_set<int>* moves, bool recursive, int en_passant){
+	PieceType pt = (*board)[pos];
 	Color color_of_piece = get_color(pt);
 	Color color_of_opponent = rev_color(color_of_piece);
 	switch(pt){
@@ -195,13 +202,33 @@ void get_all_moves(Position pn, std::array<PieceType, 120>* board, std::unordere
 			break;
 	}
 	if (recursive){
-		filter_checked_moves(pn, pt, board, moves);
+		filter_checked_moves(pos, pt, board, moves);
 	}
 }
 
-std::array<PieceType, 120> dumb_move(Position from, Position to, std::array<PieceType, 120> board){
+std::unordered_set<int> get_all_moves(int pos, std::array<PieceType, 120> board, bool recursive, int en_passant){
+	std::unordered_set<int> moves;
+	get_all_moves(pos, &board, &moves, recursive, en_passant);
+	return moves;
+}
+
+std::array<PieceType, 120> dumb_move(int move, std::array<PieceType, 120> board){
+	int from = get_from_sq(move);
+	int to = get_to_sq(move);
 	PieceType piece = board[from];
 	board[to] = piece;
 	board[from] = PieceType::NONE;
 	return board;
 }
+
+std::unordered_set<int> get_to_squares(std::unordered_set<int> moves){
+	std::unordered_set<int> to_squares;
+	for (int move : moves){
+		to_squares.insert(get_to_sq(move));
+	}
+	return to_squares;
+}
+std::unordered_set<int> get_from_squared(std::unordered_set<int> moves){
+	std::unordered_set<int> from_squares;
+	return from_squares;
+}

src/bitwise_functions.h

@@ -10,7 +10,8 @@ Position pair_to_pos(std::pair<int, int> pr);
 Position pair_to_pos(int x, int y);
 
 // Returns a list of positions with PieceType pt
-std::vector<Position> get_pos_of(PieceType pt, std::array<PieceType, 120>);
+int get_pos_of(PieceType pt, std::array<PieceType, 120> const *board);
+std::unordered_set<int> get_poss_of(PieceType pt, std::array<PieceType, 120> const *board);
 
 // Convert a Position number into a pair of x y coordiinates
 std::pair<int, int> pos_to_pair(Position pn);
@@ -25,8 +26,8 @@ bool is_valid_position(int x, int y);
 bool is_white(PieceType pt);
 bool is_black(PieceType pt);
 
-Color get_color(int x, int y, std::array<PieceType, 120> *board);
-Color get_color(Position pn, std::array<PieceType, 120> *board);
+Color get_color(int x, int y, std::array<PieceType, 120> const *board);
+Color get_color(Position pn, std::array<PieceType, 120> const *board);
 Color get_color(PieceType pt);
 // NO_COLOR returns NO_COLOR
 // WHITE returns BLACK
@@ -42,9 +43,19 @@ void get_possible_movers(Position pn, std::array<PieceType, 120> *pt,std::unorde
 // This may require helper functions for each individual piece.
 void get_possible_moves(Position pn, std::array<PieceType, 120> *pt,std::unordered_set<int> *moves);
 
+// This functions removes moves that put your own king in check.
+void filter_checked_moves(int pos, std::array<PieceType, 120> *board, std::unordered_set<int> *moves);
+
 // Get all moves for piece in Position pn.
-void get_all_moves(Position pn, std::array<PieceType, 120> *pt,std::unordered_set<int> *moves, bool recursive=true, int en_passant=Position::NA);
+void get_all_moves(int pos, std::array<PieceType, 120> *pt,std::unordered_set<int> *moves, bool recursive=true, int en_passant=Position::NA);
+std::unordered_set<int> get_all_moves(int pos, std::array<PieceType, 120> board, bool recursive=true, int en_passant=Position::NA);
 
 // Dumb function to do board moves.
 // Does not check if move is valid, just does it.
-std::array<PieceType, 120> dumb_move(int move, std::array<PieceType, 120> *board);
+std::array<PieceType, 120> dumb_move(int move, std::array<PieceType, 120> board);
+
+// Allow the developer to get only certain pieces of the part of a move in a list.
+// This will return a vector (or unordered_set) of elements with only a certain part of the move revealed bit bit-switching.
+std::unordered_set<int> get_from_squares(std::unordered_set<int> moves);
+std::unordered_set<int> get_to_squares(std::unordered_set<int> moves);
+

tests/B_test_boards.h

@@ -1,19 +1,23 @@
 #include <unordered_set>
-#include <constants.h>
+#include <bitwise_constants.h>
 
-const Position B_QUEEN_POS = E4;
-const std::array<PieceType, 64> B_QUEEN_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, B_QUEEN, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int B_QUEEN_POS = E4;
+const std::array<PieceType, 120> B_QUEEN_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, B_QUEEN, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
-const std::unordered_set<Position> B_QUEEN_ALL_MOVES = {
+const std::unordered_set<int> B_QUEEN_ALL_MOVES = {
 	A8, E8,
 	B7, E7, H7,
 	C6, E6, G6,
@@ -24,19 +28,23 @@ const std::unordered_set<Position> B_QUEEN_ALL_MOVES = {
 	B1, E1, H1
 };
 
-const Position B_BISHOP_POS = D4;
-const std::array<PieceType, 64> B_BISHOP_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, B_BISHOP, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int B_BISHOP_POS = D4;
+const std::array<PieceType, 120> B_BISHOP_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, B_BISHOP, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
-const std::unordered_set<Position> B_BISHOP_ALL_MOVES = {
+const std::unordered_set<int> B_BISHOP_ALL_MOVES = {
 	H8,
 	A7, G7,
 	B6, F6,
@@ -46,121 +54,149 @@ const std::unordered_set<Position> B_BISHOP_ALL_MOVES = {
 	A1, G1
 };
 
-const Position B_KNIGHT_POS = D5;
-const std::array<PieceType, 64> B_KNIGHT_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, B_KNIGHT, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int B_KNIGHT_POS = D5;
+const std::array<PieceType, 120> B_KNIGHT_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, B_KNIGHT, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
-const std::unordered_set<Position> B_KNIGHT_ALL_MOVES = {
+const std::unordered_set<int> B_KNIGHT_ALL_MOVES = {
 	C7, E7,
 	B6, F6,
 	B4, F4,
 	C3, E3
 };
 
-const Position B_ROOK_POS = E5;
-const std::array<PieceType, 64> B_ROOK_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, B_ROOK, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int B_ROOK_POS = E5;
+const std::array<PieceType, 120> B_ROOK_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, B_ROOK, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
-const std::unordered_set<Position> B_ROOK_ALL_MOVES = {
+const std::unordered_set<int> B_ROOK_ALL_MOVES = {
 	E8, E7, E6,
 	A5, B5, C5, D5, F5, G5, H5,
 	E4, E3, E2, E1
 };
 
 
-const Position B_KING_POS = C4;
-const std::array<PieceType, 64> B_KING_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, B_KING, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int B_KING_POS = C4;
+const std::array<PieceType, 120> B_KING_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, B_KING, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
-const std::unordered_set<Position> B_KING_ALL_MOVES = {
+const std::unordered_set<int> B_KING_ALL_MOVES = {
 	B5, C5, D5,
 	B4, D4,
 	B3, C3, D3
 };
 
 
-const Position B_PAWN_POS = F4;
-const std::array<PieceType, 64> B_PAWN_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, B_PAWN, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int B_PAWN_POS = F4;
+const std::array<PieceType, 120> B_PAWN_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, B_PAWN, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
-const std::unordered_set<Position> B_PAWN_ALL_MOVES = {
+const std::unordered_set<int> B_PAWN_ALL_MOVES = {
 	F3
 };
-const Position B_KNIGHT_SIDE1_POS = B7;
-const std::array<PieceType, 64> B_KNIGHT_SIDE1_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, B_KNIGHT, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-const std::unordered_set<Position> B_KNIGHT_SIDE1_ALL_MOVES = {
+const int B_KNIGHT_SIDE1_POS = B7;
+const std::array<PieceType, 120> B_KNIGHT_SIDE1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, B_KNIGHT, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+const std::unordered_set<int> B_KNIGHT_SIDE1_ALL_MOVES = {
 	D8,
 	D6,
 	A5, C5
 };
-const Position B_KING_SIDE1_POS = A8;
-const std::array<PieceType, 64> B_KING_SIDE1_BOARD = {
-	B_KING, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-const std::unordered_set<Position> B_KING_SIDE1_ALL_MOVES = {
+const int B_KING_SIDE1_POS = A8;
+const std::array<PieceType, 120> B_KING_SIDE1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, B_KING, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+const std::unordered_set<int> B_KING_SIDE1_ALL_MOVES = {
 	B8,
 	A7,B7
 };
 
-const Position B_PAWN_SIDE1_POS = A7;
-const std::array<PieceType, 64> B_PAWN_SIDE1_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	B_PAWN, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-const std::unordered_set<Position> B_PAWN_SIDE1_ALL_MOVES = {
+const int B_PAWN_SIDE1_POS = A7;
+const std::array<PieceType, 120> B_PAWN_SIDE1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, B_PAWN, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+const std::unordered_set<int> B_PAWN_SIDE1_ALL_MOVES = {
 	A6, A5
 };

tests/Makefile

@@ -8,11 +8,14 @@ catch_main.o:
 custom_printing.o:
 	g++ -w -I../src/ -c -o custom_printing.o custom_printing.cpp
 
+custom_bitwise_printing.o:
+	g++ -w -I../src/ -c -o custom_bitwise_printing.o custom_bitwise_printing.cpp
+
 bitwise.out: catch_main.o
 	g++ -I../src/ -o bitwise.out ../src/bitwise.cpp catch_main.o bitwise_tests.cpp
 
-bitwise_main.out: catch_main.o
-	g++ -I../src/ -o bitwise_functions.out ../src/bitwise.cpp catch_main.o ../src/bitwise_functions.cpp bitwise_main.cpp
+bitwise_main.out: catch_main.o custom_bitwise_printing.o
+	g++ -I../src/ -o bitwise_functions.out catch_main.o custom_bitwise_printing.o ../src/bitwise_functions.cpp bitwise_main.cpp
 
 # TODO: Allw all.out to contain bitwise tests
 all.out: catch_main.o custom_printing.o

tests/W_test_boards.h

@@ -1,29 +1,38 @@
 #include <unordered_set>
-#include <constants.h>
-
-const Position W_QUEEN_POS = E4;
-const std::array<PieceType, 64> W_QUEEN_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, W_QUEEN, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-const std::array<PieceType, 64> W_QUEEN_BOARD_BLOCKED = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, B_PAWN, W_PAWN, B_PAWN, NONE, NONE, 	
-	NONE, NONE, NONE, W_KNIGHT, W_QUEEN, B_PAWN, NONE, NONE, 	
-	NONE, NONE, NONE, B_QUEEN, B_KNIGHT, W_PAWN, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-
-const std::unordered_set<Position> W_QUEEN_ALL_MOVES = {
+#include <bitwise_constants.h>
+
+const int W_QUEEN_POS = E4;
+const std::array<PieceType, 120> W_QUEEN_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, NONE, NONE, NONE, NONE, W_QUEEN, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+
+const std::array<PieceType, 120> W_QUEEN_BOARD_BLOCKED = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, B_PAWN, W_PAWN, B_PAWN, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, W_KNIGHT, W_QUEEN, B_PAWN, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, B_QUEEN, B_KNIGHT, W_PAWN, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV
+};
+
+const std::unordered_set<int> W_QUEEN_ALL_MOVES = {
 	A8, E8,
 	B7, E7, H7,
 	C6, E6, G6,
@@ -34,19 +43,23 @@ const std::unordered_set<Position> W_QUEEN_ALL_MOVES = {
 	B1, E1, H1
 };
 
-const Position W_BISHOP_POS = D4;
-const std::array<PieceType, 64> W_BISHOP_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, W_BISHOP, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int W_BISHOP_POS = D4;
+const std::array<PieceType, 120> W_BISHOP_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, W_BISHOP, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV,	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
-const std::unordered_set<Position> W_BISHOP_ALL_MOVES = {
+const std::unordered_set<int> W_BISHOP_ALL_MOVES = {
 	H8,
 	A7, G7,
 	B6, F6,
@@ -56,122 +69,150 @@ const std::unordered_set<Position> W_BISHOP_ALL_MOVES = {
 	A1, G1
 };
 
-const Position W_KNIGHT_POS = D5;
-const std::array<PieceType, 64> W_KNIGHT_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, W_KNIGHT, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-
-const Position W_KNIGHT_SIDE1_POS = B7;
-const std::array<PieceType, 64> W_KNIGHT_SIDE1_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, W_KNIGHT, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-const std::unordered_set<Position> W_KNIGHT_SIDE1_ALL_MOVES = {
+const int W_KNIGHT_POS = D5;
+const std::array<PieceType, 120> W_KNIGHT_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, W_KNIGHT, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV,	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+
+const int W_KNIGHT_SIDE1_POS = B7;
+const std::array<PieceType, 120> W_KNIGHT_SIDE1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, W_KNIGHT, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV,	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+const std::unordered_set<int> W_KNIGHT_SIDE1_ALL_MOVES = {
 	D8,
 	D6,
 	A5, C5
 };
 
-const std::unordered_set<Position> W_KNIGHT_ALL_MOVES = {
+const std::unordered_set<int> W_KNIGHT_ALL_MOVES = {
 	C7, E7,
 	B6, F6,
 	B4, F4,
 	C3, E3
 };
 
-const Position W_ROOK_POS = E5;
-const std::array<PieceType, 64> W_ROOK_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, W_ROOK, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int W_ROOK_POS = E5;
+const std::array<PieceType, 120> W_ROOK_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, W_ROOK, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV,	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
-const std::unordered_set<Position> W_ROOK_ALL_MOVES = {
+const std::unordered_set<int> W_ROOK_ALL_MOVES = {
 	E8, E7, E6,
 	A5, B5, C5, D5, F5, G5, H5,
 	E4, E3, E2, E1
 };
 
 
-const Position W_KING_POS = C4;
-const std::array<PieceType, 64> W_KING_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, W_KING, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-
-const Position W_KING_SIDE1_POS = A8;
-const std::array<PieceType, 64> W_KING_SIDE1_BOARD = {
-	W_KING, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-
-const std::unordered_set<Position> W_KING_SIDE1_ALL_MOVES = {
+const int W_KING_POS = C4;
+const std::array<PieceType, 120> W_KING_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, W_KING, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+
+const int W_KING_SIDE1_POS = A8;
+const std::array<PieceType, 120> W_KING_SIDE1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, W_KING, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+
+const std::unordered_set<int> W_KING_SIDE1_ALL_MOVES = {
 	B8,
 	A7,B7
 };
 
-const std::unordered_set<Position> W_KING_ALL_MOVES = {
+const std::unordered_set<int> W_KING_ALL_MOVES = {
 	B5, C5, D5,
 	B4, D4,
 	B3, C3, D3
 };
 
 
-const Position W_PAWN_POS = F4;
-const std::array<PieceType, 64> W_PAWN_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, W_PAWN, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int W_PAWN_POS = F4;
+const std::array<PieceType, 120> W_PAWN_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, W_PAWN, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
-const std::unordered_set<Position> W_PAWN_ALL_MOVES = {
+const std::unordered_set<int> W_PAWN_ALL_MOVES = {
 	F5
 };
 
-const Position W_PAWN_SIDE1_POS = A8;
-const std::array<PieceType, 64> W_PAWN_SIDE1_BOARD = {
-	W_PAWN, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-const std::unordered_set<Position> W_PAWN_SIDE1_ALL_MOVES;
+const int W_PAWN_SIDE1_POS = A8;
+const std::array<PieceType, 120> W_PAWN_SIDE1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, W_PAWN, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+const std::unordered_set<int> W_PAWN_SIDE1_ALL_MOVES;

tests/bitwise_main.cpp

@@ -1,38 +1,37 @@
 #include "catch.hpp"
 #include "test_boards.h"
 #include "valid_moves.h"
-#include "custom_printing.cpp"
+#include "custom_bitwise_printing.cpp"
 #include <sstream>
 #include <bitwise_functions.h>
 
 
-const std::array<PieceType, 64> TEST_MOVES = {
-	W_QUEEN, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, B_KNIGHT
-};
-
-const std::array<PieceType, 64> DUMB_MOVE_1 = {
-	B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK,	
-	B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, W_PAWN, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	W_PAWN, NONE, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, 
-	W_ROOK, W_KNIGHT, W_BISHOP, W_QUEEN, W_KING, W_BISHOP, W_KNIGHT, W_ROOK 
+const std::array<PieceType, 120> DUMB_MOVE_1 = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK,INV,	
+	INV, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, W_PAWN, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, W_PAWN, NONE, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN,INV, 
+	INV, W_ROOK, W_KNIGHT, W_BISHOP, W_QUEEN, W_KING, W_BISHOP, W_KNIGHT, W_ROOK, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 
 TEST_CASE("Test that an unordered set of positions are returned when looking for a piece type through a board", "[get_pos_of]"){
-	CHECK(get_pos_of(PieceType::B_PAWN, DEFAULT_BOARD) == B_PAWNS_SQUARES);
+	CHECK(get_poss_of(PieceType::B_PAWN, &DEFAULT_BOARD) == B_PAWNS_SQUARES);
 }
 
 TEST_CASE("Test that a color can be gotten from a given square on the board", "[get_color]"){
-	CHECK(get_color(2, 7, DUMB_MOVE_1) == Color::BLACK);
-	CHECK(get_color(3, 3, DUMB_MOVE_1) == Color::NO_COLOR);
-	CHECK(get_color(2, 1, DUMB_MOVE_1) == Color::WHITE);
-	CHECK(get_color(Position::C8, DUMB_MOVE_1) == Color::BLACK);
-	CHECK(get_color(Position::F4, DUMB_MOVE_1) == Color::NO_COLOR);
-	CHECK(get_color(Position::C2, DUMB_MOVE_1) == Color::WHITE);
+	CHECK(get_color(2, 7, &DUMB_MOVE_1) == Color::BLACK);
+	CHECK(get_color(3, 3, &DUMB_MOVE_1) == Color::NO_COLOR);
+	CHECK(get_color(2, 1, &DUMB_MOVE_1) == Color::WHITE);
+	CHECK(get_color(Position::C8, &DUMB_MOVE_1) == Color::BLACK);
+	CHECK(get_color(Position::F4, &DUMB_MOVE_1) == Color::NO_COLOR);
+	CHECK(get_color(Position::C2, &DUMB_MOVE_1) == Color::WHITE);
 }
 TEST_CASE("Test that a color can be gotten from a PieceType", "[get_color]"){
 	CHECK(get_color(PieceType::NONE) == Color::NO_COLOR);
@@ -58,7 +57,8 @@ TEST_CASE("Test that is_black, and is_white are working", "[is_black][is_white]"
 }
 
 TEST_CASE("Test that dumb moves can be made.", "[dumb_move]"){
-	CHECK(dumb_move(Position::B2, Position::B5, DEFAULT_BOARD) == DUMB_MOVE_1);
+	int move_int = Position::B2 + (Position::B5 << 7);
+	CHECK(dumb_move(move_int, DEFAULT_BOARD) == DUMB_MOVE_1);
 }
 
 TEST_CASE("Test convert method to go from X and Y to board position", "[pair_to_pos]"){
@@ -102,56 +102,41 @@ TEST_CASE("Test that invalid position ints return false", "[is_valid_position]")
 	CHECK_FALSE(is_valid_position(5, 8)); // should fail
 }
 
-TEST_CASE("Test what pieces may move where functon", "[get_possible_movers]"){
-	std::unordered_set<Position> H1_possible_movers = {Position::H2, Position::G1};
-	CHECK(get_possible_movers(BISHOP_BLOCKED1_KING_POS, BISHOP_BLOCKED1_BOARD) == BISHOP_BLOCKED1_CAN_MOVE_TO_B_KING);
-	CHECK(get_possible_movers(Position::H3, DEFAULT_BOARD) == H1_possible_movers);
-}
-
-TEST_CASE("Test where this piece may move to", "[get_possible_moves]"){
-	CHECK(get_possible_moves(Position::G1, DEFAULT_BOARD) == DEFAULT_W_R_KNIGHT_POSSIBLE_MOVES);
-	CHECK(get_possible_moves(Position::A7, DEFAULT_BOARD) == DEFAULT_B_A_PAWN_POSSIBLE_MOVES);
-	CHECK(get_possible_moves(Position::A2, DEFAULT_BOARD) == DEFAULT_W_A_PAWN_POSSIBLE_MOVES);
-	CHECK(get_possible_moves(KNIGHT_BLOCKED1_POS, KNIGHT_BLOCKED1_BOARD) == KNIGHT_BLOCKED1_MOVES);
-	CHECK(get_possible_moves(BISHOP_BLOCKED1_POS, BISHOP_BLOCKED1_BOARD) == BISHOP_BLOCKED1_MOVES);
-	CHECK(get_possible_moves(ROOK_BLOCKED1_POS, ROOK_BLOCKED1_BOARD) == ROOK_BLOCKED1_MOVES);
-}
-
 TEST_CASE("Test all possible and impossible moves for black pieces", "[get_all_moves][black]"){
-	CHECK(get_all_moves(B_KING_POS, B_KING_BOARD) == B_KING_ALL_MOVES);
-	CHECK(get_all_moves(B_QUEEN_POS, B_QUEEN_BOARD) == B_QUEEN_ALL_MOVES);
-	CHECK(get_all_moves(B_ROOK_POS, B_ROOK_BOARD) == B_ROOK_ALL_MOVES);
-	CHECK(get_all_moves(B_BISHOP_POS, B_BISHOP_BOARD) == B_BISHOP_ALL_MOVES);
-	CHECK(get_all_moves(B_KNIGHT_POS, B_KNIGHT_BOARD) == B_KNIGHT_ALL_MOVES);
-	CHECK(get_all_moves(B_PAWN_POS, B_PAWN_BOARD) == B_PAWN_ALL_MOVES);
+	CHECK(get_to_squares(get_all_moves(B_KING_POS, B_KING_BOARD)) == get_to_squares(B_KING_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(B_QUEEN_POS, B_QUEEN_BOARD)) == get_to_squares(B_QUEEN_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(B_ROOK_POS, B_ROOK_BOARD)) == get_to_squares(B_ROOK_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(B_BISHOP_POS, B_BISHOP_BOARD)) == get_to_squares(B_BISHOP_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(B_KNIGHT_POS, B_KNIGHT_BOARD)) == get_to_squares(B_KNIGHT_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(B_PAWN_POS, B_PAWN_BOARD)) == get_to_squares(B_PAWN_ALL_MOVES));
 }
 TEST_CASE("Test all possible and impossible moves for whtie pieces", "[get_all_moves][white]"){
-	CHECK(get_all_moves(W_KING_POS, W_KING_BOARD) == W_KING_ALL_MOVES);
-	CHECK(get_all_moves(W_QUEEN_POS, W_QUEEN_BOARD) == W_QUEEN_ALL_MOVES);
-	CHECK(get_all_moves(W_ROOK_POS, W_ROOK_BOARD) == W_ROOK_ALL_MOVES);
-	CHECK(get_all_moves(W_BISHOP_POS, W_BISHOP_BOARD) == W_BISHOP_ALL_MOVES);
-	CHECK(get_all_moves(W_KNIGHT_POS, W_KNIGHT_BOARD) == W_KNIGHT_ALL_MOVES);
-	CHECK(get_all_moves(W_PAWN_POS, W_PAWN_BOARD) == W_PAWN_ALL_MOVES);
+	CHECK(get_to_squares(get_all_moves(W_KING_POS, W_KING_BOARD)) == get_to_squares(W_KING_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(W_QUEEN_POS, W_QUEEN_BOARD)) == get_to_squares(W_QUEEN_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(W_ROOK_POS, W_ROOK_BOARD)) == get_to_squares(W_ROOK_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(W_BISHOP_POS, W_BISHOP_BOARD)) == get_to_squares(W_BISHOP_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(W_KNIGHT_POS, W_KNIGHT_BOARD)) == get_to_squares(W_KNIGHT_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(W_PAWN_POS, W_PAWN_BOARD)) == get_to_squares(W_PAWN_ALL_MOVES));
 }
 
 TEST_CASE("Test all moves for white in edge cases.", "[get_all_moves][white]"){
-	CHECK(get_all_moves(W_KNIGHT_SIDE1_POS, W_KNIGHT_SIDE1_BOARD) == W_KNIGHT_SIDE1_ALL_MOVES);
-	CHECK(get_all_moves(W_KING_SIDE1_POS, W_KING_SIDE1_BOARD) == W_KING_SIDE1_ALL_MOVES);
-	CHECK(get_all_moves(W_PAWN_SIDE1_POS, W_PAWN_SIDE1_BOARD) == W_PAWN_SIDE1_ALL_MOVES);
+	CHECK(get_to_squares(get_all_moves(W_KNIGHT_SIDE1_POS, W_KNIGHT_SIDE1_BOARD)) == get_to_squares(W_KNIGHT_SIDE1_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(W_KING_SIDE1_POS, W_KING_SIDE1_BOARD)) == get_to_squares(W_KING_SIDE1_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(W_PAWN_SIDE1_POS, W_PAWN_SIDE1_BOARD)) == get_to_squares(W_PAWN_SIDE1_ALL_MOVES));
 }
 TEST_CASE("Test all moves for black in edge cases.", "[get_all_moves][black]"){
-	CHECK(get_all_moves(B_KNIGHT_SIDE1_POS, B_KNIGHT_SIDE1_BOARD) == B_KNIGHT_SIDE1_ALL_MOVES);
-	CHECK(get_all_moves(B_KING_SIDE1_POS, B_KING_SIDE1_BOARD) == B_KING_SIDE1_ALL_MOVES);
-	CHECK(get_all_moves(B_PAWN_SIDE1_POS, B_PAWN_SIDE1_BOARD) == B_PAWN_SIDE1_ALL_MOVES);
+	CHECK(get_to_squares(get_all_moves(B_KNIGHT_SIDE1_POS, B_KNIGHT_SIDE1_BOARD)) == get_to_squares(B_KNIGHT_SIDE1_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(B_KING_SIDE1_POS, B_KING_SIDE1_BOARD)) == get_to_squares(B_KING_SIDE1_ALL_MOVES));
+	CHECK(get_to_squares(get_all_moves(B_PAWN_SIDE1_POS, B_PAWN_SIDE1_BOARD)) == get_to_squares(B_PAWN_SIDE1_ALL_MOVES));
 }
 
 TEST_CASE("Test that moves that put king in check are not returned", "[get_all_moves]"){
-	CHECK(get_all_moves(ROOK_CHECK_TEST_POS, ROOK_CHECK_TEST_BOARD) == ROOK_CHECK_TEST_MOVES);
-	CHECK(get_all_moves(PAWN_CHECK_TEST_POS, PAWN_CHECK_TEST_BOARD) == PAWN_CHECK_TEST_MOVES);
-	CHECK(get_all_moves(PAWN_DIAG_TEST1_POS, PAWN_DIAG_TEST1_BOARD) == PAWN_DIAG_TEST1_MOVES);
+	CHECK(get_to_squares(get_all_moves(ROOK_CHECK_TEST_POS, ROOK_CHECK_TEST_BOARD)) == get_to_squares(ROOK_CHECK_TEST_MOVES));
+	CHECK(get_to_squares(get_all_moves(PAWN_CHECK_TEST_POS, PAWN_CHECK_TEST_BOARD)) == get_to_squares(PAWN_CHECK_TEST_MOVES));
+	CHECK(get_to_squares(get_all_moves(PAWN_DIAG_TEST1_POS, PAWN_DIAG_TEST1_BOARD)) == get_to_squares(PAWN_DIAG_TEST1_MOVES));
 }
 
 TEST_CASE("Tests for en pessant squares.", "[get_all_moves]"){
-	CHECK(get_all_moves(EN_PASSANT_TEST_POS, EN_PASSANT_TEST_BOARD, false, EN_PASSANT_SQUARE) == EN_PASSANT_TEST_MOVES);
-	CHECK(get_all_moves(NO_EN_PASSANT_TEST_POS, NO_EN_PASSANT_TEST_BOARD) == NO_EN_PASSANT_TEST_MOVES);
+	CHECK(get_to_squares(get_all_moves(EN_PASSANT_TEST_POS, EN_PASSANT_TEST_BOARD, false, EN_PASSANT_SQUARE)) == get_to_squares(EN_PASSANT_TEST_MOVES));
+	CHECK(get_to_squares(get_all_moves(NO_EN_PASSANT_TEST_POS, NO_EN_PASSANT_TEST_BOARD)) == get_to_squares(NO_EN_PASSANT_TEST_MOVES));
 }

tests/bitwise_tests.cpp

@@ -1,4 +1,4 @@
-#include <constants.h>
+#include <bitwise_constants.h>
 #include <bitwise.h>
 #include "catch.hpp"
 

tests/custom_bitwise_printing.cpp

@@ -0,0 +1,95 @@
+#include "catch.hpp"
+#include <bitwise_constants.h>
+#include <sstream>
+#include <unordered_set>
+
+// For some retarted reason, I need to implement the printing of pairs, otherwise in the test outputs they show up as {?}
+// Also override default printing for Positions so it prints the value (e.g. 32), then, in parenthasies, the location (e.g. A4).
+// Example: A4(32)
+namespace Catch {
+	template<>
+	struct StringMaker<std::pair<int, int>> {
+		static std::string convert(std::pair<int, int> const& p){
+			std::stringstream ss;
+			ss << "{ " << p.first << ", " << p.second << " }";
+			return ss.str();
+		}
+	};
+	template<> 
+	struct StringMaker<Position> {
+		static std::string convert(Position const& p){
+			std::stringstream ss;
+			ss << (int) p << "(" << POSITION_STRING[p] << ")";
+			return ss.str();
+		}
+	};
+	// This override makes sure that Color enum variables are printed properly
+	template<>
+	struct StringMaker<Color> {
+		static std::string convert(Color const& c){
+			std::stringstream ss;
+			if (c==Color::WHITE) ss << "white";
+			if (c==Color::BLACK) ss << "black";
+			if (c==Color::NO_COLOR) ss << "N/A";
+			return ss.str();
+		}
+	};
+	// This prints all board comparisons in a readable fashion. Using the string name of the pieces, and newlines to seperate them.
+	template<>
+	struct StringMaker<std::array<PieceType, 120>> {
+		static std::string convert(std::array<PieceType, 120> const& board){
+			std::stringstream ss;
+			ss << "{" << std::endl;
+			for (int i = 2; i < 10; ++i){
+				for (int j = 1; j < 9; ++j){
+					int index = (i*10)+j;
+					ss << CHESS_CHARS[board[index]] << ", ";
+				}
+				ss << std::endl;
+			}
+			ss << "}" << std::endl;
+			return ss.str();
+		}
+	};
+	// This overrides vectors of positions. I want it to print a board with the positions that are selected so we can see a representation of what positions are selected.
+	template<>
+	struct StringMaker<std::unordered_set<Position>> {
+		static std::string convert(std::unordered_set<Position> const& uo_poss){
+			std::vector<Position> poss(uo_poss.begin(), uo_poss.end());
+			std::stringstream ss;
+			std::string files = "  A B C D E F G H";
+			ss << "{ {" << std::endl;
+			ss << files << std::endl;
+			for (int i = 0; i < 8; ++i){
+				ss << 8-i << "|";
+				for (int j = 0; j < 8; ++j){
+					int index = (i*8)+j;
+					// This part loops through all positions in the list and checks if it contains the current index.
+					bool part_of_poss = false;
+					for (Position p : poss){
+						if (index == p) {
+							part_of_poss = true;
+							break;
+						}
+					}
+					// Justin, this is how this oporator works.
+					// (if) part_of_poss ?(then) do this :(else) do that.
+					part_of_poss ? ss << "* " : ss << "  ";
+				}
+				ss << "|" << 8-i;
+				ss << std::endl;
+			}
+			ss << files << std::endl;
+			ss << "}" << std::endl;
+		        ss << "," << std::endl;
+		        ss << "{ ";
+			for (int pi = 0; pi < poss.size(); ++pi){
+				pi == poss.size()-1 ? ss << poss[pi] << "(" << POSITION_STRING[poss[pi]] << ")" : ss << poss[pi] << "(" << POSITION_STRING[poss[pi]] << "), ";
+			}
+			ss << " } }" << std::endl;
+			return ss.str();
+		}
+	};
+		
+}
+

tests/valid_moves.h

@@ -1,55 +1,63 @@
 #include <unordered_set>
-#include <constants.h>
+#include <bitwise_constants.h>
 
 
 /// This is for possible moves on a default board
-const std::unordered_set<Position> DEFAULT_B_A_PAWN_POSSIBLE_MOVES = {
+const std::unordered_set<int> DEFAULT_B_A_PAWN_POSSIBLE_MOVES = {
 	A6, A5
 };
-const std::unordered_set<Position> DEFAULT_W_A_PAWN_POSSIBLE_MOVES = {
+const std::unordered_set<int> DEFAULT_W_A_PAWN_POSSIBLE_MOVES = {
 	A3, A4
 };
-const std::unordered_set<Position> DEFAULT_W_R_KNIGHT_POSSIBLE_MOVES = {
+const std::unordered_set<int> DEFAULT_W_R_KNIGHT_POSSIBLE_MOVES = {
 	H3, F3
 };
 // EMPTY
-const std::unordered_set<Position> DEFAULT_W_R_ROOK_POSSIBLE_MOVES = {};
+const std::unordered_set<int> DEFAULT_W_R_ROOK_POSSIBLE_MOVES = {};
 
-const std::vector<Position> B_PAWNS_SQUARES = {
+const std::unordered_set<int> B_PAWNS_SQUARES = {
 	A7, B7, C7, D7, E7, F7, G7, H7
 };
 
 // END of default selections
 
-const Position KNIGHT_BLOCKED1_POS = B8;
-const std::array<PieceType, 64> KNIGHT_BLOCKED1_BOARD = {
-	NONE, B_KNIGHT, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, B_PAWN, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, W_PAWN, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
+const int KNIGHT_BLOCKED1_POS = B8;
+const std::array<PieceType, 120> KNIGHT_BLOCKED1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, B_KNIGHT, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, B_PAWN, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, W_PAWN, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 // Should NOT inclde D7
-const std::unordered_set<Position> KNIGHT_BLOCKED1_MOVES = {
+const std::unordered_set<int> KNIGHT_BLOCKED1_MOVES = {
 	A6, C6
 };
 
-const Position BISHOP_BLOCKED1_POS = D5;
-const std::array<PieceType, 64> BISHOP_BLOCKED1_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, B_QUEEN, NONE  , B_PAWN  , NONE, W_KING, NONE, NONE, 	
-	NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, 	
-	NONE, NONE   , W_ROOK, W_BISHOP, NONE, NONE, NONE, NONE, 	
-	NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, 	
-	NONE, NONE   , NONE  , NONE    , NONE, B_KING, NONE, NONE, 	
-	NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, 	
-	NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE
+const int BISHOP_BLOCKED1_POS = D5;
+const std::array<PieceType, 120> BISHOP_BLOCKED1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, B_QUEEN, NONE  , B_PAWN  , NONE, W_KING, NONE, NONE,  INV,	
+	INV, NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE   , W_ROOK, W_BISHOP, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE   , NONE  , NONE    , NONE, B_KING, NONE, NONE,  INV,	
+	INV, NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
 };
 // Should NOT include A8, H8, G2, or H1
-const std::unordered_set<Position> BISHOP_BLOCKED1_MOVES = {
+const std::unordered_set<int> BISHOP_BLOCKED1_MOVES = {
 	B7,
 	C6,E6,
 	C4,E4,
@@ -57,101 +65,125 @@ const std::unordered_set<Position> BISHOP_BLOCKED1_MOVES = {
 	A2
 };
 // Should NOT include B2 (black queen) as it is obstructed by the bishop on D5
-const std::unordered_set<Position> BISHOP_BLOCKED1_CAN_MOVE_TO_B_KING = {
+const std::unordered_set<int> BISHOP_BLOCKED1_CAN_MOVE_TO_B_KING = {
 	D5
 };
-const Position BISHOP_BLOCKED1_KING_POS = F3;
+const int BISHOP_BLOCKED1_KING_POS = F3;
 
 
-const Position ROOK_BLOCKED1_POS = B7;
-const std::array<PieceType, 64> ROOK_BLOCKED1_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, W_ROOK, NONE  , B_PAWN  , NONE, B_KING, NONE, NONE, 	
-	NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, 	
-	NONE, NONE   , B_BISHOP, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, 	
-	NONE, W_KING   , NONE  , NONE    , NONE, NONE, NONE, NONE, 	
-	NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, 	
-	NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE
+const int ROOK_BLOCKED1_POS = B7;
+const std::array<PieceType, 120> ROOK_BLOCKED1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,  INV,	
+	INV, NONE, W_ROOK, NONE  , B_PAWN  , NONE, B_KING, NONE, NONE, INV,	
+	INV, NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE   , B_BISHOP, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, W_KING   , NONE  , NONE    , NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE   , NONE  , NONE    , NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV
 };
 // Should NOT include E-H2 or B3-1
-const std::unordered_set<Position> ROOK_BLOCKED1_MOVES = {
+const std::unordered_set<int> ROOK_BLOCKED1_MOVES = {
 	B8,
 	A7, C7, D7,
 	B6,B5,B4
 };
 
-const Position PAWN_DIAG_TEST1_POS = E7;
-const std::array<PieceType, 64> PAWN_DIAG_TEST1_BOARD = {
-	B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK,	
-	B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, 
-	NONE, NONE, NONE, W_QUEEN, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, 
-	W_ROOK, W_KNIGHT, W_BISHOP, NONE, W_KING, W_BISHOP, W_KNIGHT, W_ROOK 
-};
-const std::unordered_set<Position> PAWN_DIAG_TEST1_MOVES = {
+const int PAWN_DIAG_TEST1_POS = E7;
+const std::array<PieceType, 120> PAWN_DIAG_TEST1_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK,INV,	
+	INV, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN,INV, 
+	INV, NONE, NONE, NONE, W_QUEEN, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN, W_PAWN,INV, 
+	INV, W_ROOK, W_KNIGHT, W_BISHOP, NONE, W_KING, W_BISHOP, W_KNIGHT, W_ROOK, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+const std::unordered_set<int> PAWN_DIAG_TEST1_MOVES = {
 	D6, E6, E5
 };
 
 // For testing the invalidating of moves because of putting own king in check
-const Position ROOK_CHECK_TEST_POS = D5;
-const std::array<PieceType, 64> ROOK_CHECK_TEST_BOARD = {
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, W_QUEEN, B_ROOK, NONE, B_KING, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 	
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE
-};
-const std::unordered_set<Position> ROOK_CHECK_TEST_MOVES = {
+const int ROOK_CHECK_TEST_POS = D5;
+const std::array<PieceType, 120> ROOK_CHECK_TEST_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, W_QUEEN, B_ROOK, NONE, B_KING, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,	
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV,
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV
+};
+const std::unordered_set<int> ROOK_CHECK_TEST_MOVES = {
 	C5, E5
 };
 
-const Position PAWN_CHECK_TEST_POS = E7;
-const std::array<PieceType, 64> PAWN_CHECK_TEST_BOARD = {
-	B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK,	
-	B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, 
-	NONE, NONE, NONE, W_PAWN, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, W_QUEEN, NONE, NONE, NONE, 
-	W_PAWN, W_PAWN, W_PAWN, NONE, W_PAWN, W_PAWN, W_PAWN, W_PAWN, 
-	W_ROOK, W_KNIGHT, W_BISHOP, NONE, W_KING, W_BISHOP, W_KNIGHT, W_ROOK 
-};
-const std::unordered_set<Position> PAWN_CHECK_TEST_MOVES = {E6, E5};
+const int PAWN_CHECK_TEST_POS = E7;
+const std::array<PieceType, 120> PAWN_CHECK_TEST_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK,INV,	
+	INV, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN, B_PAWN,INV, 
+	INV, NONE, NONE, NONE, W_PAWN, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, W_QUEEN, NONE, NONE, NONE,INV, 
+	INV, W_PAWN, W_PAWN, W_PAWN, NONE, W_PAWN, W_PAWN, W_PAWN, W_PAWN,INV, 
+	INV, W_ROOK, W_KNIGHT, W_BISHOP, NONE, W_KING, W_BISHOP, W_KNIGHT, W_ROOK, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+const std::unordered_set<int> PAWN_CHECK_TEST_MOVES = {E6, E5};
 
 // These boards tests for en pessent squares.
 
-const Position EN_PASSANT_SQUARE = E6;
-const Position EN_PASSANT_TEST_POS = D5;
-const std::array<PieceType, 64> EN_PASSANT_TEST_BOARD = {
-	B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK,	
-	B_PAWN, B_PAWN, B_PAWN, NONE, B_PAWN, B_PAWN, B_PAWN, B_PAWN, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, W_PAWN, B_PAWN, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	W_PAWN, W_PAWN, W_PAWN, NONE, W_PAWN, W_PAWN, W_PAWN, W_PAWN, 
-	W_ROOK, W_KNIGHT, W_BISHOP, W_QUEEN, W_KING, W_BISHOP, W_KNIGHT, W_ROOK 
-};
-const std::unordered_set<Position> EN_PASSANT_TEST_MOVES = {
+const int EN_PASSANT_SQUARE = E6;
+const int EN_PASSANT_TEST_POS = D5;
+const std::array<PieceType, 120> EN_PASSANT_TEST_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK,INV,	
+	INV, B_PAWN, B_PAWN, B_PAWN, NONE, B_PAWN, B_PAWN, B_PAWN, B_PAWN,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, W_PAWN, B_PAWN, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE,INV, 
+	INV, W_PAWN, W_PAWN, W_PAWN, NONE, W_PAWN, W_PAWN, W_PAWN, W_PAWN,INV, 
+	INV, W_ROOK, W_KNIGHT, W_BISHOP, W_QUEEN, W_KING, W_BISHOP, W_KNIGHT, W_ROOK, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+const std::unordered_set<int> EN_PASSANT_TEST_MOVES = {
 	E6, D6
 };
 
-const Position NO_EN_PASSANT_TEST_POS = D5;
-const std::array<PieceType, 64> NO_EN_PASSANT_TEST_BOARD = {
-	B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK,	
-	B_PAWN, B_PAWN, B_PAWN, NONE, B_PAWN, B_PAWN, B_PAWN, B_PAWN, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, W_PAWN, B_PAWN, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, 
-	W_PAWN, W_PAWN, W_PAWN, NONE, W_PAWN, W_PAWN, W_PAWN, W_PAWN, 
-	W_ROOK, W_KNIGHT, W_BISHOP, W_QUEEN, W_KING, W_BISHOP, W_KNIGHT, W_ROOK 
-};
-const std::unordered_set<Position> NO_EN_PASSANT_TEST_MOVES = {D6};
+const int NO_EN_PASSANT_TEST_POS = D5;
+const std::array<PieceType, 120> NO_EN_PASSANT_TEST_BOARD = {
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, B_ROOK, B_KNIGHT, B_BISHOP, B_QUEEN, B_KING, B_BISHOP, B_KNIGHT, B_ROOK, INV,	
+	INV, B_PAWN, B_PAWN, B_PAWN, NONE, B_PAWN, B_PAWN, B_PAWN, B_PAWN, INV,
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, NONE, NONE, NONE, W_PAWN, B_PAWN, NONE, NONE, NONE, INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, NONE, NONE, NONE, NONE, NONE, NONE, NONE, NONE, INV, 
+	INV, W_PAWN, W_PAWN, W_PAWN, NONE, W_PAWN, W_PAWN, W_PAWN, W_PAWN, INV, 
+	INV, W_ROOK, W_KNIGHT, W_BISHOP, W_QUEEN, W_KING, W_BISHOP, W_KNIGHT, W_ROOK, INV, 
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV, 	
+	INV, INV, INV, INV, INV, INV, INV, INV, INV, INV	
+};
+const std::unordered_set<int> NO_EN_PASSANT_TEST_MOVES = {D6};