/// -DUSE_POPCNT | Add runtime support for use of popcnt asm-instruction. Works
/// | only in 64-bit mode. For compiling requires hardware with
/// | popcnt support.
-///
-/// -DOLD_LOCKS | Under Windows are used the fast Slim Reader/Writer (SRW)
-/// | Locks and Condition Variables: these are not supported by
-/// | Windows XP and older, to compile for those platforms you
-/// | should enable OLD_LOCKS.
#include <climits>
#include <cstdlib>
-#if defined(_MSC_VER)
-
-// Disable some silly and noisy warning from MSVC compiler
-#pragma warning(disable: 4127) // Conditional expression is constant
-#pragma warning(disable: 4146) // Unary minus operator applied to unsigned type
-#pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false'
-
-// MSVC does not support <inttypes.h>
-typedef signed __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef signed __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef signed __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef signed __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-
-#else
-# include <inttypes.h>
-#endif
+#include "platform.h"
#if defined(_WIN64)
# include <intrin.h> // MSVC popcnt and bsfq instrinsics
typedef uint64_t Key;
typedef uint64_t Bitboard;
-const int MAX_MOVES = 256;
+const int MAX_MOVES = 192;
const int MAX_PLY = 100;
const int MAX_PLY_PLUS_2 = MAX_PLY + 2;
ALL_CASTLES = 15
};
+enum CastlingSide {
+ KING_SIDE,
+ QUEEN_SIDE
+};
+
enum ScaleFactor {
SCALE_FACTOR_DRAW = 0,
SCALE_FACTOR_NORMAL = 64,
SCALE_FACTOR_NONE = 255
};
-enum ValueType {
- VALUE_TYPE_NONE = 0,
- VALUE_TYPE_UPPER = 1,
- VALUE_TYPE_LOWER = 2,
- VALUE_TYPE_EXACT = VALUE_TYPE_UPPER | VALUE_TYPE_LOWER
+enum Bound {
+ BOUND_NONE = 0,
+ BOUND_UPPER = 1,
+ BOUND_LOWER = 2,
+ BOUND_EXACT = BOUND_UPPER | BOUND_LOWER
};
enum Value {
};
enum PieceType {
- NO_PIECE_TYPE = 0,
+ NO_PIECE_TYPE = 0, ALL_PIECES = 0,
PAWN = 1, KNIGHT = 2, BISHOP = 3, ROOK = 4, QUEEN = 5, KING = 6
};
DEPTH_ZERO = 0 * ONE_PLY,
DEPTH_QS_CHECKS = -1 * ONE_PLY,
DEPTH_QS_NO_CHECKS = -2 * ONE_PLY,
- DEPTH_QS_RECAPTURES = -4 * ONE_PLY,
+ DEPTH_QS_RECAPTURES = -5 * ONE_PLY,
DEPTH_NONE = -127 * ONE_PLY
};
return make_score(mg_value(s) / i, eg_value(s) / i);
}
+/// Weight score v by score w trying to prevent overflow
+inline Score apply_weight(Score v, Score w) {
+ return make_score((int(mg_value(v)) * mg_value(w)) / 0x100,
+ (int(eg_value(v)) * eg_value(w)) / 0x100);
+}
+
#undef ENABLE_OPERATORS_ON
#undef ENABLE_SAFE_OPERATORS_ON
-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);
-
-extern const Value PieceValueMidgame[17];
+const Value PawnValueMidgame = Value(198);
+const Value PawnValueEndgame = Value(258);
+const Value KnightValueMidgame = Value(817);
+const Value KnightValueEndgame = Value(846);
+const Value BishopValueMidgame = Value(836);
+const Value BishopValueEndgame = Value(857);
+const Value RookValueMidgame = Value(1270);
+const Value RookValueEndgame = Value(1278);
+const Value QueenValueMidgame = Value(2521);
+const Value QueenValueEndgame = Value(2558);
+
+extern const Value PieceValueMidgame[17]; // Indexed by Piece or PieceType
extern const Value PieceValueEndgame[17];
extern int SquareDistance[64][64];
+inline Color operator~(Color c) {
+ return Color(c ^ 1);
+}
+
+inline Square operator~(Square s) {
+ return Square(s ^ 56); // Vertical flip SQ_A1 -> SQ_A8
+}
+
inline Value mate_in(int ply) {
return VALUE_MATE - ply;
}
return Piece((c << 3) | pt);
}
+inline CastleRight make_castle_right(Color c, CastlingSide s) {
+ return CastleRight((s == KING_SIDE ? WHITE_OO : WHITE_OOO) << c);
+}
+
inline PieceType type_of(Piece p) {
return PieceType(p & 7);
}
return Color(p >> 3);
}
-inline Color flip(Color c) {
- return Color(c ^ 1);
-}
-
inline Square make_square(File f, Rank r) {
return Square((r << 3) | f);
}
-inline bool square_is_ok(Square s) {
+inline bool is_ok(Square s) {
return s >= SQ_A1 && s <= SQ_H8;
}
return Rank(s >> 3);
}
-inline Square flip(Square s) {
- return Square(s ^ 56);
-}
-
inline Square mirror(Square s) {
- return Square(s ^ 7);
+ return Square(s ^ 7); // Horizontal flip SQ_A1 -> SQ_H1
}
inline Square relative_square(Color c, Square s) {
return c == WHITE ? DELTA_N : DELTA_S;
}
-inline Square move_from(Move m) {
+inline Square from_sq(Move m) {
return Square((m >> 6) & 0x3F);
}
-inline Square move_to(Move m) {
+inline Square to_sq(Move m) {
return Square(m & 0x3F);
}
return (m & (3 << 14)) == (3 << 14);
}
-inline PieceType promotion_piece_type(Move m) {
+inline PieceType promotion_type(Move m) {
return PieceType(((m >> 12) & 3) + 2);
}
return Move(to | (from << 6));
}
-inline Move make_promotion_move(Square from, Square to, PieceType promotion) {
- return Move(to | (from << 6) | (1 << 14) | ((promotion - 2) << 12)) ;
+inline Move make_promotion(Square from, Square to, PieceType pt) {
+ return Move(to | (from << 6) | (1 << 14) | ((pt - 2) << 12)) ;
}
-inline Move make_enpassant_move(Square from, Square to) {
+inline Move make_enpassant(Square from, Square to) {
return Move(to | (from << 6) | (2 << 14));
}
-inline Move make_castle_move(Square from, Square to) {
+inline Move make_castle(Square from, Square to) {
return Move(to | (from << 6) | (3 << 14));
}
inline bool is_ok(Move m) {
- return move_from(m) != move_to(m); // Catches also MOVE_NULL and MOVE_NONE
+ return from_sq(m) != to_sq(m); // Catches also MOVE_NULL and MOVE_NONE
}
#include <string>
/// Our insertion sort implementation, works with pointers and iterators and is
/// guaranteed to be stable, as is needed.
template<typename T, typename K>
-void sort(K firstMove, K lastMove)
+void sort(K first, K last)
{
- T value;
- K cur, p, d;
-
- if (firstMove != lastMove)
- for (cur = firstMove + 1; cur != lastMove; cur++)
- {
- p = d = cur;
- value = *p--;
- if (*p < value)
- {
- do *d = *p;
- while (--d != firstMove && *--p < value);
- *d = value;
- }
- }
+ T tmp;
+ K p, q;
+
+ for (p = first + 1; p < last; p++)
+ {
+ tmp = *p;
+ for (q = p; q != first && *(q-1) < tmp; --q)
+ *q = *(q-1);
+ *q = tmp;
+ }
}
#endif // !defined(TYPES_H_INCLUDED)
projects / stockfish / blobdiff