2008-08-31 23:59:13 -06:00
|
|
|
/*
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
2011-12-30 05:24:41 -07:00
|
|
|
Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
2008-08-31 23:59:13 -06:00
|
|
|
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.
|
2008-10-26 14:44:58 -06:00
|
|
|
|
2008-10-19 10:56:28 -06:00
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
2008-08-31 23:59:13 -06:00
|
|
|
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.
|
2008-10-26 14:44:58 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#if !defined(POSITION_H_INCLUDED)
|
|
|
|
#define POSITION_H_INCLUDED
|
|
|
|
|
2011-05-17 03:47:52 -06:00
|
|
|
#include <cassert>
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
#include "bitboard.h"
|
2011-02-23 13:27:22 -07:00
|
|
|
#include "types.h"
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2011-01-07 05:00:25 -07:00
|
|
|
|
2011-06-29 10:40:33 -06:00
|
|
|
/// The checkInfo struct is initialized at c'tor time and keeps info used
|
|
|
|
/// to detect if a move gives check.
|
2011-12-04 02:53:40 -07:00
|
|
|
class Position;
|
2009-11-09 12:49:01 -07:00
|
|
|
|
|
|
|
struct CheckInfo {
|
|
|
|
|
2011-12-04 02:53:40 -07:00
|
|
|
explicit CheckInfo(const Position&);
|
2009-11-09 12:49:01 -07:00
|
|
|
|
2011-12-04 02:53:40 -07:00
|
|
|
Bitboard dcCandidates;
|
|
|
|
Bitboard pinned;
|
|
|
|
Bitboard checkSq[8];
|
2012-01-08 07:08:20 -07:00
|
|
|
Square ksq;
|
2009-11-09 12:49:01 -07:00
|
|
|
};
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-02-22 12:16:21 -07:00
|
|
|
/// The StateInfo struct stores information we need to restore a Position
|
2009-02-20 02:20:08 -07:00
|
|
|
/// object to its previous state when we retract a move. Whenever a move
|
2009-02-22 12:16:21 -07:00
|
|
|
/// is made on the board (by calling Position::do_move), an StateInfo object
|
|
|
|
/// must be passed as a parameter.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-02-22 12:16:21 -07:00
|
|
|
struct StateInfo {
|
2009-11-08 09:56:41 -07:00
|
|
|
Key pawnKey, materialKey;
|
2009-05-21 01:47:03 -06:00
|
|
|
Value npMaterial[2];
|
2011-07-20 02:45:40 -06:00
|
|
|
int castleRights, rule50, pliesFromNull;
|
|
|
|
Score value;
|
|
|
|
Square epSquare;
|
2009-03-02 09:32:30 -07:00
|
|
|
|
2010-04-11 10:03:03 -06:00
|
|
|
Key key;
|
2009-03-02 09:32:30 -07:00
|
|
|
Bitboard checkersBB;
|
2011-07-02 04:01:12 -06:00
|
|
|
PieceType capturedType;
|
2009-03-02 09:32:30 -07:00
|
|
|
StateInfo* previous;
|
2008-08-31 23:59:13 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-05-20 07:12:45 -06:00
|
|
|
/// The position data structure. A position consists of the following data:
|
2008-10-26 14:44:58 -06:00
|
|
|
///
|
2008-08-31 23:59:13 -06:00
|
|
|
/// * For each piece type, a bitboard representing the squares occupied
|
|
|
|
/// by pieces of that type.
|
2009-05-20 07:12:45 -06:00
|
|
|
/// * For each color, a bitboard representing the squares occupied by
|
2008-08-31 23:59:13 -06:00
|
|
|
/// pieces of that color.
|
|
|
|
/// * A bitboard of all occupied squares.
|
|
|
|
/// * A bitboard of all checking pieces.
|
|
|
|
/// * A 64-entry array of pieces, indexed by the squares of the board.
|
|
|
|
/// * The current side to move.
|
|
|
|
/// * Information about the castling rights for both sides.
|
2009-05-20 07:12:45 -06:00
|
|
|
/// * The initial files of the kings and both pairs of rooks. This is
|
2008-08-31 23:59:13 -06:00
|
|
|
/// used to implement the Chess960 castling rules.
|
|
|
|
/// * The en passant square (which is SQ_NONE if no en passant capture is
|
|
|
|
/// possible).
|
|
|
|
/// * The squares of the kings for both sides.
|
|
|
|
/// * Hash keys for the position itself, the current pawn structure, and
|
|
|
|
/// the current material situation.
|
2009-05-20 07:12:45 -06:00
|
|
|
/// * Hash keys for all previous positions in the game for detecting
|
2008-08-31 23:59:13 -06:00
|
|
|
/// repetition draws.
|
|
|
|
/// * A counter for detecting 50 move rule draws.
|
|
|
|
|
|
|
|
class Position {
|
|
|
|
|
2011-11-27 09:07:17 -07:00
|
|
|
// No copy c'tor or assignment operator allowed
|
2011-07-15 14:51:19 -06:00
|
|
|
Position(const Position&);
|
2011-07-16 03:42:27 -06:00
|
|
|
Position& operator=(const Position&);
|
2010-06-02 13:13:51 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
public:
|
2011-11-27 09:07:17 -07:00
|
|
|
Position() {}
|
|
|
|
Position(const Position& pos, int th) { copy(pos, th); }
|
|
|
|
Position(const std::string& fen, bool isChess960, int th);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Text input/output
|
2011-11-27 09:07:17 -07:00
|
|
|
void copy(const Position& pos, int th);
|
2011-01-03 04:50:49 -07:00
|
|
|
void from_fen(const std::string& fen, bool isChess960);
|
2011-01-03 14:31:17 -07:00
|
|
|
const std::string to_fen() const;
|
2008-11-15 00:14:28 -07:00
|
|
|
void print(Move m = MOVE_NONE) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// The piece on a given square
|
|
|
|
Piece piece_on(Square s) const;
|
2012-01-09 14:34:00 -07:00
|
|
|
Piece piece_moved(Move m) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
bool square_is_empty(Square s) const;
|
|
|
|
|
|
|
|
// Side to move
|
|
|
|
Color side_to_move() const;
|
|
|
|
|
|
|
|
// Bitboard representation of the position
|
2012-03-18 04:10:12 -06:00
|
|
|
Bitboard pieces() const;
|
2011-06-28 07:36:39 -06:00
|
|
|
Bitboard pieces(Color c) const;
|
2009-09-02 03:57:38 -06:00
|
|
|
Bitboard pieces(PieceType pt) const;
|
|
|
|
Bitboard pieces(PieceType pt, Color c) const;
|
|
|
|
Bitboard pieces(PieceType pt1, PieceType pt2) const;
|
|
|
|
Bitboard pieces(PieceType pt1, PieceType pt2, Color c) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Number of pieces of each color and type
|
|
|
|
int piece_count(Color c, PieceType pt) const;
|
|
|
|
|
2008-11-15 05:00:56 -07:00
|
|
|
// The en passant square
|
2008-08-31 23:59:13 -06:00
|
|
|
Square ep_square() const;
|
|
|
|
|
|
|
|
// Current king position for each color
|
|
|
|
Square king_square(Color c) const;
|
|
|
|
|
2008-11-15 05:00:56 -07:00
|
|
|
// Castling rights
|
2011-06-27 09:06:15 -06:00
|
|
|
bool can_castle(CastleRight f) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
bool can_castle(Color c) const;
|
2012-02-27 04:11:18 -07:00
|
|
|
bool castle_impeded(CastleRight f) const;
|
2011-06-27 09:06:15 -06:00
|
|
|
Square castle_rook_square(CastleRight f) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Bitboards for pinned pieces and discovered check candidates
|
2011-07-16 02:56:34 -06:00
|
|
|
Bitboard discovered_check_candidates() const;
|
|
|
|
Bitboard pinned_pieces() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-20 01:43:25 -06:00
|
|
|
// Checking pieces and under check information
|
2008-08-31 23:59:13 -06:00
|
|
|
Bitboard checkers() const;
|
2011-04-29 08:26:48 -06:00
|
|
|
bool in_check() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2008-10-19 06:44:25 -06:00
|
|
|
// Piece lists
|
2011-06-28 08:16:43 -06:00
|
|
|
const Square* piece_list(Color c, PieceType pt) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-20 03:26:54 -06:00
|
|
|
// Information about attacks to or from a given square
|
2009-09-20 02:31:48 -06:00
|
|
|
Bitboard attackers_to(Square s) const;
|
2011-05-22 03:57:06 -06:00
|
|
|
Bitboard attackers_to(Square s, Bitboard occ) const;
|
2009-09-20 07:23:46 -06:00
|
|
|
Bitboard attacks_from(Piece p, Square s) const;
|
2010-12-15 01:14:01 -07:00
|
|
|
static Bitboard attacks_from(Piece p, Square s, Bitboard occ);
|
2009-09-20 07:23:46 -06:00
|
|
|
template<PieceType> Bitboard attacks_from(Square s) const;
|
|
|
|
template<PieceType> Bitboard attacks_from(Square s, Color c) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Properties of moves
|
2011-04-29 08:26:48 -06:00
|
|
|
bool move_gives_check(Move m, const CheckInfo& ci) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
bool move_attacks_square(Move m, Square s) const;
|
2011-10-03 02:56:49 -06:00
|
|
|
bool pl_move_is_legal(Move m, Bitboard pinned) const;
|
|
|
|
bool is_pseudo_legal(const Move m) const;
|
|
|
|
bool is_capture(Move m) const;
|
|
|
|
bool is_capture_or_promotion(Move m) const;
|
|
|
|
bool is_passed_pawn_push(Move m) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2010-03-08 06:57:01 -07:00
|
|
|
// Piece captured with previous moves
|
2010-08-07 11:40:04 -06:00
|
|
|
PieceType captured_piece_type() const;
|
2010-03-08 06:57:01 -07:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
// Information about pawns
|
|
|
|
bool pawn_is_passed(Color c, Square s) const;
|
|
|
|
|
|
|
|
// Doing and undoing moves
|
2009-02-22 12:16:21 -07:00
|
|
|
void do_move(Move m, StateInfo& st);
|
2009-11-11 02:41:46 -07:00
|
|
|
void do_move(Move m, StateInfo& st, const CheckInfo& ci, bool moveIsCheck);
|
2009-02-22 09:49:52 -07:00
|
|
|
void undo_move(Move m);
|
2011-10-29 10:49:20 -06:00
|
|
|
template<bool Do> void do_null_move(StateInfo& st);
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Static exchange evaluation
|
|
|
|
int see(Move m) const;
|
2009-07-11 02:54:30 -06:00
|
|
|
int see_sign(Move m) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Accessing hash keys
|
2011-12-25 03:50:59 -07:00
|
|
|
Key key() const;
|
|
|
|
Key exclusion_key() const;
|
|
|
|
Key pawn_key() const;
|
|
|
|
Key material_key() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Incremental evaluation
|
2009-11-07 04:40:48 -07:00
|
|
|
Score value() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
Value non_pawn_material(Color c) const;
|
2011-06-28 08:25:44 -06:00
|
|
|
Score pst_delta(Piece piece, Square from, Square to) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-01-10 03:57:06 -07:00
|
|
|
// Other properties of the position
|
2011-06-04 04:29:54 -06:00
|
|
|
template<bool SkipRepetition> bool is_draw() const;
|
2011-07-20 02:45:40 -06:00
|
|
|
int startpos_ply_counter() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
bool opposite_colored_bishops() const;
|
2012-02-05 08:24:53 -07:00
|
|
|
bool both_color_bishops(Color c) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
bool has_pawn_on_7th(Color c) const;
|
2011-01-03 14:31:17 -07:00
|
|
|
bool is_chess960() const;
|
2010-06-02 13:13:51 -06:00
|
|
|
int thread() const;
|
2010-10-31 03:55:28 -06:00
|
|
|
int64_t nodes_searched() const;
|
|
|
|
void set_nodes_searched(int64_t n);
|
2010-07-11 10:23:50 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
// Position consistency check, for debugging
|
2011-10-16 16:56:25 -06:00
|
|
|
bool pos_is_ok(int* failedStep = NULL) const;
|
2011-10-02 01:33:40 -06:00
|
|
|
void flip_me();
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2011-06-13 08:59:03 -06:00
|
|
|
// Global initialization
|
|
|
|
static void init();
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
private:
|
2009-02-28 02:20:57 -07:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
// Initialization helper functions (used while setting up a position)
|
|
|
|
void clear();
|
|
|
|
void put_piece(Piece p, Square s);
|
2012-02-27 04:11:18 -07:00
|
|
|
void set_castle_right(Color c, Square rfrom);
|
2011-07-03 03:38:20 -06:00
|
|
|
bool move_is_legal(const Move m) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2011-10-30 11:16:28 -06:00
|
|
|
// Helper template functions
|
2011-10-29 09:49:59 -06:00
|
|
|
template<bool Do> void do_castle_move(Move m);
|
2011-10-30 11:16:28 -06:00
|
|
|
template<bool FindPinned> Bitboard hidden_checkers() const;
|
2008-10-23 13:43:48 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
// Computing hash keys from scratch (for initialization and debugging)
|
|
|
|
Key compute_key() const;
|
|
|
|
Key compute_pawn_key() const;
|
|
|
|
Key compute_material_key() const;
|
|
|
|
|
|
|
|
// Computing incremental evaluation scores and material counts
|
2011-06-28 08:25:44 -06:00
|
|
|
Score pst(Piece p, Square s) const;
|
2009-11-07 05:12:58 -07:00
|
|
|
Score compute_value() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
Value compute_non_pawn_material(Color c) const;
|
|
|
|
|
|
|
|
// Board
|
2011-06-29 10:40:33 -06:00
|
|
|
Piece board[64]; // [square]
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-09-23 10:11:29 -06:00
|
|
|
// Bitboards
|
2011-06-29 10:40:33 -06:00
|
|
|
Bitboard byTypeBB[8]; // [pieceType]
|
|
|
|
Bitboard byColorBB[2]; // [color]
|
2009-09-23 10:11:29 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
// Piece counts
|
2011-06-29 10:40:33 -06:00
|
|
|
int pieceCount[2][8]; // [color][pieceType]
|
2008-10-26 14:44:58 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
// Piece lists
|
2011-06-29 10:40:33 -06:00
|
|
|
Square pieceList[2][8][16]; // [color][pieceType][index]
|
|
|
|
int index[64]; // [square]
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Other info
|
2011-06-29 10:40:33 -06:00
|
|
|
int castleRightsMask[64]; // [square]
|
|
|
|
Square castleRookSquare[16]; // [castleRight]
|
2012-02-27 04:11:18 -07:00
|
|
|
Bitboard castlePath[16]; // [castleRight]
|
2009-02-22 12:16:21 -07:00
|
|
|
StateInfo startState;
|
2011-07-02 04:01:12 -06:00
|
|
|
int64_t nodes;
|
2011-07-20 02:45:40 -06:00
|
|
|
int startPosPly;
|
2011-07-02 04:01:12 -06:00
|
|
|
Color sideToMove;
|
2010-06-02 13:13:51 -06:00
|
|
|
int threadID;
|
2009-02-22 12:16:21 -07:00
|
|
|
StateInfo* st;
|
2011-07-02 04:01:12 -06:00
|
|
|
int chess960;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Static variables
|
2011-06-29 10:40:33 -06:00
|
|
|
static Score pieceSquareTable[16][64]; // [piece][square]
|
2011-10-22 08:52:53 -06:00
|
|
|
static Key zobrist[2][8][64]; // [color][pieceType][square]/[piece count]
|
2012-02-19 03:28:42 -07:00
|
|
|
static Key zobEp[8]; // [file]
|
2011-06-29 10:40:33 -06:00
|
|
|
static Key zobCastle[16]; // [castleRight]
|
2008-08-31 23:59:13 -06:00
|
|
|
static Key zobSideToMove;
|
2009-11-23 04:40:18 -07:00
|
|
|
static Key zobExclusion;
|
2008-08-31 23:59:13 -06:00
|
|
|
};
|
|
|
|
|
2010-10-31 03:55:28 -06:00
|
|
|
inline int64_t Position::nodes_searched() const {
|
|
|
|
return nodes;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void Position::set_nodes_searched(int64_t n) {
|
|
|
|
nodes = n;
|
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline Piece Position::piece_on(Square s) const {
|
|
|
|
return board[s];
|
|
|
|
}
|
|
|
|
|
2012-01-09 14:34:00 -07:00
|
|
|
inline Piece Position::piece_moved(Move m) const {
|
|
|
|
return board[from_sq(m)];
|
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline bool Position::square_is_empty(Square s) const {
|
2011-12-27 11:26:27 -07:00
|
|
|
return board[s] == NO_PIECE;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline Color Position::side_to_move() const {
|
|
|
|
return sideToMove;
|
|
|
|
}
|
|
|
|
|
2012-03-18 04:10:12 -06:00
|
|
|
inline Bitboard Position::pieces() const {
|
2012-03-18 04:33:54 -06:00
|
|
|
return byTypeBB[ALL_PIECES];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-06-28 07:36:39 -06:00
|
|
|
inline Bitboard Position::pieces(Color c) const {
|
2008-08-31 23:59:13 -06:00
|
|
|
return byColorBB[c];
|
|
|
|
}
|
|
|
|
|
2009-09-02 03:57:38 -06:00
|
|
|
inline Bitboard Position::pieces(PieceType pt) const {
|
2008-08-31 23:59:13 -06:00
|
|
|
return byTypeBB[pt];
|
|
|
|
}
|
|
|
|
|
2009-09-02 03:57:38 -06:00
|
|
|
inline Bitboard Position::pieces(PieceType pt, Color c) const {
|
|
|
|
return byTypeBB[pt] & byColorBB[c];
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const {
|
|
|
|
return byTypeBB[pt1] | byTypeBB[pt2];
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Bitboard Position::pieces(PieceType pt1, PieceType pt2, Color c) const {
|
|
|
|
return (byTypeBB[pt1] | byTypeBB[pt2]) & byColorBB[c];
|
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline int Position::piece_count(Color c, PieceType pt) const {
|
|
|
|
return pieceCount[c][pt];
|
|
|
|
}
|
|
|
|
|
2011-06-28 08:16:43 -06:00
|
|
|
inline const Square* Position::piece_list(Color c, PieceType pt) const {
|
2009-09-23 14:45:32 -06:00
|
|
|
return pieceList[c][pt];
|
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline Square Position::ep_square() const {
|
2009-02-22 12:16:21 -07:00
|
|
|
return st->epSquare;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline Square Position::king_square(Color c) const {
|
2009-09-23 10:47:03 -06:00
|
|
|
return pieceList[c][KING][0];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-06-27 09:06:15 -06:00
|
|
|
inline bool Position::can_castle(CastleRight f) const {
|
|
|
|
return st->castleRights & f;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-06-11 05:41:20 -06:00
|
|
|
inline bool Position::can_castle(Color c) const {
|
|
|
|
return st->castleRights & ((WHITE_OO | WHITE_OOO) << c);
|
|
|
|
}
|
|
|
|
|
2012-02-27 04:11:18 -07:00
|
|
|
inline bool Position::castle_impeded(CastleRight f) const {
|
2012-03-18 04:33:54 -06:00
|
|
|
return byTypeBB[ALL_PIECES] & castlePath[f];
|
2012-02-27 04:11:18 -07:00
|
|
|
}
|
|
|
|
|
2011-06-27 09:06:15 -06:00
|
|
|
inline Square Position::castle_rook_square(CastleRight f) const {
|
|
|
|
return castleRookSquare[f];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2012-01-14 15:01:09 -07:00
|
|
|
template<PieceType Pt>
|
2009-09-20 07:23:46 -06:00
|
|
|
inline Bitboard Position::attacks_from(Square s) const {
|
2012-03-18 04:10:12 -06:00
|
|
|
return Pt == BISHOP || Pt == ROOK ? attacks_bb<Pt>(s, pieces())
|
2012-01-14 15:01:09 -07:00
|
|
|
: Pt == QUEEN ? attacks_from<ROOK>(s) | attacks_from<BISHOP>(s)
|
2012-02-12 08:02:13 -07:00
|
|
|
: StepAttacksBB[Pt][s];
|
2009-02-12 04:26:23 -07:00
|
|
|
}
|
|
|
|
|
2008-10-19 05:43:09 -06:00
|
|
|
template<>
|
2012-01-14 15:01:09 -07:00
|
|
|
inline Bitboard Position::attacks_from<PAWN>(Square s, Color c) const {
|
|
|
|
return StepAttacksBB[make_piece(c, PAWN)][s];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-10-22 07:21:57 -06:00
|
|
|
inline Bitboard Position::attacks_from(Piece p, Square s) const {
|
2012-03-18 04:33:54 -06:00
|
|
|
return attacks_from(p, s, byTypeBB[ALL_PIECES]);
|
2011-10-22 07:21:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline Bitboard Position::attackers_to(Square s) const {
|
2012-03-18 04:33:54 -06:00
|
|
|
return attackers_to(s, byTypeBB[ALL_PIECES]);
|
2011-10-22 07:21:57 -06:00
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline Bitboard Position::checkers() const {
|
2009-02-22 12:16:21 -07:00
|
|
|
return st->checkersBB;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-04-29 08:26:48 -06:00
|
|
|
inline bool Position::in_check() const {
|
2011-10-03 02:23:04 -06:00
|
|
|
return st->checkersBB != 0;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-10-30 11:16:28 -06:00
|
|
|
inline Bitboard Position::discovered_check_candidates() const {
|
|
|
|
return hidden_checkers<false>();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Bitboard Position::pinned_pieces() const {
|
|
|
|
return hidden_checkers<true>();
|
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline bool Position::pawn_is_passed(Color c, Square s) const {
|
2012-01-12 11:31:18 -07:00
|
|
|
return !(pieces(PAWN, ~c) & passed_pawn_mask(c, s));
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-12-25 03:50:59 -07:00
|
|
|
inline Key Position::key() const {
|
2009-02-22 12:16:21 -07:00
|
|
|
return st->key;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-12-25 03:50:59 -07:00
|
|
|
inline Key Position::exclusion_key() const {
|
2009-11-23 04:40:18 -07:00
|
|
|
return st->key ^ zobExclusion;
|
|
|
|
}
|
|
|
|
|
2011-12-25 03:50:59 -07:00
|
|
|
inline Key Position::pawn_key() const {
|
2009-02-22 12:16:21 -07:00
|
|
|
return st->pawnKey;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-12-25 03:50:59 -07:00
|
|
|
inline Key Position::material_key() const {
|
2009-02-22 12:16:21 -07:00
|
|
|
return st->materialKey;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-06-28 08:25:44 -06:00
|
|
|
inline Score Position::pst(Piece p, Square s) const {
|
2011-06-29 10:40:33 -06:00
|
|
|
return pieceSquareTable[p][s];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-06-28 08:25:44 -06:00
|
|
|
inline Score Position::pst_delta(Piece piece, Square from, Square to) const {
|
2011-06-29 10:40:33 -06:00
|
|
|
return pieceSquareTable[piece][to] - pieceSquareTable[piece][from];
|
2008-10-15 00:18:05 -06:00
|
|
|
}
|
|
|
|
|
2009-11-07 04:40:48 -07:00
|
|
|
inline Score Position::value() const {
|
|
|
|
return st->value;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline Value Position::non_pawn_material(Color c) const {
|
2009-05-21 01:47:03 -06:00
|
|
|
return st->npMaterial[c];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2011-10-03 02:56:49 -06:00
|
|
|
inline bool Position::is_passed_pawn_push(Move m) const {
|
2008-09-27 05:28:58 -06:00
|
|
|
|
2012-01-01 08:00:00 -07:00
|
|
|
return board[from_sq(m)] == make_piece(sideToMove, PAWN)
|
|
|
|
&& pawn_is_passed(sideToMove, to_sq(m));
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
2008-09-27 05:28:58 -06:00
|
|
|
|
2011-07-20 02:45:40 -06:00
|
|
|
inline int Position::startpos_ply_counter() const {
|
2011-07-23 22:59:16 -06:00
|
|
|
return startPosPly + st->pliesFromNull; // HACK
|
2010-07-11 10:23:50 -06:00
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline bool Position::opposite_colored_bishops() const {
|
2008-09-27 05:28:58 -06:00
|
|
|
|
2011-10-03 02:23:04 -06:00
|
|
|
return pieceCount[WHITE][BISHOP] == 1
|
|
|
|
&& pieceCount[BLACK][BISHOP] == 1
|
|
|
|
&& opposite_colors(pieceList[WHITE][BISHOP][0], pieceList[BLACK][BISHOP][0]);
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2012-02-05 08:24:53 -07:00
|
|
|
inline bool Position::both_color_bishops(Color c) const {
|
|
|
|
// Assumes that there are only two bishops
|
|
|
|
return pieceCount[c][BISHOP] >= 2 &&
|
|
|
|
opposite_colors(pieceList[c][BISHOP][0], pieceList[c][BISHOP][1]);
|
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline bool Position::has_pawn_on_7th(Color c) const {
|
2011-01-19 04:20:06 -07:00
|
|
|
return pieces(PAWN, c) & rank_bb(relative_rank(c, RANK_7));
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
2008-10-26 14:44:58 -06:00
|
|
|
|
2011-01-03 14:31:17 -07:00
|
|
|
inline bool Position::is_chess960() const {
|
2011-04-04 01:53:44 -06:00
|
|
|
return chess960;
|
2011-01-03 14:31:17 -07:00
|
|
|
}
|
|
|
|
|
2011-10-03 02:56:49 -06:00
|
|
|
inline bool Position::is_capture_or_promotion(Move m) const {
|
2011-06-22 16:04:57 -06:00
|
|
|
|
2011-10-03 02:56:49 -06:00
|
|
|
assert(is_ok(m));
|
2012-01-01 08:00:00 -07:00
|
|
|
return is_special(m) ? !is_castle(m) : !square_is_empty(to_sq(m));
|
2011-06-22 16:04:57 -06:00
|
|
|
}
|
|
|
|
|
2011-10-03 02:56:49 -06:00
|
|
|
inline bool Position::is_capture(Move m) const {
|
2009-04-27 08:35:31 -06:00
|
|
|
|
2011-06-22 16:04:57 -06:00
|
|
|
// Note that castle is coded as "king captures the rook"
|
2011-10-03 02:56:49 -06:00
|
|
|
assert(is_ok(m));
|
2012-01-01 08:00:00 -07:00
|
|
|
return (!square_is_empty(to_sq(m)) && !is_castle(m)) || is_enpassant(m);
|
2009-10-21 04:41:24 -06:00
|
|
|
}
|
|
|
|
|
2010-08-07 11:40:04 -06:00
|
|
|
inline PieceType Position::captured_piece_type() const {
|
|
|
|
return st->capturedType;
|
2010-03-08 06:57:01 -07:00
|
|
|
}
|
|
|
|
|
2010-06-02 13:13:51 -06:00
|
|
|
inline int Position::thread() const {
|
|
|
|
return threadID;
|
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
#endif // !defined(POSITION_H_INCLUDED)
|