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)
|
2016-01-02 02:43:25 -07:00
|
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
|
|
|
Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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/>.
|
|
|
|
*/
|
|
|
|
|
2013-07-23 07:31:57 -06:00
|
|
|
#ifndef POSITION_H_INCLUDED
|
2008-08-31 23:59:13 -06:00
|
|
|
#define POSITION_H_INCLUDED
|
|
|
|
|
2011-05-17 03:47:52 -06:00
|
|
|
#include <cassert>
|
2015-01-07 01:09:41 -07:00
|
|
|
#include <cstddef> // For offsetof()
|
2016-04-17 13:31:19 -06:00
|
|
|
#include <deque>
|
2016-04-11 08:45:36 -06:00
|
|
|
#include <memory> // For std::unique_ptr
|
2015-01-09 04:35:44 -07:00
|
|
|
#include <string>
|
2016-04-11 08:45:36 -06:00
|
|
|
#include <vector>
|
2011-05-17 03:47:52 -06:00
|
|
|
|
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-12-04 02:53:40 -07:00
|
|
|
class Position;
|
2015-11-20 23:48:50 -07:00
|
|
|
class Thread;
|
2009-11-09 12:49:01 -07:00
|
|
|
|
2015-05-01 18:36:39 -06:00
|
|
|
namespace PSQT {
|
|
|
|
|
2016-09-03 10:14:01 -06:00
|
|
|
extern Score psq[PIECE_NB][SQUARE_NB];
|
2015-05-01 18:36:39 -06:00
|
|
|
|
|
|
|
void init();
|
|
|
|
}
|
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
|
|
|
|
/// StateInfo struct stores information needed to restore a Position object to
|
|
|
|
/// its previous state when we retract a move. Whenever a move is made on the
|
|
|
|
/// board (by calling Position::do_move), a StateInfo object must be passed.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2009-02-22 12:16:21 -07:00
|
|
|
struct StateInfo {
|
2015-01-07 01:09:41 -07:00
|
|
|
|
|
|
|
// Copied when making a move
|
|
|
|
Key pawnKey;
|
|
|
|
Key materialKey;
|
|
|
|
Value nonPawnMaterial[COLOR_NB];
|
|
|
|
int castlingRights;
|
|
|
|
int rule50;
|
|
|
|
int pliesFromNull;
|
|
|
|
Score psq;
|
2011-07-20 02:45:40 -06:00
|
|
|
Square epSquare;
|
2009-03-02 09:32:30 -07:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
// Not copied when making a move
|
|
|
|
Key key;
|
|
|
|
Bitboard checkersBB;
|
2016-09-03 10:14:01 -06:00
|
|
|
Piece capturedPiece;
|
2009-03-02 09:32:30 -07:00
|
|
|
StateInfo* previous;
|
2016-08-27 02:05:42 -06:00
|
|
|
Bitboard blockersForKing[COLOR_NB];
|
2016-09-12 00:47:19 -06:00
|
|
|
Bitboard pinnersForKing[COLOR_NB];
|
2016-08-27 02:05:42 -06:00
|
|
|
Bitboard checkSquares[PIECE_TYPE_NB];
|
2008-08-31 23:59:13 -06:00
|
|
|
};
|
|
|
|
|
2016-04-17 13:31:19 -06:00
|
|
|
// In a std::deque references to elements are unaffected upon resizing
|
|
|
|
typedef std::unique_ptr<std::deque<StateInfo>> StateListPtr;
|
2016-04-11 08:45:36 -06:00
|
|
|
|
2012-10-28 10:12:40 -06:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
/// Position class stores information regarding the board representation as
|
|
|
|
/// pieces, side to move, hash keys, castling info, etc. Important methods are
|
|
|
|
/// do_move() and undo_move(), used by the search to update node info when
|
|
|
|
/// traversing the search tree.
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
class Position {
|
2014-11-01 11:50:27 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
public:
|
2015-01-07 01:09:41 -07:00
|
|
|
static void init();
|
|
|
|
|
2016-04-11 08:45:36 -06:00
|
|
|
Position() = default;
|
2015-01-21 05:18:19 -07:00
|
|
|
Position(const Position&) = delete;
|
2016-04-11 08:45:36 -06:00
|
|
|
Position& operator=(const Position&) = delete;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2014-11-01 11:50:27 -06:00
|
|
|
// FEN string input/output
|
2016-04-11 08:45:36 -06:00
|
|
|
Position& set(const std::string& fenStr, bool isChess960, StateInfo* si, Thread* th);
|
2012-11-11 05:18:10 -07:00
|
|
|
const std::string fen() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Position representation
|
2012-03-18 04:10:12 -06:00
|
|
|
Bitboard pieces() const;
|
2009-09-02 03:57:38 -06:00
|
|
|
Bitboard pieces(PieceType pt) const;
|
|
|
|
Bitboard pieces(PieceType pt1, PieceType pt2) const;
|
2012-05-01 05:01:38 -06:00
|
|
|
Bitboard pieces(Color c) const;
|
|
|
|
Bitboard pieces(Color c, PieceType pt) const;
|
|
|
|
Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const;
|
2012-04-02 11:21:17 -06:00
|
|
|
Piece piece_on(Square s) const;
|
|
|
|
Square ep_square() const;
|
2013-09-28 06:43:50 -06:00
|
|
|
bool empty(Square s) const;
|
2013-06-16 03:59:40 -06:00
|
|
|
template<PieceType Pt> int count(Color c) const;
|
2015-08-04 01:00:52 -06:00
|
|
|
template<PieceType Pt> const Square* squares(Color c) const;
|
|
|
|
template<PieceType Pt> Square square(Color c) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Castling
|
2012-04-27 03:30:35 -06:00
|
|
|
int can_castle(Color c) const;
|
2014-03-08 07:08:55 -07:00
|
|
|
int can_castle(CastlingRight cr) const;
|
|
|
|
bool castling_impeded(CastlingRight cr) const;
|
|
|
|
Square castling_rook_square(CastlingRight cr) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Checking
|
|
|
|
Bitboard checkers() const;
|
2011-07-16 02:56:34 -06:00
|
|
|
Bitboard discovered_check_candidates() const;
|
2013-12-03 03:06:59 -07:00
|
|
|
Bitboard pinned_pieces(Color c) const;
|
2016-08-27 02:05:42 -06:00
|
|
|
Bitboard check_squares(PieceType pt) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Attacks to/from a given square
|
2009-09-20 02:31:48 -06:00
|
|
|
Bitboard attackers_to(Square s) const;
|
2014-12-07 16:53:33 -07:00
|
|
|
Bitboard attackers_to(Square s, Bitboard occupied) const;
|
2014-04-06 02:50:27 -06:00
|
|
|
Bitboard attacks_from(Piece pc, Square s) const;
|
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;
|
2016-09-12 00:47:19 -06:00
|
|
|
Bitboard slider_blockers(Bitboard sliders, Square s, Bitboard& pinners) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Properties of moves
|
2016-07-03 02:35:44 -06:00
|
|
|
bool legal(Move m) const;
|
2013-09-28 06:43:50 -06:00
|
|
|
bool pseudo_legal(const Move m) const;
|
|
|
|
bool capture(Move m) const;
|
|
|
|
bool capture_or_promotion(Move m) const;
|
2016-07-03 02:35:44 -06:00
|
|
|
bool gives_check(Move m) const;
|
2013-12-03 14:58:39 -07:00
|
|
|
bool advanced_pawn_push(Move m) const;
|
2013-09-28 06:43:50 -06:00
|
|
|
Piece moved_piece(Move m) const;
|
2016-09-03 10:14:01 -06:00
|
|
|
Piece captured_piece() const;
|
2010-03-08 06:57:01 -07:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Piece specific
|
2013-09-28 06:43:50 -06:00
|
|
|
bool pawn_passed(Color c, Square s) const;
|
|
|
|
bool opposite_bishops() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Doing and undoing moves
|
Compute checkers from scratch
This micro-optimization only complicates the code and provides no benefit.
Removing it is even a speedup on my machine (i7-3770k, linux, gcc 4.9.1):
stat test master diff
mean 2,403,118 2,390,904 12,214
stdev 12,043 10,620 3,677
speedup 0.51%
P(speedup>0) 100.0%
No functional change.
2015-02-15 00:49:20 -07:00
|
|
|
void do_move(Move m, StateInfo& st, bool givesCheck);
|
2009-02-22 09:49:52 -07:00
|
|
|
void undo_move(Move m);
|
2013-01-27 03:45:01 -07:00
|
|
|
void do_null_move(StateInfo& st);
|
|
|
|
void undo_null_move();
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Static exchange evaluation
|
2014-02-16 05:06:31 -07:00
|
|
|
Value see(Move m) const;
|
|
|
|
Value 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;
|
2014-10-03 22:07:55 -06:00
|
|
|
Key key_after(Move m) const;
|
2011-12-25 03:50:59 -07:00
|
|
|
Key material_key() const;
|
2015-01-07 01:09:41 -07:00
|
|
|
Key pawn_key() const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-01-10 03:57:06 -07:00
|
|
|
// Other properties of the position
|
2012-04-02 11:21:17 -06:00
|
|
|
Color side_to_move() const;
|
2014-06-20 15:40:36 -06:00
|
|
|
Phase game_phase() const;
|
2013-02-16 04:42:22 -07:00
|
|
|
int game_ply() const;
|
2011-01-03 14:31:17 -07:00
|
|
|
bool is_chess960() const;
|
2012-04-06 11:36:46 -06:00
|
|
|
Thread* this_thread() const;
|
2014-02-09 09:31:45 -07:00
|
|
|
uint64_t nodes_searched() const;
|
|
|
|
void set_nodes_searched(uint64_t n);
|
2013-04-10 14:23:48 -06:00
|
|
|
bool is_draw() const;
|
2015-01-18 00:05:05 -07:00
|
|
|
int rule50_count() const;
|
2015-01-07 01:09:41 -07:00
|
|
|
Score psq_score() const;
|
|
|
|
Value non_pawn_material(Color c) const;
|
2010-07-11 10:23:50 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
// Position consistency check, for debugging
|
2015-02-07 11:34:24 -07:00
|
|
|
bool pos_is_ok(int* failedStep = nullptr) const;
|
2012-04-02 11:21:17 -06:00
|
|
|
void flip();
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
private:
|
2012-04-02 11:21:17 -06:00
|
|
|
// Initialization helpers (used while setting up a position)
|
2014-03-08 07:08:55 -07:00
|
|
|
void set_castling_right(Color c, Square rfrom);
|
2014-03-12 15:46:17 -06:00
|
|
|
void set_state(StateInfo* si) const;
|
2016-08-27 02:05:42 -06:00
|
|
|
void set_check_info(StateInfo* si) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
// Other helpers
|
2016-09-03 10:14:01 -06:00
|
|
|
void put_piece(Piece pc, Square s);
|
|
|
|
void remove_piece(Piece pc, Square s);
|
|
|
|
void move_piece(Piece pc, Square from, Square to);
|
2014-03-13 05:53:03 -06:00
|
|
|
template<bool Do>
|
2015-02-08 05:21:50 -07:00
|
|
|
void do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto);
|
2008-10-23 13:43:48 -06:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
// Data members
|
2012-10-21 02:41:23 -06:00
|
|
|
Piece board[SQUARE_NB];
|
|
|
|
Bitboard byTypeBB[PIECE_TYPE_NB];
|
|
|
|
Bitboard byColorBB[COLOR_NB];
|
2016-09-03 10:14:01 -06:00
|
|
|
int pieceCount[PIECE_NB];
|
|
|
|
Square pieceList[PIECE_NB][16];
|
2012-10-21 02:41:23 -06:00
|
|
|
int index[SQUARE_NB];
|
2014-03-08 07:08:55 -07:00
|
|
|
int castlingRightsMask[SQUARE_NB];
|
|
|
|
Square castlingRookSquare[CASTLING_RIGHT_NB];
|
|
|
|
Bitboard castlingPath[CASTLING_RIGHT_NB];
|
2014-02-09 09:31:45 -07:00
|
|
|
uint64_t nodes;
|
2013-02-16 04:42:22 -07:00
|
|
|
int gamePly;
|
2011-07-02 04:01:12 -06:00
|
|
|
Color sideToMove;
|
2012-04-06 11:36:46 -06:00
|
|
|
Thread* thisThread;
|
2009-02-22 12:16:21 -07:00
|
|
|
StateInfo* st;
|
2014-02-18 00:30:13 -07:00
|
|
|
bool chess960;
|
2008-08-31 23:59:13 -06:00
|
|
|
};
|
|
|
|
|
2015-11-07 23:26:39 -07:00
|
|
|
extern std::ostream& operator<<(std::ostream& os, const Position& pos);
|
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
inline Color Position::side_to_move() const {
|
|
|
|
return sideToMove;
|
2010-10-31 03:55:28 -06:00
|
|
|
}
|
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
inline bool Position::empty(Square s) const {
|
|
|
|
return board[s] == NO_PIECE;
|
2010-10-31 03:55:28 -06:00
|
|
|
}
|
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
inline Piece Position::piece_on(Square s) const {
|
|
|
|
return board[s];
|
|
|
|
}
|
|
|
|
|
2013-09-28 06:43:50 -06:00
|
|
|
inline Piece Position::moved_piece(Move m) const {
|
2012-01-09 14:34:00 -07:00
|
|
|
return board[from_sq(m)];
|
|
|
|
}
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
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 pt1, PieceType pt2) const {
|
|
|
|
return byTypeBB[pt1] | byTypeBB[pt2];
|
|
|
|
}
|
|
|
|
|
2012-05-01 05:01:38 -06:00
|
|
|
inline Bitboard Position::pieces(Color c) const {
|
|
|
|
return byColorBB[c];
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Bitboard Position::pieces(Color c, PieceType pt) const {
|
|
|
|
return byColorBB[c] & byTypeBB[pt];
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const {
|
|
|
|
return byColorBB[c] & (byTypeBB[pt1] | byTypeBB[pt2]);
|
2009-09-02 03:57:38 -06:00
|
|
|
}
|
|
|
|
|
2013-06-16 03:59:40 -06:00
|
|
|
template<PieceType Pt> inline int Position::count(Color c) const {
|
2016-09-03 10:14:01 -06:00
|
|
|
return pieceCount[make_piece(c, Pt)];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2015-08-04 01:00:52 -06:00
|
|
|
template<PieceType Pt> inline const Square* Position::squares(Color c) const {
|
2016-09-03 10:14:01 -06:00
|
|
|
return pieceList[make_piece(c, Pt)];
|
2009-09-23 14:45:32 -06:00
|
|
|
}
|
|
|
|
|
2015-08-04 01:00:52 -06:00
|
|
|
template<PieceType Pt> inline Square Position::square(Color c) const {
|
2016-09-03 10:14:01 -06:00
|
|
|
assert(pieceCount[make_piece(c, Pt)] == 1);
|
|
|
|
return pieceList[make_piece(c, Pt)][0];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
inline Square Position::ep_square() const {
|
|
|
|
return st->epSquare;
|
|
|
|
}
|
|
|
|
|
2014-03-08 07:08:55 -07:00
|
|
|
inline int Position::can_castle(CastlingRight cr) const {
|
|
|
|
return st->castlingRights & cr;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2012-04-27 03:30:35 -06:00
|
|
|
inline int Position::can_castle(Color c) const {
|
2014-03-08 07:08:55 -07:00
|
|
|
return st->castlingRights & ((WHITE_OO | WHITE_OOO) << (2 * c));
|
2011-06-11 05:41:20 -06:00
|
|
|
}
|
|
|
|
|
2014-03-08 07:08:55 -07:00
|
|
|
inline bool Position::castling_impeded(CastlingRight cr) const {
|
|
|
|
return byTypeBB[ALL_PIECES] & castlingPath[cr];
|
2012-02-27 04:11:18 -07:00
|
|
|
}
|
|
|
|
|
2014-03-08 07:08:55 -07:00
|
|
|
inline Square Position::castling_rook_square(CastlingRight cr) const {
|
|
|
|
return castlingRookSquare[cr];
|
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 {
|
2014-03-09 04:03:02 -06:00
|
|
|
return Pt == BISHOP || Pt == ROOK ? attacks_bb<Pt>(s, byTypeBB[ALL_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
|
|
|
}
|
|
|
|
|
2014-04-06 02:50:27 -06:00
|
|
|
inline Bitboard Position::attacks_from(Piece pc, Square s) const {
|
|
|
|
return attacks_bb(pc, 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-10-30 11:16:28 -06:00
|
|
|
inline Bitboard Position::discovered_check_candidates() const {
|
2016-08-27 02:05:42 -06:00
|
|
|
return st->blockersForKing[~sideToMove] & pieces(sideToMove);
|
2011-10-30 11:16:28 -06:00
|
|
|
}
|
|
|
|
|
2013-12-03 03:06:59 -07:00
|
|
|
inline Bitboard Position::pinned_pieces(Color c) const {
|
2016-08-27 02:05:42 -06:00
|
|
|
return st->blockersForKing[c] & pieces(c);
|
2016-07-03 02:35:44 -06:00
|
|
|
}
|
|
|
|
|
2016-08-27 02:05:42 -06:00
|
|
|
inline Bitboard Position::check_squares(PieceType pt) const {
|
|
|
|
return st->checkSquares[pt];
|
2011-10-30 11:16:28 -06:00
|
|
|
}
|
|
|
|
|
2013-09-28 06:43:50 -06:00
|
|
|
inline bool Position::pawn_passed(Color c, Square s) const {
|
2012-05-01 05:01:38 -06:00
|
|
|
return !(pieces(~c, PAWN) & passed_pawn_mask(c, s));
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2013-12-03 14:58:39 -07:00
|
|
|
inline bool Position::advanced_pawn_push(Move m) const {
|
2013-12-04 09:24:32 -07:00
|
|
|
return type_of(moved_piece(m)) == PAWN
|
|
|
|
&& relative_rank(sideToMove, from_sq(m)) > RANK_4;
|
2013-09-28 06:43:50 -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::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
|
|
|
}
|
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
inline Score Position::psq_score() const {
|
2013-06-09 05:43:30 -06:00
|
|
|
return st->psq;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
inline Value Position::non_pawn_material(Color c) const {
|
2014-12-07 16:53:33 -07:00
|
|
|
return st->nonPawnMaterial[c];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2013-02-16 04:42:22 -07:00
|
|
|
inline int Position::game_ply() const {
|
|
|
|
return gamePly;
|
2010-07-11 10:23:50 -06:00
|
|
|
}
|
|
|
|
|
2015-01-18 00:05:05 -07:00
|
|
|
inline int Position::rule50_count() const {
|
|
|
|
return st->rule50;
|
|
|
|
}
|
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
inline uint64_t Position::nodes_searched() const {
|
|
|
|
return nodes;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline void Position::set_nodes_searched(uint64_t n) {
|
|
|
|
nodes = n;
|
|
|
|
}
|
2008-09-27 05:28:58 -06:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
inline bool Position::opposite_bishops() const {
|
2016-09-03 10:14:01 -06:00
|
|
|
return pieceCount[W_BISHOP] == 1
|
|
|
|
&& pieceCount[B_BISHOP] == 1
|
2015-08-04 01:00:52 -06:00
|
|
|
&& opposite_colors(square<BISHOP>(WHITE), square<BISHOP>(BLACK));
|
2008-08-31 23:59:13 -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
|
|
|
}
|
|
|
|
|
2013-09-28 06:43:50 -06:00
|
|
|
inline bool Position::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));
|
2013-12-06 02:43:17 -07:00
|
|
|
return type_of(m) != NORMAL ? type_of(m) != CASTLING : !empty(to_sq(m));
|
2011-06-22 16:04:57 -06:00
|
|
|
}
|
|
|
|
|
2013-09-28 06:43:50 -06:00
|
|
|
inline bool Position::capture(Move m) const {
|
2009-04-27 08:35:31 -06:00
|
|
|
|
2015-01-07 01:09:41 -07:00
|
|
|
// Castling is encoded as "king captures the rook"
|
2011-10-03 02:56:49 -06:00
|
|
|
assert(is_ok(m));
|
2013-12-01 02:25:10 -07:00
|
|
|
return (!empty(to_sq(m)) && type_of(m) != CASTLING) || type_of(m) == ENPASSANT;
|
2009-10-21 04:41:24 -06:00
|
|
|
}
|
|
|
|
|
2016-09-03 10:14:01 -06:00
|
|
|
inline Piece Position::captured_piece() const {
|
|
|
|
return st->capturedPiece;
|
2010-03-08 06:57:01 -07:00
|
|
|
}
|
|
|
|
|
2012-04-06 11:36:46 -06:00
|
|
|
inline Thread* Position::this_thread() const {
|
|
|
|
return thisThread;
|
|
|
|
}
|
|
|
|
|
2016-09-03 10:14:01 -06:00
|
|
|
inline void Position::put_piece(Piece pc, Square s) {
|
2013-08-01 07:58:38 -06:00
|
|
|
|
2016-09-03 10:14:01 -06:00
|
|
|
board[s] = pc;
|
2013-08-01 07:58:38 -06:00
|
|
|
byTypeBB[ALL_PIECES] |= s;
|
2016-09-03 10:14:01 -06:00
|
|
|
byTypeBB[type_of(pc)] |= s;
|
|
|
|
byColorBB[color_of(pc)] |= s;
|
|
|
|
index[s] = pieceCount[pc]++;
|
|
|
|
pieceList[pc][index[s]] = s;
|
|
|
|
pieceCount[make_piece(color_of(pc), ALL_PIECES)]++;
|
2013-07-29 09:44:58 -06:00
|
|
|
}
|
|
|
|
|
2016-09-03 10:14:01 -06:00
|
|
|
inline void Position::remove_piece(Piece pc, Square s) {
|
2013-08-01 07:58:38 -06:00
|
|
|
|
2013-07-29 09:44:58 -06:00
|
|
|
// WARNING: This is not a reversible operation. If we remove a piece in
|
|
|
|
// do_move() and then replace it in undo_move() we will put it at the end of
|
|
|
|
// the list and not in its original place, it means index[] and pieceList[]
|
|
|
|
// are not guaranteed to be invariant to a do_move() + undo_move() sequence.
|
2013-08-01 07:58:38 -06:00
|
|
|
byTypeBB[ALL_PIECES] ^= s;
|
2016-09-03 10:14:01 -06:00
|
|
|
byTypeBB[type_of(pc)] ^= s;
|
|
|
|
byColorBB[color_of(pc)] ^= s;
|
2015-01-07 01:09:41 -07:00
|
|
|
/* board[s] = NO_PIECE; Not needed, overwritten by the capturing one */
|
2016-09-03 10:14:01 -06:00
|
|
|
Square lastSquare = pieceList[pc][--pieceCount[pc]];
|
2013-07-29 09:44:58 -06:00
|
|
|
index[lastSquare] = index[s];
|
2016-09-03 10:14:01 -06:00
|
|
|
pieceList[pc][index[lastSquare]] = lastSquare;
|
|
|
|
pieceList[pc][pieceCount[pc]] = SQ_NONE;
|
|
|
|
pieceCount[make_piece(color_of(pc), ALL_PIECES)]--;
|
2013-07-29 09:44:58 -06:00
|
|
|
}
|
|
|
|
|
2016-09-03 10:14:01 -06:00
|
|
|
inline void Position::move_piece(Piece pc, Square from, Square to) {
|
2015-02-08 05:21:50 -07:00
|
|
|
|
|
|
|
// index[from] is not updated and becomes stale. This works as long as index[]
|
|
|
|
// is accessed just by known occupied squares.
|
|
|
|
Bitboard from_to_bb = SquareBB[from] ^ SquareBB[to];
|
|
|
|
byTypeBB[ALL_PIECES] ^= from_to_bb;
|
2016-09-03 10:14:01 -06:00
|
|
|
byTypeBB[type_of(pc)] ^= from_to_bb;
|
|
|
|
byColorBB[color_of(pc)] ^= from_to_bb;
|
2015-02-08 05:21:50 -07:00
|
|
|
board[from] = NO_PIECE;
|
2016-09-03 10:14:01 -06:00
|
|
|
board[to] = pc;
|
2015-02-08 05:21:50 -07:00
|
|
|
index[to] = index[from];
|
2016-09-03 10:14:01 -06:00
|
|
|
pieceList[pc][index[to]] = to;
|
2015-02-08 05:21:50 -07:00
|
|
|
}
|
|
|
|
|
2013-07-23 07:31:57 -06:00
|
|
|
#endif // #ifndef POSITION_H_INCLUDED
|