diff --git a/src/bitbase.cpp b/src/bitbase.cpp index 5d20fbc6..0c3230f2 100644 --- a/src/bitbase.cpp +++ b/src/bitbase.cpp @@ -17,20 +17,10 @@ along with this program. If not, see . */ - -//// -//// Includes -//// - #include #include "bitboard.h" -#include "square.h" - - -//// -//// Local definitions -//// +#include "types.h" namespace { @@ -63,10 +53,6 @@ namespace { } -//// -//// Functions -//// - void generate_kpk_bitbase(uint8_t bitbase[]) { bool repeat; diff --git a/src/bitboard.h b/src/bitboard.h index d846765b..b962226b 100644 --- a/src/bitboard.h +++ b/src/bitboard.h @@ -21,8 +21,6 @@ #if !defined(BITBOARD_H_INCLUDED) #define BITBOARD_H_INCLUDED -#include "piece.h" -#include "square.h" #include "types.h" const Bitboard EmptyBoardBB = 0; diff --git a/src/bitcount.h b/src/bitcount.h index 2e417e04..199fcf19 100644 --- a/src/bitcount.h +++ b/src/bitcount.h @@ -18,7 +18,6 @@ along with this program. If not, see . */ - #if !defined(BITCOUNT_H_INCLUDED) #define BITCOUNT_H_INCLUDED diff --git a/src/depth.h b/src/depth.h deleted file mode 100644 index 4b9e0753..00000000 --- a/src/depth.h +++ /dev/null @@ -1,43 +0,0 @@ -/* - Stockfish, a UCI chess playing engine derived from Glaurung 2.1 - Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad - - Stockfish is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - Stockfish is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -*/ - - -#if !defined(DEPTH_H_INCLUDED) -#define DEPTH_H_INCLUDED - -#include "types.h" - -//// -//// Types -//// - -enum Depth { - - ONE_PLY = 2, - - DEPTH_ZERO = 0 * ONE_PLY, - DEPTH_QS_CHECKS = -1 * ONE_PLY, - DEPTH_QS_NO_CHECKS = -2 * ONE_PLY, - - DEPTH_NONE = -127 * ONE_PLY -}; - -ENABLE_OPERATORS_ON(Depth) - -#endif // !defined(DEPTH_H_INCLUDED) diff --git a/src/endgame.h b/src/endgame.h index 94654ca8..ceb93efa 100644 --- a/src/endgame.h +++ b/src/endgame.h @@ -17,21 +17,11 @@ along with this program. If not, see . */ - #if !defined(ENDGAME_H_INCLUDED) #define ENDGAME_H_INCLUDED -//// -//// Includes -//// - #include "position.h" -#include "value.h" - - -//// -//// Types -//// +#include "types.h" enum EndgameType { @@ -94,11 +84,4 @@ struct ScalingFunction : public EndgameScalingFunctionBase { ScaleFactor apply(const Position&) const; }; - -//// -//// Prototypes -//// - -extern void init_bitbases(); - #endif // !defined(ENDGAME_H_INCLUDED) diff --git a/src/evaluate.h b/src/evaluate.h index a3347022..4198ca56 100644 --- a/src/evaluate.h +++ b/src/evaluate.h @@ -17,12 +17,10 @@ along with this program. If not, see . */ - #if !defined(EVALUATE_H_INCLUDED) #define EVALUATE_H_INCLUDED -#include "piece.h" -#include "value.h" +#include "types.h" class Position; diff --git a/src/history.h b/src/history.h index 0459c8fb..c265777b 100644 --- a/src/history.h +++ b/src/history.h @@ -21,12 +21,7 @@ #define HISTORY_H_INCLUDED #include - -#include "depth.h" -#include "piece.h" -#include "square.h" -#include "value.h" - +#include "types.h" /// The History class stores statistics about how often different moves /// have been successful or unsuccessful during the current search. These diff --git a/src/lock.h b/src/lock.h index 9bf59afa..939b7da0 100644 --- a/src/lock.h +++ b/src/lock.h @@ -17,11 +17,9 @@ along with this program. If not, see . */ - #if !defined(LOCK_H_INCLUDED) #define LOCK_H_INCLUDED - #if !defined(_MSC_VER) # include diff --git a/src/main.cpp b/src/main.cpp index a1dd0790..86c7558c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -20,23 +20,13 @@ // To profile with callgrind uncomment following line //#define USE_CALLGRIND - -//// -//// Includes -//// - #include #include #include #include "bitboard.h" -#include "bitcount.h" -#include "endgame.h" #include "evaluate.h" -#include "material.h" -#include "misc.h" #include "position.h" -#include "search.h" #include "thread.h" #include "ucioption.h" @@ -48,10 +38,7 @@ using namespace std; extern bool execute_uci_command(const string& cmd); extern void benchmark(int argc, char* argv[]); - -//// -//// Functions -//// +extern void init_bitbases(); int main(int argc, char* argv[]) { diff --git a/src/material.h b/src/material.h index d039dbbf..9992c0b7 100644 --- a/src/material.h +++ b/src/material.h @@ -17,23 +17,13 @@ along with this program. If not, see . */ - #if !defined(MATERIAL_H_INCLUDED) #define MATERIAL_H_INCLUDED -//// -//// Includes -//// - #include "endgame.h" #include "position.h" #include "tt.h" - -//// -//// Types -//// - const int MaterialTableSize = 1024; /// MaterialInfo is a class which contains various information about a @@ -83,11 +73,6 @@ private: }; -//// -//// Inline functions -//// - - /// MaterialInfo::material_value simply returns the material balance /// evaluation that is independent from game phase. @@ -96,6 +81,7 @@ inline Score MaterialInfo::material_value() const { return make_score(value, value); } + /// MaterialInfo::scale_factor takes a position and a color as input, and /// returns a scale factor for the given color. We have to provide the /// position in addition to the color, because the scale factor need not @@ -123,6 +109,7 @@ inline int MaterialInfo::space_weight() const { return spaceWeight; } + /// MaterialInfo::game_phase() returns the game phase according /// to this material configuration. diff --git a/src/misc.h b/src/misc.h index 55f4afde..0c4bd644 100644 --- a/src/misc.h +++ b/src/misc.h @@ -21,7 +21,6 @@ #define MISC_H_INCLUDED #include - #include "types.h" extern const std::string engine_name(); diff --git a/src/move.h b/src/move.h index 928bb9e4..ada89a4e 100644 --- a/src/move.h +++ b/src/move.h @@ -23,9 +23,7 @@ #include #include "misc.h" -#include "piece.h" -#include "square.h" -#include "value.h" +#include "types.h" // Maximum number of allowed moves per position const int MOVES_MAX = 256; diff --git a/src/movegen.cpp b/src/movegen.cpp index 018b770b..0056ce38 100644 --- a/src/movegen.cpp +++ b/src/movegen.cpp @@ -17,16 +17,10 @@ along with this program. If not, see . */ - -//// -//// Includes -//// - #include #include "bitcount.h" #include "movegen.h" -#include "types.h" // Simple macro to wrap a very common while loop, no facny, no flexibility, // hardcoded list name 'mlist' and from square 'from'. @@ -35,10 +29,6 @@ // Version used for pawns, where the 'from' square is given as a delta from the 'to' square #define SERIALIZE_MOVES_D(b, d) while (b) { to = pop_1st_bit(&b); (*mlist++).move = make_move(to + (d), to); } -//// -//// Local definitions -//// - namespace { enum CastlingSide { diff --git a/src/movegen.h b/src/movegen.h index 35fda92a..4bb44331 100644 --- a/src/movegen.h +++ b/src/movegen.h @@ -17,7 +17,6 @@ along with this program. If not, see . */ - #if !defined(MOVEGEN_H_INCLUDED) #define MOVEGEN_H_INCLUDED diff --git a/src/movepick.cpp b/src/movepick.cpp index a7e5bdac..3bc85556 100644 --- a/src/movepick.cpp +++ b/src/movepick.cpp @@ -24,7 +24,7 @@ #include "movegen.h" #include "movepick.h" #include "search.h" -#include "value.h" +#include "types.h" namespace { diff --git a/src/movepick.h b/src/movepick.h index ad76085b..04e5fb5e 100644 --- a/src/movepick.h +++ b/src/movepick.h @@ -20,9 +20,9 @@ #if !defined MOVEPICK_H_INCLUDED #define MOVEPICK_H_INCLUDED -#include "depth.h" #include "history.h" #include "position.h" +#include "types.h" struct SearchStack; diff --git a/src/pawns.h b/src/pawns.h index 77a09f29..549aafa9 100644 --- a/src/pawns.h +++ b/src/pawns.h @@ -17,23 +17,13 @@ along with this program. If not, see . */ - #if !defined(PAWNS_H_INCLUDED) #define PAWNS_H_INCLUDED -//// -//// Includes -//// - #include "bitboard.h" #include "position.h" #include "tt.h" -#include "value.h" - - -//// -//// Types -//// +#include "types.h" const int PawnTableSize = 16384; @@ -88,11 +78,6 @@ private: Score evaluate_pawns(const Position& pos, Bitboard ourPawns, Bitboard theirPawns, PawnInfo* pi) const; }; - -//// -//// Inline functions -//// - inline Square pawn_push(Color c) { return c == WHITE ? DELTA_N : DELTA_S; } diff --git a/src/piece.h b/src/piece.h deleted file mode 100644 index 341e877d..00000000 --- a/src/piece.h +++ /dev/null @@ -1,93 +0,0 @@ -/* - Stockfish, a UCI chess playing engine derived from Glaurung 2.1 - Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad - - Stockfish is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - Stockfish is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -*/ - -#if !defined(PIECE_H_INCLUDED) -#define PIECE_H_INCLUDED - -#include "value.h" - -enum PieceType { - PIECE_TYPE_NONE = 0, - PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6 -}; - -enum Piece { - PIECE_NONE_DARK_SQ = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6, - BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16 -}; - -enum Color { - WHITE, BLACK, COLOR_NONE -}; - -ENABLE_OPERATORS_ON(PieceType) -ENABLE_OPERATORS_ON(Piece) -ENABLE_OPERATORS_ON(Color) - -/// Important: If the material values are changed, one must also -/// adjust the piece square tables, and the method game_phase() in the -/// Position class! -/// -/// Values modified by Joona Kiiski - -const Value PawnValueMidgame = Value(0x0C6); -const Value PawnValueEndgame = Value(0x102); -const Value KnightValueMidgame = Value(0x331); -const Value KnightValueEndgame = Value(0x34E); -const Value BishopValueMidgame = Value(0x344); -const Value BishopValueEndgame = Value(0x359); -const Value RookValueMidgame = Value(0x4F6); -const Value RookValueEndgame = Value(0x4FE); -const Value QueenValueMidgame = Value(0x9D9); -const Value QueenValueEndgame = Value(0x9FE); - -inline Piece make_piece(Color c, PieceType pt) { - return Piece((int(c) << 3) | int(pt)); -} - -inline PieceType type_of_piece(Piece p) { - return PieceType(int(p) & 7); -} - -inline Color color_of_piece(Piece p) { - return Color(int(p) >> 3); -} - -inline Color opposite_color(Color c) { - return Color(int(c) ^ 1); -} - -inline bool color_is_ok(Color c) { - return c == WHITE || c == BLACK; -} - -inline bool piece_type_is_ok(PieceType pt) { - return pt >= PAWN && pt <= KING; -} - -inline bool piece_is_ok(Piece p) { - return piece_type_is_ok(type_of_piece(p)) && color_is_ok(color_of_piece(p)); -} - -inline char piece_type_to_char(PieceType pt) { - static const char ch[] = " PNBRQK"; - return ch[pt]; -} - -#endif // !defined(PIECE_H_INCLUDED) diff --git a/src/position.h b/src/position.h index 91604e94..7392b9ea 100644 --- a/src/position.h +++ b/src/position.h @@ -22,9 +22,7 @@ #include "bitboard.h" #include "move.h" -#include "piece.h" -#include "square.h" -#include "value.h" +#include "types.h" /// Maximum number of plies per game (220 should be enough, because the /// maximum search depth is 100, and during position setup we reset the diff --git a/src/psqtab.h b/src/psqtab.h index 2ae17cd1..f56ba9cc 100644 --- a/src/psqtab.h +++ b/src/psqtab.h @@ -17,15 +17,10 @@ along with this program. If not, see . */ - #if !defined(PSQTAB_H_INCLUDED) #define PSQTAB_H_INCLUDED -//// -//// Includes -//// - -#include "value.h" +#include "types.h" namespace { diff --git a/src/rkiss.h b/src/rkiss.h index d197c02d..924b6c65 100644 --- a/src/rkiss.h +++ b/src/rkiss.h @@ -39,18 +39,8 @@ #if !defined(RKISS_H_INCLUDED) #define RKISS_H_INCLUDED - -//// -//// Includes -//// - #include "types.h" - -//// -//// Types -//// - class RKISS { // Keep variables always together diff --git a/src/search.h b/src/search.h index 1940c1b5..9d3fb4ca 100644 --- a/src/search.h +++ b/src/search.h @@ -17,31 +17,15 @@ along with this program. If not, see . */ - #if !defined(SEARCH_H_INCLUDED) #define SEARCH_H_INCLUDED -//// -//// Includes -//// - -#include "depth.h" #include "move.h" -#include "value.h" - - -//// -//// Constants -//// +#include "types.h" const int PLY_MAX = 100; const int PLY_MAX_PLUS_2 = PLY_MAX + 2; - -//// -//// Types -//// - /// The SearchStack struct keeps track of the information we need to remember /// from nodes shallower and deeper in the tree during the search. Each /// search thread has its own array of SearchStack objects, indexed by the @@ -62,10 +46,6 @@ struct SearchStack { SplitPoint* sp; }; - -//// -//// Prototypes -//// class Position; extern void init_search(); diff --git a/src/square.h b/src/square.h deleted file mode 100644 index 05be4bed..00000000 --- a/src/square.h +++ /dev/null @@ -1,155 +0,0 @@ -/* - Stockfish, a UCI chess playing engine derived from Glaurung 2.1 - Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad - - Stockfish is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - Stockfish is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -*/ - -#if !defined(SQUARE_H_INCLUDED) -#define SQUARE_H_INCLUDED - -#include // for abs() -#include - -#include "misc.h" -#include "piece.h" - -enum Square { - SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1, - SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2, - SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3, - SQ_A4, SQ_B4, SQ_C4, SQ_D4, SQ_E4, SQ_F4, SQ_G4, SQ_H4, - SQ_A5, SQ_B5, SQ_C5, SQ_D5, SQ_E5, SQ_F5, SQ_G5, SQ_H5, - SQ_A6, SQ_B6, SQ_C6, SQ_D6, SQ_E6, SQ_F6, SQ_G6, SQ_H6, - SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7, - SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8, - SQ_NONE, - - DELTA_N = 8, - DELTA_E = 1, - DELTA_S = -8, - DELTA_W = -1, - - DELTA_NN = DELTA_N + DELTA_N, - DELTA_NE = DELTA_N + DELTA_E, - DELTA_SE = DELTA_S + DELTA_E, - DELTA_SS = DELTA_S + DELTA_S, - DELTA_SW = DELTA_S + DELTA_W, - DELTA_NW = DELTA_N + DELTA_W -}; - -enum File { - FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H -}; - -enum Rank { - RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8 -}; - -enum SquareColor { - DARK, LIGHT -}; - -ENABLE_OPERATORS_ON(Square) -ENABLE_OPERATORS_ON(File) -ENABLE_OPERATORS_ON(Rank) - -inline Square make_square(File f, Rank r) { - return Square((int(r) << 3) | int(f)); -} - -inline File square_file(Square s) { - return File(int(s) & 7); -} - -inline Rank square_rank(Square s) { - return Rank(int(s) >> 3); -} - -inline Square flip_square(Square s) { - return Square(int(s) ^ 56); -} - -inline Square flop_square(Square s) { - return Square(int(s) ^ 7); -} - -inline Square relative_square(Color c, Square s) { - return Square(int(s) ^ (int(c) * 56)); -} - -inline Rank relative_rank(Color c, Rank r) { - return Rank(int(r) ^ (int(c) * 7)); -} - -inline Rank relative_rank(Color c, Square s) { - return relative_rank(c, square_rank(s)); -} - -inline SquareColor square_color(Square s) { - return SquareColor(int(square_rank(s) + s) & 1); -} - -inline bool opposite_color_squares(Square s1, Square s2) { - int s = int(s1) ^ int(s2); - return ((s >> 3) ^ s) & 1; -} - -inline int file_distance(Square s1, Square s2) { - return abs(square_file(s1) - square_file(s2)); -} - -inline int rank_distance(Square s1, Square s2) { - return abs(square_rank(s1) - square_rank(s2)); -} - -inline int square_distance(Square s1, Square s2) { - return Max(file_distance(s1, s2), rank_distance(s1, s2)); -} - -inline File file_from_char(char c) { - return File(c - 'a') + FILE_A; -} - -inline char file_to_char(File f) { - return char(f - FILE_A + int('a')); -} - -inline Rank rank_from_char(char c) { - return Rank(c - '1') + RANK_1; -} - -inline char rank_to_char(Rank r) { - return char(r - RANK_1 + int('1')); -} - -inline const std::string square_to_string(Square s) { - char ch[] = { file_to_char(square_file(s)), rank_to_char(square_rank(s)), 0 }; - return std::string(ch); -} - -inline bool file_is_ok(File f) { - return f >= FILE_A && f <= FILE_H; -} - -inline bool rank_is_ok(Rank r) { - return r >= RANK_1 && r <= RANK_8; -} - -inline bool square_is_ok(Square s) { - return s >= SQ_A1 && s <= SQ_H8; -} - -#endif // !defined(SQUARE_H_INCLUDED) diff --git a/src/thread.h b/src/thread.h index 3cc526ce..609b2e60 100644 --- a/src/thread.h +++ b/src/thread.h @@ -17,15 +17,9 @@ along with this program. If not, see . */ - #if !defined(THREAD_H_INCLUDED) #define THREAD_H_INCLUDED - -//// -//// Includes -//// - #include #include "lock.h" @@ -33,19 +27,9 @@ #include "position.h" #include "search.h" - -//// -//// Constants and variables -//// - const int MAX_THREADS = 16; const int MAX_ACTIVE_SPLIT_POINTS = 8; - -//// -//// Types -//// - struct SplitPoint { // Const data after splitPoint has been setup @@ -73,7 +57,6 @@ struct SplitPoint { }; // ThreadState type is used to represent thread's current state - enum ThreadState { THREAD_INITIALIZING, // thread is initializing itself @@ -91,5 +74,4 @@ struct Thread { SplitPoint splitPoints[MAX_ACTIVE_SPLIT_POINTS]; }; - #endif // !defined(THREAD_H_INCLUDED) diff --git a/src/timeman.h b/src/timeman.h index 1d001c61..dfff89ab 100644 --- a/src/timeman.h +++ b/src/timeman.h @@ -17,14 +17,9 @@ along with this program. If not, see . */ - #if !defined(TIMEMAN_H_INCLUDED) #define TIMEMAN_H_INCLUDED -//// -//// Prototypes -//// - class TimeManager { public: diff --git a/src/tt.h b/src/tt.h index 5c3ddc52..5ca5c237 100644 --- a/src/tt.h +++ b/src/tt.h @@ -17,21 +17,13 @@ along with this program. If not, see . */ - #if !defined(TT_H_INCLUDED) #define TT_H_INCLUDED #include -#include "depth.h" #include "move.h" -#include "value.h" - - -//// -//// Types -//// - +#include "types.h" /// A simple fixed size hash table used to store pawns and material /// configurations. It is basically just an array of Entry objects. diff --git a/src/types.h b/src/types.h index 76ef4cdb..a5502c2f 100644 --- a/src/types.h +++ b/src/types.h @@ -20,6 +20,7 @@ #if !defined(TYPES_H_INCLUDED) #define TYPES_H_INCLUDED +#include #include #if defined(_MSC_VER) @@ -45,10 +46,6 @@ typedef unsigned __int64 uint64_t; #endif -// Our hash key and bitboard types -typedef uint64_t Key; -typedef uint64_t Bitboard; - #define Min(x, y) (((x) < (y)) ? (x) : (y)) #define Max(x, y) (((x) < (y)) ? (y) : (x)) @@ -131,23 +128,6 @@ inline void __cpuid(int CPUInfo[4], int) #define FORCE_INLINE inline #endif -// Operators used by enum types like Depth, Piece, Square and so on. - -#define ENABLE_OPERATORS_ON(T) \ -inline T operator+ (const T d1, const T d2) { return T(int(d1) + int(d2)); } \ -inline T operator- (const T d1, const T d2) { return T(int(d1) - int(d2)); } \ -inline T operator* (int i, const T d) { return T(i * int(d)); } \ -inline T operator* (const T d, int i) { return T(int(d) * i); } \ -inline T operator/ (const T d, int i) { return T(int(d) / i); } \ -inline T operator- (const T d) { return T(-int(d)); } \ -inline T operator++ (T& d, int) {d = T(int(d) + 1); return d; } \ -inline T operator-- (T& d, int) { d = T(int(d) - 1); return d; } \ -inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; } \ -inline void operator-= (T& d1, const T d2) { d1 = d1 - d2; } \ -inline void operator*= (T& d, int i) { d = T(int(d) * i); } \ -inline void operator/= (T& d, int i) { d = T(int(d) / i); } - - /// cpu_has_popcnt() detects support for popcnt instruction at runtime inline bool cpu_has_popcnt() { @@ -174,4 +154,307 @@ const bool CpuIs64Bit = true; const bool CpuIs64Bit = false; #endif +#include + +typedef uint64_t Key; +typedef uint64_t Bitboard; + +enum ValueType { + VALUE_TYPE_NONE = 0, + VALUE_TYPE_UPPER = 1, + VALUE_TYPE_LOWER = 2, + VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER +}; + +enum Value { + VALUE_ZERO = 0, + VALUE_DRAW = 0, + VALUE_KNOWN_WIN = 15000, + VALUE_MATE = 30000, + VALUE_INFINITE = 30001, + VALUE_NONE = 30002, + VALUE_ENSURE_INTEGER_SIZE_P = INT_MAX, + VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN +}; + +enum PieceType { + PIECE_TYPE_NONE = 0, + PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6 +}; + +enum Piece { + PIECE_NONE_DARK_SQ = 0, WP = 1, WN = 2, WB = 3, WR = 4, WQ = 5, WK = 6, + BP = 9, BN = 10, BB = 11, BR = 12, BQ = 13, BK = 14, PIECE_NONE = 16 +}; + +enum Color { + WHITE, BLACK, COLOR_NONE +}; + +enum Depth { + + ONE_PLY = 2, + + DEPTH_ZERO = 0 * ONE_PLY, + DEPTH_QS_CHECKS = -1 * ONE_PLY, + DEPTH_QS_NO_CHECKS = -2 * ONE_PLY, + + DEPTH_NONE = -127 * ONE_PLY +}; + +enum Square { + SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1, + SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2, + SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3, + SQ_A4, SQ_B4, SQ_C4, SQ_D4, SQ_E4, SQ_F4, SQ_G4, SQ_H4, + SQ_A5, SQ_B5, SQ_C5, SQ_D5, SQ_E5, SQ_F5, SQ_G5, SQ_H5, + SQ_A6, SQ_B6, SQ_C6, SQ_D6, SQ_E6, SQ_F6, SQ_G6, SQ_H6, + SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7, + SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8, + SQ_NONE, + + DELTA_N = 8, + DELTA_E = 1, + DELTA_S = -8, + DELTA_W = -1, + + DELTA_NN = DELTA_N + DELTA_N, + DELTA_NE = DELTA_N + DELTA_E, + DELTA_SE = DELTA_S + DELTA_E, + DELTA_SS = DELTA_S + DELTA_S, + DELTA_SW = DELTA_S + DELTA_W, + DELTA_NW = DELTA_N + DELTA_W +}; + +enum File { + FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H +}; + +enum Rank { + RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8 +}; + +enum SquareColor { + DARK, LIGHT +}; + +enum ScaleFactor { + SCALE_FACTOR_ZERO = 0, + SCALE_FACTOR_NORMAL = 64, + SCALE_FACTOR_MAX = 128, + SCALE_FACTOR_NONE = 255 +}; + + +/// Score enum keeps a midgame and an endgame value in a single +/// integer (enum), first LSB 16 bits are used to store endgame +/// value, while upper bits are used for midgame value. Compiler +/// is free to choose the enum type as long as can keep its data, +/// so ensure Score to be an integer type. +enum Score { + SCORE_ZERO = 0, + SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX, + SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN +}; + +#define ENABLE_OPERATORS_ON(T) \ +inline T operator+ (const T d1, const T d2) { return T(int(d1) + int(d2)); } \ +inline T operator- (const T d1, const T d2) { return T(int(d1) - int(d2)); } \ +inline T operator* (int i, const T d) { return T(i * int(d)); } \ +inline T operator* (const T d, int i) { return T(int(d) * i); } \ +inline T operator/ (const T d, int i) { return T(int(d) / i); } \ +inline T operator- (const T d) { return T(-int(d)); } \ +inline T operator++ (T& d, int) {d = T(int(d) + 1); return d; } \ +inline T operator-- (T& d, int) { d = T(int(d) - 1); return d; } \ +inline void operator+= (T& d1, const T d2) { d1 = d1 + d2; } \ +inline void operator-= (T& d1, const T d2) { d1 = d1 - d2; } \ +inline void operator*= (T& d, int i) { d = T(int(d) * i); } \ +inline void operator/= (T& d, int i) { d = T(int(d) / i); } + +ENABLE_OPERATORS_ON(Value) +ENABLE_OPERATORS_ON(PieceType) +ENABLE_OPERATORS_ON(Piece) +ENABLE_OPERATORS_ON(Color) +ENABLE_OPERATORS_ON(Depth) +ENABLE_OPERATORS_ON(Square) +ENABLE_OPERATORS_ON(File) +ENABLE_OPERATORS_ON(Rank) + +#undef ENABLE_OPERATORS_ON + +// Extra operators for adding integers to a Value +inline Value operator+ (Value v, int i) { return Value(int(v) + i); } +inline Value operator- (Value v, int i) { return Value(int(v) - i); } + +// Extracting the _signed_ lower and upper 16 bits it not so trivial +// because according to the standard a simple cast to short is +// implementation defined and so is a right shift of a signed integer. +inline Value mg_value(Score s) { return Value(((int(s) + 32768) & ~0xffff) / 0x10000); } + +// Unfortunatly on Intel 64 bit we have a small speed regression, so use a faster code in +// this case, although not 100% standard compliant it seems to work for Intel and MSVC. +#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER)) +inline Value eg_value(Score s) { return Value(int16_t(s & 0xffff)); } +#else +inline Value eg_value(Score s) { return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u)); } +#endif + +inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); } + +// Division must be handled separately for each term +inline Score operator/(Score s, int i) { return make_score(mg_value(s) / i, eg_value(s) / i); } + +// Only declared but not defined. We don't want to multiply two scores due to +// a very high risk of overflow. So user should explicitly convert to integer. +inline Score operator*(Score s1, Score s2); + +// Remaining Score operators are standard +inline Score operator+ (const Score d1, const Score d2) { return Score(int(d1) + int(d2)); } +inline Score operator- (const Score d1, const Score d2) { return Score(int(d1) - int(d2)); } +inline Score operator* (int i, const Score d) { return Score(i * int(d)); } +inline Score operator* (const Score d, int i) { return Score(int(d) * i); } +inline Score operator- (const Score d) { return Score(-int(d)); } +inline void operator+= (Score& d1, const Score d2) { d1 = d1 + d2; } +inline void operator-= (Score& d1, const Score d2) { d1 = d1 - d2; } +inline void operator*= (Score& d, int i) { d = Score(int(d) * i); } +inline void operator/= (Score& d, int i) { d = Score(int(d) / i); } + +const Value PawnValueMidgame = Value(0x0C6); +const Value PawnValueEndgame = Value(0x102); +const Value KnightValueMidgame = Value(0x331); +const Value KnightValueEndgame = Value(0x34E); +const Value BishopValueMidgame = Value(0x344); +const Value BishopValueEndgame = Value(0x359); +const Value RookValueMidgame = Value(0x4F6); +const Value RookValueEndgame = Value(0x4FE); +const Value QueenValueMidgame = Value(0x9D9); +const Value QueenValueEndgame = Value(0x9FE); + +inline Value value_mate_in(int ply) { + return VALUE_MATE - ply; +} + +inline Value value_mated_in(int ply) { + return -VALUE_MATE + ply; +} + +inline Piece make_piece(Color c, PieceType pt) { + return Piece((int(c) << 3) | int(pt)); +} + +inline PieceType type_of_piece(Piece p) { + return PieceType(int(p) & 7); +} + +inline Color color_of_piece(Piece p) { + return Color(int(p) >> 3); +} + +inline Color opposite_color(Color c) { + return Color(int(c) ^ 1); +} + +inline bool color_is_ok(Color c) { + return c == WHITE || c == BLACK; +} + +inline bool piece_type_is_ok(PieceType pt) { + return pt >= PAWN && pt <= KING; +} + +inline bool piece_is_ok(Piece p) { + return piece_type_is_ok(type_of_piece(p)) && color_is_ok(color_of_piece(p)); +} + +inline char piece_type_to_char(PieceType pt) { + static const char ch[] = " PNBRQK"; + return ch[pt]; +} + +inline Square make_square(File f, Rank r) { + return Square((int(r) << 3) | int(f)); +} + +inline File square_file(Square s) { + return File(int(s) & 7); +} + +inline Rank square_rank(Square s) { + return Rank(int(s) >> 3); +} + +inline Square flip_square(Square s) { + return Square(int(s) ^ 56); +} + +inline Square flop_square(Square s) { + return Square(int(s) ^ 7); +} + +inline Square relative_square(Color c, Square s) { + return Square(int(s) ^ (int(c) * 56)); +} + +inline Rank relative_rank(Color c, Rank r) { + return Rank(int(r) ^ (int(c) * 7)); +} + +inline Rank relative_rank(Color c, Square s) { + return relative_rank(c, square_rank(s)); +} + +inline SquareColor square_color(Square s) { + return SquareColor(int(square_rank(s) + s) & 1); +} + +inline bool opposite_color_squares(Square s1, Square s2) { + int s = int(s1) ^ int(s2); + return ((s >> 3) ^ s) & 1; +} + +inline int file_distance(Square s1, Square s2) { + return abs(square_file(s1) - square_file(s2)); +} + +inline int rank_distance(Square s1, Square s2) { + return abs(square_rank(s1) - square_rank(s2)); +} + +inline int square_distance(Square s1, Square s2) { + return Max(file_distance(s1, s2), rank_distance(s1, s2)); +} + +inline File file_from_char(char c) { + return File(c - 'a') + FILE_A; +} + +inline char file_to_char(File f) { + return char(f - FILE_A + int('a')); +} + +inline Rank rank_from_char(char c) { + return Rank(c - '1') + RANK_1; +} + +inline char rank_to_char(Rank r) { + return char(r - RANK_1 + int('1')); +} + +inline const std::string square_to_string(Square s) { + char ch[] = { file_to_char(square_file(s)), rank_to_char(square_rank(s)), 0 }; + return std::string(ch); +} + +inline bool file_is_ok(File f) { + return f >= FILE_A && f <= FILE_H; +} + +inline bool rank_is_ok(Rank r) { + return r >= RANK_1 && r <= RANK_8; +} + +inline bool square_is_ok(Square s) { + return s >= SQ_A1 && s <= SQ_H8; +} + #endif // !defined(TYPES_H_INCLUDED) diff --git a/src/value.h b/src/value.h deleted file mode 100644 index 2edb4a00..00000000 --- a/src/value.h +++ /dev/null @@ -1,115 +0,0 @@ -/* - Stockfish, a UCI chess playing engine derived from Glaurung 2.1 - Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad - - Stockfish is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - Stockfish is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . -*/ - -#if !defined(VALUE_H_INCLUDED) -#define VALUE_H_INCLUDED - -#include - -#include "types.h" - - -enum ValueType { - VALUE_TYPE_NONE = 0, - VALUE_TYPE_UPPER = 1, - VALUE_TYPE_LOWER = 2, - VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER -}; - - -enum Value { - VALUE_ZERO = 0, - VALUE_DRAW = 0, - VALUE_KNOWN_WIN = 15000, - VALUE_MATE = 30000, - VALUE_INFINITE = 30001, - VALUE_NONE = 30002, - VALUE_ENSURE_INTEGER_SIZE_P = INT_MAX, - VALUE_ENSURE_INTEGER_SIZE_N = INT_MIN -}; - -ENABLE_OPERATORS_ON(Value) - -// Extra operators -inline Value operator+ (Value v, int i) { return Value(int(v) + i); } -inline Value operator- (Value v, int i) { return Value(int(v) - i); } - - -enum ScaleFactor { - SCALE_FACTOR_ZERO = 0, - SCALE_FACTOR_NORMAL = 64, - SCALE_FACTOR_MAX = 128, - SCALE_FACTOR_NONE = 255 -}; - - -/// Score enum keeps a midgame and an endgame value in a single -/// integer (enum), first LSB 16 bits are used to store endgame -/// value, while upper bits are used for midgame value. - -// Compiler is free to choose the enum type as long as can keep -// its data, so ensure Score to be an integer type. -enum Score { - SCORE_ZERO = 0, - SCORE_ENSURE_INTEGER_SIZE_P = INT_MAX, - SCORE_ENSURE_INTEGER_SIZE_N = INT_MIN -}; - -// Extracting the _signed_ lower and upper 16 bits it not so trivial -// because according to the standard a simple cast to short is -// implementation defined and so is a right shift of a signed integer. -inline Value mg_value(Score s) { return Value(((int(s) + 32768) & ~0xffff) / 0x10000); } - -// Unfortunatly on Intel 64 bit we have a small speed regression, so use a faster code in -// this case, although not 100% standard compliant it seems to work for Intel and MSVC. -#if defined(IS_64BIT) && (!defined(__GNUC__) || defined(__INTEL_COMPILER)) -inline Value eg_value(Score s) { return Value(int16_t(s & 0xffff)); } -#else -inline Value eg_value(Score s) { return Value((int)(unsigned(s) & 0x7fffu) - (int)(unsigned(s) & 0x8000u)); } -#endif - -inline Score make_score(int mg, int eg) { return Score((mg << 16) + eg); } - -// Division must be handled separately for each term -inline Score operator/(Score s, int i) { return make_score(mg_value(s) / i, eg_value(s) / i); } - -// Only declared but not defined. We don't want to multiply two scores due to -// a very high risk of overflow. So user should explicitly convert to integer. -inline Score operator*(Score s1, Score s2); - -// Remaining operators are standard -inline Score operator+ (const Score d1, const Score d2) { return Score(int(d1) + int(d2)); } -inline Score operator- (const Score d1, const Score d2) { return Score(int(d1) - int(d2)); } -inline Score operator* (int i, const Score d) { return Score(i * int(d)); } -inline Score operator* (const Score d, int i) { return Score(int(d) * i); } -inline Score operator- (const Score d) { return Score(-int(d)); } -inline void operator+= (Score& d1, const Score d2) { d1 = d1 + d2; } -inline void operator-= (Score& d1, const Score d2) { d1 = d1 - d2; } -inline void operator*= (Score& d, int i) { d = Score(int(d) * i); } -inline void operator/= (Score& d, int i) { d = Score(int(d) / i); } - -inline Value value_mate_in(int ply) { - return VALUE_MATE - ply; -} - -inline Value value_mated_in(int ply) { - return -VALUE_MATE + ply; -} - -#endif // !defined(VALUE_H_INCLUDED)