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
|
2020-01-07 13:35:47 -07:00
|
|
|
Copyright (C) 2015-2020 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>
|
2016-04-17 13:31:19 -06:00
|
|
|
#include <deque>
|
2016-09-17 00:19:06 -06:00
|
|
|
#include <memory> // For std::unique_ptr
|
2015-01-09 04:35:44 -07:00
|
|
|
#include <string>
|
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
|
|
|
|
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;
|
2011-07-20 02:45:40 -06:00
|
|
|
Square epSquare;
|
2009-03-02 09:32:30 -07:00
|
|
|
|
2016-09-17 00:19:06 -06:00
|
|
|
// Not copied when making a move (will be recomputed anyhow)
|
2015-01-07 01:09:41 -07:00
|
|
|
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];
|
Renaming some variables in code
Implements renaming suggestions by Marco Costalba, Günther Demetz,
Gontran Lemaire, Ronald de Man, Stéphane Nicolet, Alain Savard,
Joost VandeVondele, Jerry Donald Watson, Mike Whiteley, xoto10,
and I hope that I haven't forgotten anybody.
Perpetual renaming thread for suggestions:
https://github.com/official-stockfish/Stockfish/issues/1426
No functional change.
2018-03-15 03:44:26 -06:00
|
|
|
Bitboard pinners[COLOR_NB];
|
2016-08-27 02:05:42 -06:00
|
|
|
Bitboard checkSquares[PIECE_TYPE_NB];
|
2020-01-09 12:49:13 -07:00
|
|
|
int repetition;
|
2008-08-31 23:59:13 -06:00
|
|
|
};
|
|
|
|
|
2017-08-13 00:38:39 -06:00
|
|
|
/// A list to keep track of the position states along the setup moves (from the
|
|
|
|
/// start position to the position just before the search starts). Needed by
|
|
|
|
/// 'draw by repetition' detection. Use a std::deque because pointers to
|
|
|
|
/// elements are not invalidated upon list resizing.
|
2016-04-17 13:31:19 -06:00
|
|
|
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.
|
2016-09-17 00:19:06 -06:00
|
|
|
class Thread;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
class Position {
|
|
|
|
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);
|
2016-07-16 00:10:45 -06:00
|
|
|
Position& set(const std::string& code, Color c, StateInfo* si);
|
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;
|
2017-03-08 19:45:09 -07:00
|
|
|
template<PieceType Pt> int count() 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;
|
2019-05-29 02:00:32 -06:00
|
|
|
bool is_on_semiopen_file(Color c, Square s) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Castling
|
2018-12-11 05:47:56 -07:00
|
|
|
int castling_rights(Color c) const;
|
2019-08-12 08:42:28 -06:00
|
|
|
bool can_castle(CastlingRights cr) const;
|
|
|
|
bool castling_impeded(CastlingRights cr) const;
|
|
|
|
Square castling_rook_square(CastlingRights cr) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2012-04-02 11:21:17 -06:00
|
|
|
// Checking
|
|
|
|
Bitboard checkers() const;
|
2018-02-26 17:18:33 -07:00
|
|
|
Bitboard blockers_for_king(Color c) const;
|
2016-08-27 02:05:42 -06:00
|
|
|
Bitboard check_squares(PieceType pt) const;
|
2019-06-09 07:07:36 -06:00
|
|
|
bool is_discovery_check_on_king(Color c, Move m) 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;
|
2017-04-28 21:33:30 -06:00
|
|
|
Bitboard attacks_from(PieceType pt, 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;
|
2019-04-16 15:10:53 -06:00
|
|
|
int pawns_on_same_color_squares(Color c, Square s) const;
|
2008-08-31 23:59:13 -06:00
|
|
|
|
|
|
|
// Doing and undoing moves
|
2016-11-11 06:02:28 -07:00
|
|
|
void do_move(Move m, StateInfo& newSt);
|
2016-11-03 04:45:39 -06:00
|
|
|
void do_move(Move m, StateInfo& newSt, bool givesCheck);
|
2009-02-22 09:49:52 -07:00
|
|
|
void undo_move(Move m);
|
2016-11-03 04:45:39 -06:00
|
|
|
void do_null_move(StateInfo& newSt);
|
2013-01-27 03:45:01 -07:00
|
|
|
void undo_null_move();
|
2008-08-31 23:59:13 -06:00
|
|
|
|
2016-09-17 00:19:06 -06:00
|
|
|
// Static Exchange Evaluation
|
2017-06-24 04:36:07 -06:00
|
|
|
bool see_ge(Move m, Value threshold = VALUE_ZERO) 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;
|
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;
|
Threefold repetition detection
Implement a threefold repetition detection. Below are the examples of
problems fixed by this change.
Loosing move in a drawn position.
position fen 8/k7/3p4/p2P1p2/P2P1P2/8/8/K7 w - - 0 1 moves a1a2 a7a8 a2a1
The old code suggested a loosing move "bestmove a8a7", the new code suggests "bestmove a8b7" leading to a draw.
Incorrect evaluation (happened in a real game in TCEC Season 9).
position fen 4rbkr/1q3pp1/b3pn2/7p/1pN5/1P1BBP1P/P1R2QP1/3R2K1 w - - 5 31 moves e3d4 h8h6 d4e3
The old code evaluated it as "cp 0", the new code evaluation is around "cp -50" which is adequate.
Brings 0.5-1 ELO gain. Passes [-3.00,1.00].
STC: http://tests.stockfishchess.org/tests/view/584ece040ebc5903140c5aea
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 47744 W: 8537 L: 8461 D: 30746
LTC: http://tests.stockfishchess.org/tests/view/584f134d0ebc5903140c5b37
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 36775 W: 4739 L: 4639 D: 27397
Patch has been rewritten into current form for simplification and
logic slightly changed so that return a draw score if the position
repeats once earlier but after or at the root, or repeats twice
strictly before the root. In its original form, repetition at root
was not returned as an immediate draw.
After retestimng testing both version with SPRT[-3, 1], both passed
succesfully, but this version was chosen becuase more natural. There is
an argument about MultiPV in which an extended draw at root may be sensible.
See discussion here:
https://github.com/official-stockfish/Stockfish/pull/925
For documentation, current version passed both at STC and LTC:
STC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 51562 W: 9314 L: 9245 D: 33003
LTC
LLR: 2.96 (-2.94,2.94) [-3.00,1.00]
Total: 115663 W: 14904 L: 14906 D: 85853
bench: 5468995
2016-12-12 08:04:16 -07:00
|
|
|
bool is_draw(int ply) const;
|
Use cycle detection to bound search value
A position which has a move which draws by repetition, or which could have
been reached from an earlier position in the game tree, is considered to be
at least a draw for the side to move.
Cycle detection algorithm by Marcel van Kervink:
https://marcelk.net/2013-04-06/paper/upcoming-rep-v2.pdf
----------------------------
How does the algorithm work in practice? The algorithm is an efficient
method to detect if the side to move has a drawing move, without doing any
move generation, thus possibly giving a cheap cutoffThe most interesting
conditions are both on line 1195:
```
if ( originalKey == (progressKey ^ stp->key)
|| progressKey == Zobrist::side)
```
This uses the position keys as a sort-of Bloom filter, to avoid the expensive
checks which follow. For "upcoming repetition" consider the opening Nf3 Nf6 Ng1.
The XOR of this position's key with the starting position gives their difference,
which can be used to look up black's repeating move (Ng8). But that look-up is
expensive, so line 1195 checks that the white pieces are on their original squares.
This is the subtlest part of the algorithm, but the basic idea in the above game
is there are 4 positions (starting position and the one after each move). An XOR
of the first pair (startpos and after Nf3) gives a key matching Nf3. An XOR of
the second pair (after Nf6 and after Ng1) gives a key matching the move Ng1. But
since the difference in each pair is the location of the white knight those keys
are "identical" (not quite because while there are 4 keys the the side to move
changed 3 times, so the keys differ by Zobrist::side). The loop containing line
1195 does this pair-wise XOR-ing.
Continuing the example, after line 1195 determines that the white pieces are
back where they started we still need to make sure the changes in the black
pieces represents a legal move. This is done by looking up the "moveKey" to
see if it corresponds to possible move, and that there are no pieces blocking
its way. There is the additional complication that, to match the behavior of
is_draw(), if the repetition is not inside the search tree then there must be
an additional repetition in the game history. Since a position can have more
than one upcoming repetition a simple count does not suffice. So there is a
search loop ending on line 1215.
On the other hand, the "no-progress' is the same thing but offset by 1 ply.
I like the concept but think it currently has minimal or negative benefit,
and I'd be happy to remove it if that would get the patch accepted. This
will not, however, save many lines of code.
-----------------------------
STC:
LLR: 2.95 (-2.94,2.94) [0.00,5.00]
Total: 36430 W: 7446 L: 7150 D: 21834
http://tests.stockfishchess.org/tests/view/5afc123f0ebc591fdf408dfc
LTC:
LLR: 2.96 (-2.94,2.94) [0.00,5.00]
Total: 12998 W: 2045 L: 1876 D: 9077
http://tests.stockfishchess.org/tests/view/5afc2c630ebc591fdf408e0c
How could we continue after the patch:
• The code in search() that checks for cycles has numerous possible variants.
Perhaps the check need could be done in qsearch() too.
• The biggest improvement would be to get "no progress" to be of actual benefit,
and it would be helpful understand why it (probably) isn't. Perhaps there is an
interaction with the transposition table or the (fantastically complex) tree
search. Perhaps this would be hard to fix, but there may be a simple oversight.
Closes https://github.com/official-stockfish/Stockfish/pull/1575
Bench: 4550412
2018-05-16 14:47:41 -06:00
|
|
|
bool has_game_cycle(int ply) const;
|
2018-04-18 10:38:38 -06:00
|
|
|
bool has_repeated() 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;
|
2017-03-08 19:45:09 -07:00
|
|
|
Value non_pawn_material() const;
|
2010-07-11 10:23:50 -06:00
|
|
|
|
2008-08-31 23:59:13 -06:00
|
|
|
// Position consistency check, for debugging
|
2017-06-24 04:36:07 -06:00
|
|
|
bool pos_is_ok() 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];
|
2013-02-16 04:42:22 -07:00
|
|
|
int gamePly;
|
2011-07-02 04:01:12 -06:00
|
|
|
Color sideToMove;
|
2018-06-09 05:45:49 -06:00
|
|
|
Score psq;
|
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
|
|
|
};
|
|
|
|
|
2018-06-09 05:45:49 -06:00
|
|
|
namespace PSQT {
|
|
|
|
extern Score psq[PIECE_NB][SQUARE_NB];
|
|
|
|
}
|
|
|
|
|
2016-11-27 01:11:56 -07:00
|
|
|
extern std::ostream& operator<<(std::ostream& os, const Position& pos);
|
2015-11-07 23:26:39 -07:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2017-03-08 19:45:09 -07:00
|
|
|
template<PieceType Pt> inline int Position::count() const {
|
|
|
|
return pieceCount[make_piece(WHITE, Pt)] + pieceCount[make_piece(BLACK, Pt)];
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2019-05-29 02:00:32 -06:00
|
|
|
inline bool Position::is_on_semiopen_file(Color c, Square s) const {
|
|
|
|
return !(pieces(c, PAWN) & file_bb(s));
|
2019-04-16 08:09:36 -06:00
|
|
|
}
|
|
|
|
|
2019-08-12 08:42:28 -06:00
|
|
|
inline bool Position::can_castle(CastlingRights cr) const {
|
2014-03-08 07:08:55 -07:00
|
|
|
return st->castlingRights & cr;
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2018-12-11 05:47:56 -07:00
|
|
|
inline int Position::castling_rights(Color c) const {
|
2019-01-02 00:31:03 -07:00
|
|
|
return st->castlingRights & (c == WHITE ? WHITE_CASTLING : BLACK_CASTLING);
|
2011-06-11 05:41:20 -06:00
|
|
|
}
|
|
|
|
|
2019-08-12 08:42:28 -06:00
|
|
|
inline bool Position::castling_impeded(CastlingRights cr) const {
|
2020-01-09 12:49:13 -07:00
|
|
|
assert(cr == WHITE_OO || cr == WHITE_OOO || cr == BLACK_OO || cr == BLACK_OOO);
|
|
|
|
|
2014-03-08 07:08:55 -07:00
|
|
|
return byTypeBB[ALL_PIECES] & castlingPath[cr];
|
2012-02-27 04:11:18 -07:00
|
|
|
}
|
|
|
|
|
2019-08-12 08:42:28 -06:00
|
|
|
inline Square Position::castling_rook_square(CastlingRights cr) const {
|
2020-01-09 12:49:13 -07:00
|
|
|
assert(cr == WHITE_OO || cr == WHITE_OOO || cr == BLACK_OO || cr == BLACK_OOO);
|
|
|
|
|
2014-03-08 07:08:55 -07:00
|
|
|
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 {
|
2019-10-18 18:20:38 -06:00
|
|
|
static_assert(Pt != PAWN, "Pawn attacks need color");
|
|
|
|
|
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)
|
2017-04-28 21:33:30 -06:00
|
|
|
: PseudoAttacks[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 {
|
2017-04-28 21:33:30 -06:00
|
|
|
return PawnAttacks[c][s];
|
2008-08-31 23:59:13 -06:00
|
|
|
}
|
|
|
|
|
2017-04-28 21:33:30 -06:00
|
|
|
inline Bitboard Position::attacks_from(PieceType pt, Square s) const {
|
|
|
|
return attacks_bb(pt, 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
|
|
|
}
|
|
|
|
|
2018-02-26 17:18:33 -07:00
|
|
|
inline Bitboard Position::blockers_for_king(Color c) const {
|
|
|
|
return st->blockersForKing[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
|
|
|
}
|
|
|
|
|
2019-06-09 07:07:36 -06:00
|
|
|
inline bool Position::is_discovery_check_on_king(Color c, Move m) const {
|
|
|
|
return st->blockersForKing[c] & from_sq(m);
|
|
|
|
}
|
|
|
|
|
2013-09-28 06:43:50 -06:00
|
|
|
inline bool Position::pawn_passed(Color c, Square s) const {
|
2019-02-08 02:36:03 -07:00
|
|
|
return !(pieces(~c, PAWN) & passed_pawn_span(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
|
2019-03-31 04:02:19 -06:00
|
|
|
&& relative_rank(sideToMove, to_sq(m)) > RANK_5;
|
2013-09-28 06:43:50 -06:00
|
|
|
}
|
|
|
|
|
2019-04-16 15:10:53 -06:00
|
|
|
inline int Position::pawns_on_same_color_squares(Color c, Square s) const {
|
|
|
|
return popcount(pieces(c, PAWN) & ((DarkSquares & s) ? DarkSquares : ~DarkSquares));
|
|
|
|
}
|
|
|
|
|
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 {
|
2018-06-09 05:45:49 -06:00
|
|
|
return 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
|
|
|
}
|
|
|
|
|
2017-03-08 19:45:09 -07:00
|
|
|
inline Value Position::non_pawn_material() const {
|
|
|
|
return st->nonPawnMaterial[WHITE] + st->nonPawnMaterial[BLACK];
|
|
|
|
}
|
|
|
|
|
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 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-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 {
|
2011-10-03 02:56:49 -06:00
|
|
|
assert(is_ok(m));
|
2016-09-17 00:19:06 -06:00
|
|
|
// Castling is encoded as "king captures rook"
|
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)]++;
|
2018-06-09 05:45:49 -06:00
|
|
|
psq += PSQT::psq[pc][s];
|
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[]
|
2016-09-17 00:19:06 -06:00
|
|
|
// are not 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)]--;
|
2018-06-09 05:45:49 -06:00
|
|
|
psq -= PSQT::psq[pc][s];
|
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.
|
Make Square and Bitboard operators commutative
As Stockfish developers, we aim to make our code as legible and as close
to simple English as possible. However, one of the more notable exceptions
to this rule concerns operations between Squares and Bitboards.
Prior to this pull request, AND, OR, and XOR were only defined when the
Bitboard was the first operand, and the Square the second. For example,
for a Bitboard b and Square s, "b & s" would be valid but "s & b" would not.
This conflicts with natural reasoning about logical operators, both
mathematically and intuitively, which says that logical operators should
commute.
More dangerously, however, both Square and Bitboard are defined as integers
"under the hood." As a result, code like "s & b" would still compile and give
reasonable bench values. This trap occasionally ensnares even experienced
Stockfish developers, but it is especially dangerous for new developers not
aware of this peculiarity. Because there is no compilation or runtime error,
and a reasonable bench, only a close review by approvers can spot this error
when a test has been submitted--and many times, these bugs have slipped past
review. This is by far the most common logical error on Fishtest, and has
wasted uncountable STC games over the years.
However, it can be fixed by adding three non-functional lines of code. In this
patch, we define the operators when the operands are provided in the opposite
order, i.e., we make AND, OR, and XOR commutative for Bitboards and Squares.
Because these are inline methods and implemented identically, the executable
does not change at all.
This patch has the small side-effect of requiring Squares to be explicitly
cast to integers before AND, OR, or XOR with integers. This is only performed
twice in Stockfish's source code, and again does not change the executable at
all (since Square is an enum defined as an integer anyway).
For demonstration purposes, this pull request also inverts the order of one AND
and one OR, to show that neither the bench nor the executable change. (This
change can be removed before merging, if preferred.)
I hope that this pull request significantly lowers the barrier-of-entry for new
developer to join the Stockfish project. I also hope that this change will improve
our efficiency in using our generous CPU donors' machines, since it will remove
one of the most common causes of buggy tests.
Following helpful review and comments by Michael Stembera (@mstembera), we add
a further clean-up by implementing OR for two Squares, to anticipate additional
traps developers may encounter and handle them cleanly.
Closes https://github.com/official-stockfish/Stockfish/pull/2387
No functional change.
2019-10-31 22:27:19 -06:00
|
|
|
Bitboard fromTo = from | to;
|
2018-06-02 09:41:37 -06:00
|
|
|
byTypeBB[ALL_PIECES] ^= fromTo;
|
|
|
|
byTypeBB[type_of(pc)] ^= fromTo;
|
|
|
|
byColorBB[color_of(pc)] ^= fromTo;
|
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;
|
2018-06-09 05:45:49 -06:00
|
|
|
psq += PSQT::psq[pc][to] - PSQT::psq[pc][from];
|
2015-02-08 05:21:50 -07:00
|
|
|
}
|
|
|
|
|
2016-11-11 06:02:28 -07:00
|
|
|
inline void Position::do_move(Move m, StateInfo& newSt) {
|
|
|
|
do_move(m, newSt, gives_check(m));
|
|
|
|
}
|
|
|
|
|
2013-07-23 07:31:57 -06:00
|
|
|
#endif // #ifndef POSITION_H_INCLUDED
|