tait
/
chess
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Make unordered_sets unto vectors

Browse Source
master
Tait Hoyem 5 years ago
parent 52ec82f7df
commit 16add284ef
11 changed files with 107 additions and 107 deletions
Show Stats Download Patch File Download Diff File

32
src/all_moves_functions.cpp
Unescape View File

@ -1,5 +1,5 @@
#include "constants.h" #include "constants.h"
#include <unordered_set> #include <vector>
#include <array> #include <array>
#include <iostream> #include <iostream>
@ -23,7 +23,7 @@ Color _rev_color(Color c){
} }
// This function will set the boolean guarding it to false if it is blocked, thus stopping it from running. // This function will set the boolean guarding it to false if it is blocked, thus stopping it from running.
void _add_if_not_blocked(int pos, int from, std::unordered_set<int> *pns, std::array<PieceType, 120> *board, Color color_of_piece, Color color_of_opposite, bool *is_not_blocked){ void _add_if_not_blocked(int pos, int from, std::vector<int> *pns, std::array<PieceType, 120> *board, Color color_of_piece, Color color_of_opposite, bool *is_not_blocked){
if (*is_not_blocked){ if (*is_not_blocked){
if (!is_valid_position(pos)){ if (!is_valid_position(pos)){
*is_not_blocked = false; *is_not_blocked = false;
@ -31,47 +31,47 @@ void _add_if_not_blocked(int pos, int from, std::unordered_set<int> *pns, std::a
if (_xy_is_color(pos, board, color_of_piece)){ if (_xy_is_color(pos, board, color_of_piece)){
*is_not_blocked = false; *is_not_blocked = false;
} else if (_xy_is_color(pos, board, color_of_opposite)){ } else if (_xy_is_color(pos, board, color_of_opposite)){
pns->insert(make_move(from, pos)); pns->push_back(make_move(from, pos));
*is_not_blocked = false; *is_not_blocked = false;
} else { } else {
pns->insert(make_move(from, pos)); pns->push_back(make_move(from, pos));
} }
} }
} }
} }
// 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) // 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, int from, std::unordered_set<int> *pns, std::array<PieceType, 120> *board, Color color_of_piece, Color color_of_opposite){ void _add_if_not_blocked(int pos, int from, std::vector<int> *pns, std::array<PieceType, 120> *board, Color color_of_piece, Color color_of_opposite){
if (!is_valid_position(pos) || if (!is_valid_position(pos) ||
_xy_is_color(pos, board, color_of_piece)){ _xy_is_color(pos, board, color_of_piece)){
return; return;
} else { } else {
pns->insert(make_move(from, pos)); pns->push_back(make_move(from, pos));
} }
} }
// This is a specialized function for the pawn's diagonal takes. // This is a specialized function for the pawn's diagonal takes.
// It will only to pns if there is a piece of opposite color on it. // It will only to pns if there is a piece of opposite color on it.
void _pawn_diag_add_if_not_blocked(int pos, int from, std::unordered_set<int> *pns, std::array<PieceType, 120> *board, Color color_of_piece, Color color_of_opposite, int en_passant){ void _pawn_diag_add_if_not_blocked(int pos, int from, std::vector<int> *pns, std::array<PieceType, 120> *board, Color color_of_piece, Color color_of_opposite, int en_passant){
if (is_valid_position(pos) && (_xy_is_color(pos, board, color_of_opposite) || if (is_valid_position(pos) && (_xy_is_color(pos, board, color_of_opposite) ||
pos == en_passant)){ pos == en_passant)){
pns->insert(make_move(from, pos)); pns->push_back(make_move(from, pos));
} }
} }
// This is a specialized functions for the pawn's inability to take going forward. // This is a specialized functions for the pawn's inability to take going forward.
// Notice the lack of insertion where there usually is when (x,y) is a different color. // Notice the lack of push_backion where there usually is when (x,y) is a different color.
void _pawn_add_if_not_blocked(int pos, int from, std::unordered_set<int> *pns, std::array<PieceType, 120> *board, Color color_of_piece, Color color_of_opposite, bool *is_not_blocked){ void _pawn_add_if_not_blocked(int pos, int from, std::vector<int> *pns, std::array<PieceType, 120> *board, Color color_of_piece, Color color_of_opposite, bool *is_not_blocked){
if (*is_not_blocked){ if (*is_not_blocked){
if ((*board)[pos] != PieceType::NONE || if ((*board)[pos] != PieceType::NONE ||
(*board)[pos] == PieceType::INV){ (*board)[pos] == PieceType::INV){
*is_not_blocked = false; *is_not_blocked = false;
} else { } else {
pns->insert(make_move(from, pos)); pns->push_back(make_move(from, pos));
} }
} }
} }
void _get_all_moves_rook(int pos, std::unordered_set<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc){ void _get_all_moves_rook(int pos, std::vector<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc){
for (int rk_off : ROOK_PIECE_OFFSETS){ for (int rk_off : ROOK_PIECE_OFFSETS){
bool* not_blocked = new bool(true); bool* not_blocked = new bool(true);
for (int offset=1; offset<8; offset++){ for (int offset=1; offset<8; offset++){
@ -93,7 +93,7 @@ void _get_all_moves_rook(int pos, std::unordered_set<int> *pns, std::array<Piece
*/ */
} }
void _get_all_moves_bishop(int pos, std::unordered_set<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc){ void _get_all_moves_bishop(int pos, std::vector<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc){
for (int bs_off : BISHOP_PIECE_OFFSETS){ for (int bs_off : BISHOP_PIECE_OFFSETS){
bool* not_blocked = new bool(true); bool* not_blocked = new bool(true);
for (int offset=1; offset<8; offset++){ for (int offset=1; offset<8; offset++){
@ -118,7 +118,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){ void _get_all_moves_knight(int pos, std::vector<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc){
for (int kn_off : KNIGHT_PIECE_OFFSETS){ for (int kn_off : KNIGHT_PIECE_OFFSETS){
bool* not_blocked = new bool(true); bool* not_blocked = new bool(true);
_add_if_not_blocked(pos+kn_off, pos, pns, board, pc, rc); _add_if_not_blocked(pos+kn_off, pos, pns, board, pc, rc);
@ -134,7 +134,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){ void _get_all_moves_king(int pos, std::vector<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc){
for (int kn_off : KING_PIECE_OFFSETS){ for (int kn_off : KING_PIECE_OFFSETS){
bool* not_blocked = new bool(true); bool* not_blocked = new bool(true);
_add_if_not_blocked(pos+kn_off, pos, pns, board, pc, rc); _add_if_not_blocked(pos+kn_off, pos, pns, board, pc, rc);
@ -153,7 +153,7 @@ void _get_all_moves_king(int pos, std::unordered_set<int> *pns, std::array<Piece
*/ */
} }
void _get_all_moves_pawn(int pos, std::unordered_set<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc, int en_passant){ void _get_all_moves_pawn(int pos, std::vector<int> *pns, std::array<PieceType, 120>* board, Color pc, Color rc, int en_passant){
// if it's white use different offsets, and pawn starting rank // if it's white use different offsets, and pawn starting rank
int offset2 = pc==Color::WHITE?-20:20; int offset2 = pc==Color::WHITE?-20:20;

2
src/bitwise.h
Unescape View File

@ -2,7 +2,7 @@
#define BITWISE_H #define BITWISE_H
#include "constants.h" #include "constants.h"
#include <unordered_set> #include <vector>
// Using macros for ease of use, can also use functons, but I don't see the point. // Using macros for ease of use, can also use functons, but I don't see the point.

24
src/functions.cpp
Unescape View File

@ -49,13 +49,13 @@ Color rev_color(Color c){
return c==Color::WHITE?Color::BLACK:Color::WHITE; return c==Color::WHITE?Color::BLACK:Color::WHITE;
} }
std::unordered_set<int> get_possible_movers(Position pn, std::array<PieceType, 120> board){ std::vector<int> get_possible_movers(Position pn, std::array<PieceType, 120> board){
std::unordered_set<int> pns = {Position::A1}; std::vector<int> pns = {Position::A1};
return pns; return pns;
} }
std::unordered_set<int> get_possible_moves(Position pn, std::array<PieceType, 120> board){ std::vector<int> get_possible_moves(Position pn, std::array<PieceType, 120> board){
std::unordered_set<int> pns = {Position::A1}; std::vector<int> pns = {Position::A1};
get_all_moves(pn, &board, &pns); get_all_moves(pn, &board, &pns);
return pns; return pns;
} }
@ -69,11 +69,11 @@ int get_pos_of(PieceType pt, std::array<PieceType, 120> const *board){
return Position::NA; return Position::NA;
} }
std::unordered_set<int> get_poss_of(PieceType pt, std::array<PieceType, 120> const *board){ std::vector<int> get_poss_of(PieceType pt, std::array<PieceType, 120> const *board){
std::unordered_set<int> results; std::vector<int> results;
for (int pn = Position::A8; pn!=Position::H1; pn++){ for (int pn = Position::A8; pn!=Position::H1; pn++){
if ((*board)[pn] == pt){ if ((*board)[pn] == pt){
results.insert(pn); results.push_back(pn);
} }
} }
return results; return results;
@ -88,7 +88,7 @@ void get_poss_of(PieceType pt, std::array<PieceType, 120>* board, std::vector<in
} }
//TODO: Make faster by running from king squar eonly, instead of running on every piece of opposite team. //TODO: Make faster by running from king squar eonly, instead of running on every piece of opposite team.
void filter_checked_moves(PieceType pt, std::array<PieceType, 120> *board, std::unordered_set<int> *pns){ void filter_checked_moves(PieceType pt, std::array<PieceType, 120> *board, std::vector<int> *pns){
PieceType my_king = is_white(pt)?PieceType::W_KING:PieceType::B_KING; PieceType my_king = is_white(pt)?PieceType::W_KING:PieceType::B_KING;
int my_king_pos = get_pos_of(my_king, board); int my_king_pos = get_pos_of(my_king, board);
int attackers = 0; int attackers = 0;
@ -110,7 +110,7 @@ void filter_checked_moves(PieceType pt, std::array<PieceType, 120> *board, std::
std::vector<int> psns; std::vector<int> psns;
get_poss_of(other_p, &moved_board, &psns); get_poss_of(other_p, &moved_board, &psns);
for (auto psn : psns){ for (auto psn : psns){
std::unordered_set<int> other_moves; std::vector<int> other_moves;
get_all_moves(psn, &moved_board, &other_moves, false); get_all_moves(psn, &moved_board, &other_moves, false);
// for every position the piece can mvoe to // for every position the piece can mvoe to
for (int cp : other_moves){ for (int cp : other_moves){
@ -136,7 +136,7 @@ void filter_checked_moves(PieceType pt, std::array<PieceType, 120> *board, std::
} }
} }
void get_all_moves(int pos, std::array<PieceType, 120>* board, std::unordered_set<int>* moves, bool recursive, int en_passant){ void get_all_moves(int pos, std::array<PieceType, 120>* board, std::vector<int>* moves, bool recursive, int en_passant){
PieceType pt = (*board)[pos]; PieceType pt = (*board)[pos];
Color color_of_piece = get_color(pt); Color color_of_piece = get_color(pt);
Color color_of_opponent = rev_color(color_of_piece); Color color_of_opponent = rev_color(color_of_piece);
@ -174,8 +174,8 @@ void get_all_moves(int pos, std::array<PieceType, 120>* board, std::unordered_se
} }
} }
std::unordered_set<int> get_all_moves(int pos, std::array<PieceType, 120> board, bool recursive, int en_passant){ std::vector<int> get_all_moves(int pos, std::array<PieceType, 120> board, bool recursive, int en_passant){
std::unordered_set<int> moves; std::vector<int> moves;
get_all_moves(pos, &board, &moves, recursive, en_passant); get_all_moves(pos, &board, &moves, recursive, en_passant);
return moves; return moves;
} }

14
src/functions.h
Unescape View File

@ -1,12 +1,12 @@
#include "constants.h" #include "constants.h"
#include <unordered_set> #include <vector>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <math.h> #include <math.h>
// Returns a list of positions with PieceType pt // Returns a list of positions with PieceType pt
int get_pos_of(PieceType pt, std::array<PieceType, 120> const *board); 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); std::vector<int> get_poss_of(PieceType pt, std::array<PieceType, 120> const *board);
// Convert a Position number into a pair of x y coordiinates // Convert a Position number into a pair of x y coordiinates
std::pair<int, int> pos_to_pair(Position pn); std::pair<int, int> pos_to_pair(Position pn);
@ -32,18 +32,18 @@ Color rev_color(Color c);
// Get all positions of pieces which can move to this square // Get all positions of pieces which can move to this square
// This may require helper functions for each individual peice. // This may require helper functions for each individual peice.
// TODO rename to something less stupid. // TODO rename to something less stupid.
void get_possible_movers(Position pn, std::array<PieceType, 120> *pt,std::unordered_set<int> *moves); void get_possible_movers(Position pn, std::array<PieceType, 120> *pt,std::vector<int> *moves);
// Get all possible moved for piece in Position pn. // Get all possible moved for piece in Position pn.
// This may require helper functions for each individual piece. // 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); void get_possible_moves(Position pn, std::array<PieceType, 120> *pt,std::vector<int> *moves);
// This functions removes moves that put your own king in check. // 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); void filter_checked_moves(int pos, std::array<PieceType, 120> *board, std::vector<int> *moves);
// Get all moves for piece in Position pn. // Get all moves for piece in Position pn.
void get_all_moves(int pos, 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::vector<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); std::vector<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. // Dumb function to do board moves.
// Does not check if move is valid, just does it. // Does not check if move is valid, just does it.

20
tests/B_test_boards.h
Unescape View File

@ -1,4 +1,4 @@
#include <unordered_set> #include <vector>
#include <constants.h> #include <constants.h>
const int B_QUEEN_POS = E4; const int B_QUEEN_POS = E4;
@ -17,7 +17,7 @@ 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
}; };
const std::unordered_set<int> B_QUEEN_ALL_MOVES = { const std::vector<int> B_QUEEN_ALL_MOVES = {
A8, E8, A8, E8,
B7, E7, H7, B7, E7, H7,
C6, E6, G6, C6, E6, G6,
@ -44,7 +44,7 @@ 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
}; };
const std::unordered_set<int> B_BISHOP_ALL_MOVES = { const std::vector<int> B_BISHOP_ALL_MOVES = {
H8, H8,
A7, G7, A7, G7,
B6, F6, B6, F6,
@ -70,7 +70,7 @@ 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
}; };
const std::unordered_set<int> B_KNIGHT_ALL_MOVES = { const std::vector<int> B_KNIGHT_ALL_MOVES = {
C7, E7, C7, E7,
B6, F6, B6, F6,
B4, F4, B4, F4,
@ -93,7 +93,7 @@ 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
}; };
const std::unordered_set<int> B_ROOK_ALL_MOVES = { const std::vector<int> B_ROOK_ALL_MOVES = {
E8, E7, E6, E8, E7, E6,
A5, B5, C5, D5, F5, G5, H5, A5, B5, C5, D5, F5, G5, H5,
E4, E3, E2, E1 E4, E3, E2, E1
@ -116,7 +116,7 @@ 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
}; };
const std::unordered_set<int> B_KING_ALL_MOVES = { const std::vector<int> B_KING_ALL_MOVES = {
B5, C5, D5, B5, C5, D5,
B4, D4, B4, D4,
B3, C3, D3 B3, C3, D3
@ -139,7 +139,7 @@ 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
}; };
const std::unordered_set<int> B_PAWN_ALL_MOVES = { const std::vector<int> B_PAWN_ALL_MOVES = {
F3 F3
}; };
const int B_KNIGHT_SIDE1_POS = B7; const int B_KNIGHT_SIDE1_POS = B7;
@ -157,7 +157,7 @@ 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, 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 = { const std::vector<int> B_KNIGHT_SIDE1_ALL_MOVES = {
D8, D8,
D6, D6,
A5, C5 A5, C5
@ -177,7 +177,7 @@ 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, 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 = { const std::vector<int> B_KING_SIDE1_ALL_MOVES = {
B8, B8,
A7,B7 A7,B7
}; };
@ -197,6 +197,6 @@ 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, 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 = { const std::vector<int> B_PAWN_SIDE1_ALL_MOVES = {
A6, A5 A6, A5
}; };

20
tests/W_test_boards.h
Unescape View File

@ -1,4 +1,4 @@
#include <unordered_set> #include <vector>
#include <constants.h> #include <constants.h>
const int W_QUEEN_POS = E4; const int W_QUEEN_POS = E4;
@ -32,7 +32,7 @@ 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
}; };
const std::unordered_set<int> W_QUEEN_ALL_MOVES = { const std::vector<int> W_QUEEN_ALL_MOVES = {
A8, E8, A8, E8,
B7, E7, H7, B7, E7, H7,
C6, E6, G6, C6, E6, G6,
@ -59,7 +59,7 @@ 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
}; };
const std::unordered_set<int> W_BISHOP_ALL_MOVES = { const std::vector<int> W_BISHOP_ALL_MOVES = {
H8, H8,
A7, G7, A7, G7,
B6, F6, B6, F6,
@ -100,13 +100,13 @@ 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, 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 = { const std::vector<int> W_KNIGHT_SIDE1_ALL_MOVES = {
D8, D8,
D6, D6,
A5, C5 A5, C5
}; };
const std::unordered_set<int> W_KNIGHT_ALL_MOVES = { const std::vector<int> W_KNIGHT_ALL_MOVES = {
C7, E7, C7, E7,
B6, F6, B6, F6,
B4, F4, B4, F4,
@ -129,7 +129,7 @@ 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
}; };
const std::unordered_set<int> W_ROOK_ALL_MOVES = { const std::vector<int> W_ROOK_ALL_MOVES = {
E8, E7, E6, E8, E7, E6,
A5, B5, C5, D5, F5, G5, H5, A5, B5, C5, D5, F5, G5, H5,
E4, E3, E2, E1 E4, E3, E2, E1
@ -168,12 +168,12 @@ 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
}; };
const std::unordered_set<int> W_KING_SIDE1_ALL_MOVES = { const std::vector<int> W_KING_SIDE1_ALL_MOVES = {
B8, B8,
A7,B7 A7,B7
}; };
const std::unordered_set<int> W_KING_ALL_MOVES = { const std::vector<int> W_KING_ALL_MOVES = {
B5, C5, D5, B5, C5, D5,
B4, D4, B4, D4,
B3, C3, D3 B3, C3, D3
@ -196,7 +196,7 @@ 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
}; };
const std::unordered_set<int> W_PAWN_ALL_MOVES = { const std::vector<int> W_PAWN_ALL_MOVES = {
F5 F5
}; };
@ -215,4 +215,4 @@ 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, 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; const std::vector<int> W_PAWN_SIDE1_ALL_MOVES;

6
tests/custom_printing.cpp
Unescape View File

@ -1,7 +1,7 @@
#include "catch.hpp" #include "catch.hpp"
#include <constants.h> #include <constants.h>
#include <sstream> #include <sstream>
#include <unordered_set> #include <vector>
// override default printing for Positions so it prints the value (e.g. 32), then, in parenthasies, the location (e.g. A4). // override default printing for Positions so it prints the value (e.g. 32), then, in parenthasies, the location (e.g. A4).
// Example: A4(32) // Example: A4(32)
@ -44,8 +44,8 @@ namespace Catch {
}; };
// 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. // 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<> template<>
struct StringMaker<std::unordered_set<int>> { struct StringMaker<std::vector<int>> {
static std::string convert(std::unordered_set<int> const& uo_poss){ static std::string convert(std::vector<int> const& uo_poss){
std::vector<int> poss(uo_poss.begin(), uo_poss.end()); std::vector<int> poss(uo_poss.begin(), uo_poss.end());
std::stringstream ss; std::stringstream ss;
std::string files = " A B C D E F G H"; std::string files = " A B C D E F G H";

6
tests/main.cpp
Unescape View File

@ -22,8 +22,8 @@ const std::array<PieceType, 120> DUMB_MOVE_1 = {
}; };
TEST_CASE("Test that the get_to_squares works, this is required!", "[get_to_squares]"){ TEST_CASE("Test that the get_to_squares works, this is required!", "[get_to_squares]"){
std::unordered_set<int> to_squares = {Position::H1}; std::vector<int> to_squares = {Position::H1};
std::unordered_set<int> moves = {0b11000100000000}; std::vector<int> moves = {0b11000100000000};
REQUIRE(get_to_squares(moves) == to_squares); REQUIRE(get_to_squares(moves) == to_squares);
} }
@ -107,7 +107,7 @@ TEST_CASE("Test that moves that put king in check are not returned", "[get_all_m
CHECK(get_to_squares(get_all_moves(ROOK_CHECK_TEST_POS, ROOK_CHECK_TEST_BOARD)) == ROOK_CHECK_TEST_MOVES); CHECK(get_to_squares(get_all_moves(ROOK_CHECK_TEST_POS, ROOK_CHECK_TEST_BOARD)) == ROOK_CHECK_TEST_MOVES);
CHECK(get_to_squares(get_all_moves(PAWN_CHECK_TEST_POS, PAWN_CHECK_TEST_BOARD)) == PAWN_CHECK_TEST_MOVES); CHECK(get_to_squares(get_all_moves(PAWN_CHECK_TEST_POS, PAWN_CHECK_TEST_BOARD)) == PAWN_CHECK_TEST_MOVES);
auto pawn_diag_moves = get_all_moves(PAWN_DIAG_TEST1_POS, PAWN_DIAG_TEST1_BOARD); auto pawn_diag_moves = get_all_moves(PAWN_DIAG_TEST1_POS, PAWN_DIAG_TEST1_BOARD);
std::unordered_set<int> pawn_start_flags = {0, 1, 0}; std::vector<int> pawn_start_flags = {0, 1, 0};
CHECK(get_to_squares(pawn_diag_moves) == PAWN_DIAG_TEST1_MOVES); CHECK(get_to_squares(pawn_diag_moves) == PAWN_DIAG_TEST1_MOVES);
CHECK(get_pawn_start_flags(pawn_diag_moves) == pawn_start_flags); CHECK(get_pawn_start_flags(pawn_diag_moves) == pawn_start_flags);
} }

44
tests/test_functions.cpp
Unescape View File

@ -1,55 +1,55 @@
#include "test_functions.h" #include "test_functions.h"
#include <bitwise.h> #include <bitwise.h>
#include <unordered_set> #include <vector>
#include <algorithm> #include <algorithm>
std::unordered_set<int> get_to_squares(std::unordered_set<int> moves){ std::vector<int> get_to_squares(std::vector<int> moves){
std::unordered_set<int> transformed; std::vector<int> transformed;
for (int mv : moves){ for (int mv : moves){
transformed.insert(get_to_sq(mv)); transformed.push_back(get_to_sq(mv));
} }
return transformed; return transformed;
} }
std::unordered_set<int> get_from_squared(std::unordered_set<int> moves){ std::vector<int> get_from_squared(std::vector<int> moves){
std::unordered_set<int> transformed; std::vector<int> transformed;
for (int mv : moves){ for (int mv : moves){
transformed.insert(get_from_sq(mv)); transformed.push_back(get_from_sq(mv));
} }
return transformed; return transformed;
} }
std::unordered_set<int> get_captured_pieces(std::unordered_set<int> moves){ std::vector<int> get_captured_pieces(std::vector<int> moves){
std::unordered_set<int> transformed; std::vector<int> transformed;
for (int mv : moves){ for (int mv : moves){
transformed.insert(get_captured_pc(mv)); transformed.push_back(get_captured_pc(mv));
} }
return transformed; return transformed;
} }
std::unordered_set<int> get_promoted_pieces(std::unordered_set<int> moves){ std::vector<int> get_promoted_pieces(std::vector<int> moves){
std::unordered_set<int> transformed; std::vector<int> transformed;
for (int mv : moves){ for (int mv : moves){
transformed.insert(get_promoted_to_pc(mv)); transformed.push_back(get_promoted_to_pc(mv));
} }
return transformed; return transformed;
} }
std::unordered_set<int> get_en_passant_flags(std::unordered_set<int> moves){ std::vector<int> get_en_passant_flags(std::vector<int> moves){
std::unordered_set<int> transformed; std::vector<int> transformed;
for (int mv : moves){ for (int mv : moves){
transformed.insert(get_en_pass_flag(mv)); transformed.push_back(get_en_pass_flag(mv));
} }
return transformed; return transformed;
} }
std::unordered_set<int> get_pawn_start_flags(std::unordered_set<int> moves){ std::vector<int> get_pawn_start_flags(std::vector<int> moves){
std::unordered_set<int> transformed; std::vector<int> transformed;
for (int mv : moves){ for (int mv : moves){
std::cout << "MOVE: \n"; std::cout << "MOVE: \n";
transformed.insert(get_pawn_st_flag(mv)); transformed.push_back(get_pawn_st_flag(mv));
} }
return transformed; return transformed;
} }
std::unordered_set<int> get_castle_flags(std::unordered_set<int> moves){ std::vector<int> get_castle_flags(std::vector<int> moves){
std::unordered_set<int> transformed; std::vector<int> transformed;
for (int mv : moves){ for (int mv : moves){
transformed.insert(get_castle_flag(mv)); transformed.push_back(get_castle_flag(mv));
} }
return transformed; return transformed;
} }

16
tests/test_functions.h
Unescape View File

@ -1,12 +1,12 @@
#ifndef TEST_FUNCTIONS_H #ifndef TEST_FUNCTIONS_H
#define TEST_FUNCTOPMS_H #define TEST_FUNCTOPMS_H
#include <unordered_set> #include <vector>
std::unordered_set<int> get_from_squares(std::unordered_set<int> moves); std::vector<int> get_from_squares(std::vector<int> moves);
std::unordered_set<int> get_to_squares(std::unordered_set<int> moves); std::vector<int> get_to_squares(std::vector<int> moves);
std::unordered_set<int> get_captured_pieces(std::unordered_set<int> moves); std::vector<int> get_captured_pieces(std::vector<int> moves);
std::unordered_set<int> get_promoted_pieces(std::unordered_set<int> moves); std::vector<int> get_promoted_pieces(std::vector<int> moves);
std::unordered_set<int> get_en_passant_flags(std::unordered_set<int> moves); std::vector<int> get_en_passant_flags(std::vector<int> moves);
std::unordered_set<int> get_pawn_start_flags(std::unordered_set<int> moves); std::vector<int> get_pawn_start_flags(std::vector<int> moves);
std::unordered_set<int> get_castle_flags(std::unordered_set<int> moves); std::vector<int> get_castle_flags(std::vector<int> moves);
#endif #endif

30
tests/valid_moves.h
Unescape View File

@ -1,21 +1,21 @@
#include <unordered_set> #include <vector>
#include <constants.h> #include <constants.h>
/// This is for possible moves on a default board /// This is for possible moves on a default board
const std::unordered_set<int> DEFAULT_B_A_PAWN_POSSIBLE_MOVES = { const std::vector<int> DEFAULT_B_A_PAWN_POSSIBLE_MOVES = {
A6, A5 A6, A5
}; };
const std::unordered_set<int> DEFAULT_W_A_PAWN_POSSIBLE_MOVES = { const std::vector<int> DEFAULT_W_A_PAWN_POSSIBLE_MOVES = {
A3, A4 A3, A4
}; };
const std::unordered_set<int> DEFAULT_W_R_KNIGHT_POSSIBLE_MOVES = { const std::vector<int> DEFAULT_W_R_KNIGHT_POSSIBLE_MOVES = {
H3, F3 H3, F3
}; };
// EMPTY // EMPTY
const std::unordered_set<int> DEFAULT_W_R_ROOK_POSSIBLE_MOVES = {}; const std::vector<int> DEFAULT_W_R_ROOK_POSSIBLE_MOVES = {};
const std::unordered_set<int> B_PAWNS_SQUARES = { const std::vector<int> B_PAWNS_SQUARES = {
A7, B7, C7, D7, E7, F7, G7, H7 A7, B7, C7, D7, E7, F7, G7, H7
}; };
@ -37,7 +37,7 @@ 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
}; };
// Should NOT inclde D7 // Should NOT inclde D7
const std::unordered_set<int> KNIGHT_BLOCKED1_MOVES = { const std::vector<int> KNIGHT_BLOCKED1_MOVES = {
A6, C6 A6, C6
}; };
@ -57,7 +57,7 @@ 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
}; };
// Should NOT include A8, H8, G2, or H1 // Should NOT include A8, H8, G2, or H1
const std::unordered_set<int> BISHOP_BLOCKED1_MOVES = { const std::vector<int> BISHOP_BLOCKED1_MOVES = {
B7, B7,
C6,E6, C6,E6,
C4,E4, C4,E4,
@ -65,7 +65,7 @@ const std::unordered_set<int> BISHOP_BLOCKED1_MOVES = {
A2 A2
}; };
// Should NOT include B2 (black queen) as it is obstructed by the bishop on D5 // Should NOT include B2 (black queen) as it is obstructed by the bishop on D5
const std::unordered_set<int> BISHOP_BLOCKED1_CAN_MOVE_TO_B_KING = { const std::vector<int> BISHOP_BLOCKED1_CAN_MOVE_TO_B_KING = {
D5 D5
}; };
const int BISHOP_BLOCKED1_KING_POS = F3; const int BISHOP_BLOCKED1_KING_POS = F3;
@ -87,7 +87,7 @@ 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
}; };
// Should NOT include E-H2 or B3-1 // Should NOT include E-H2 or B3-1
const std::unordered_set<int> ROOK_BLOCKED1_MOVES = { const std::vector<int> ROOK_BLOCKED1_MOVES = {
B8, B8,
A7, C7, D7, A7, C7, D7,
B6,B5,B4 B6,B5,B4
@ -108,7 +108,7 @@ 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, 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 = { const std::vector<int> PAWN_DIAG_TEST1_MOVES = {
D6, E6, E5 D6, E6, E5
}; };
@ -128,7 +128,7 @@ 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, 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 = { const std::vector<int> ROOK_CHECK_TEST_MOVES = {
C5, E5 C5, E5
}; };
@ -147,7 +147,7 @@ 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, 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}; const std::vector<int> PAWN_CHECK_TEST_MOVES = {E6, E5};
// These boards tests for en pessent squares. // These boards tests for en pessent squares.
@ -167,7 +167,7 @@ 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, 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 = { const std::vector<int> EN_PASSANT_TEST_MOVES = {
E6, D6 E6, D6
}; };
@ -186,4 +186,4 @@ 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, 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}; const std::vector<int> NO_EN_PASSANT_TEST_MOVES = {D6};

Write Preview
Loading…
Cancel
Save