X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fposition.cpp;h=0d563481c671529dee1474c765172f31fa97a1fc;hp=5a98821d493dde10d9fe2bd020ba17467c1d7ea5;hb=8de29390f2d2bd31585b93ff46eae3051126f666;hpb=a66c73deef420104e74b6645ee60e20b37fd8549 diff --git a/src/position.cpp b/src/position.cpp index 5a98821d..0d563481 100644 --- a/src/position.cpp +++ b/src/position.cpp @@ -2,6 +2,7 @@ Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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 @@ -27,7 +28,6 @@ #include "misc.h" #include "movegen.h" #include "position.h" -#include "psqtab.h" #include "thread.h" #include "tt.h" #include "uci.h" @@ -52,14 +52,13 @@ Key Position::exclusion_key() const { return st->key ^ Zobrist::exclusion; } namespace { const string PieceToChar(" PNBRQK pnbrqk"); -Score psq[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; // min_attacker() is a helper function used by see() to locate the least // valuable attacker for the side to move, remove the attacker we just found // from the bitboards and scan for new X-ray attacks behind it. -template FORCE_INLINE -PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stmAttackers, +template +PieceType min_attacker(const Bitboard* bb, Square to, Bitboard stmAttackers, Bitboard& occupied, Bitboard& attackers) { Bitboard b = stmAttackers & bb[Pt]; @@ -78,30 +77,30 @@ PieceType min_attacker(const Bitboard* bb, const Square& to, const Bitboard& stm return (PieceType)Pt; } -template<> FORCE_INLINE -PieceType min_attacker(const Bitboard*, const Square&, const Bitboard&, Bitboard&, Bitboard&) { +template<> +PieceType min_attacker(const Bitboard*, Square, Bitboard, Bitboard&, Bitboard&) { return KING; // No need to update bitboards: it is the last cycle } } // namespace -/// CheckInfo c'tor +/// CheckInfo constructor CheckInfo::CheckInfo(const Position& pos) { Color them = ~pos.side_to_move(); - ksq = pos.king_square(them); + ksq = pos.square(them); pinned = pos.pinned_pieces(pos.side_to_move()); dcCandidates = pos.discovered_check_candidates(); - checkSq[PAWN] = pos.attacks_from(ksq, them); - checkSq[KNIGHT] = pos.attacks_from(ksq); - checkSq[BISHOP] = pos.attacks_from(ksq); - checkSq[ROOK] = pos.attacks_from(ksq); - checkSq[QUEEN] = checkSq[BISHOP] | checkSq[ROOK]; - checkSq[KING] = 0; + checkSquares[PAWN] = pos.attacks_from(ksq, them); + checkSquares[KNIGHT] = pos.attacks_from(ksq); + checkSquares[BISHOP] = pos.attacks_from(ksq); + checkSquares[ROOK] = pos.attacks_from(ksq); + checkSquares[QUEEN] = checkSquares[BISHOP] | checkSquares[ROOK]; + checkSquares[KING] = 0; } @@ -120,7 +119,7 @@ std::ostream& operator<<(std::ostream& os, const Position& pos) { } os << "\nFen: " << pos.fen() << "\nKey: " << std::hex << std::uppercase - << std::setfill('0') << std::setw(16) << pos.st->key << std::dec << "\nCheckers: "; + << std::setfill('0') << std::setw(16) << pos.key() << std::dec << "\nCheckers: "; for (Bitboard b = pos.checkers(); b; ) os << UCI::square(pop_lsb(&b)) << " "; @@ -130,10 +129,7 @@ std::ostream& operator<<(std::ostream& os, const Position& pos) { /// Position::init() initializes at startup the various arrays used to compute -/// hash keys and the piece square tables. The latter is a two-step operation: -/// Firstly, the white halves of the tables are copied from PSQT[] tables. -/// Secondly, the black halves of the tables are initialized by flipping and -/// changing the sign of the white scores. +/// hash keys. void Position::init() { @@ -160,20 +156,6 @@ void Position::init() { Zobrist::side = rng.rand(); Zobrist::exclusion = rng.rand(); - - for (PieceType pt = PAWN; pt <= KING; ++pt) - { - PieceValue[MG][make_piece(BLACK, pt)] = PieceValue[MG][pt]; - PieceValue[EG][make_piece(BLACK, pt)] = PieceValue[EG][pt]; - - Score v = make_score(PieceValue[MG][pt], PieceValue[EG][pt]); - - for (Square s = SQ_A1; s <= SQ_H8; ++s) - { - psq[WHITE][pt][ s] = (v + PSQT[pt][s]); - psq[BLACK][pt][~s] = -(v + PSQT[pt][s]); - } - } } @@ -285,14 +267,15 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { { Square rsq; Color c = islower(token) ? BLACK : WHITE; + Piece rook = make_piece(c, ROOK); token = char(toupper(token)); if (token == 'K') - for (rsq = relative_square(c, SQ_H1); type_of(piece_on(rsq)) != ROOK; --rsq) {} + for (rsq = relative_square(c, SQ_H1); piece_on(rsq) != rook; --rsq) {} else if (token == 'Q') - for (rsq = relative_square(c, SQ_A1); type_of(piece_on(rsq)) != ROOK; ++rsq) {} + for (rsq = relative_square(c, SQ_A1); piece_on(rsq) != rook; ++rsq) {} else if (token >= 'A' && token <= 'H') rsq = make_square(File(token - 'A'), relative_rank(c, RANK_1)); @@ -333,7 +316,7 @@ void Position::set(const string& fenStr, bool isChess960, Thread* th) { void Position::set_castling_right(Color c, Square rfrom) { - Square kfrom = king_square(c); + Square kfrom = square(c); CastlingSide cs = kfrom < rfrom ? KING_SIDE : QUEEN_SIDE; CastlingRight cr = (c | cs); @@ -366,14 +349,14 @@ void Position::set_state(StateInfo* si) const { si->nonPawnMaterial[WHITE] = si->nonPawnMaterial[BLACK] = VALUE_ZERO; si->psq = SCORE_ZERO; - si->checkersBB = attackers_to(king_square(sideToMove)) & pieces(~sideToMove); + si->checkersBB = attackers_to(square(sideToMove)) & pieces(~sideToMove); for (Bitboard b = pieces(); b; ) { Square s = pop_lsb(&b); Piece pc = piece_on(s); si->key ^= Zobrist::psq[color_of(pc)][type_of(pc)][s]; - si->psq += psq[color_of(pc)][type_of(pc)][s]; + si->psq += PSQT::psq[color_of(pc)][type_of(pc)][s]; } if (si->epSquare != SQ_NONE) @@ -474,7 +457,7 @@ Phase Position::game_phase() const { Bitboard Position::check_blockers(Color c, Color kingColor) const { Bitboard b, pinners, result = 0; - Square ksq = king_square(kingColor); + Square ksq = square(kingColor); // Pinners are sliders that give check when a pinned piece is removed pinners = ( (pieces( ROOK, QUEEN) & PseudoAttacks[ROOK ][ksq]) @@ -516,14 +499,14 @@ bool Position::legal(Move m, Bitboard pinned) const { Square from = from_sq(m); assert(color_of(moved_piece(m)) == us); - assert(piece_on(king_square(us)) == make_piece(us, KING)); + assert(piece_on(square(us)) == make_piece(us, KING)); // En passant captures are a tricky special case. Because they are rather // uncommon, we do it simply by testing whether the king is attacked after // the move is made. if (type_of(m) == ENPASSANT) { - Square ksq = king_square(us); + Square ksq = square(us); Square to = to_sq(m); Square capsq = to - pawn_push(us); Bitboard occupied = (pieces() ^ from ^ capsq) | to; @@ -547,7 +530,7 @@ bool Position::legal(Move m, Bitboard pinned) const { // is moving along the ray towards or away from the king. return !pinned || !(pinned & from) - || aligned(from, to_sq(m), king_square(us)); + || aligned(from, to_sq(m), square(us)); } @@ -610,7 +593,7 @@ bool Position::pseudo_legal(const Move m) const { return false; // Our move must be a blocking evasion or a capture of the checking piece - if (!((between_bb(lsb(checkers()), king_square(us)) | checkers()) & to)) + if (!((between_bb(lsb(checkers()), square(us)) | checkers()) & to)) return false; } // In case of king moves under check we have to remove king so as to catch @@ -635,7 +618,7 @@ bool Position::gives_check(Move m, const CheckInfo& ci) const { Square to = to_sq(m); // Is there a direct check? - if (ci.checkSq[type_of(piece_on(from))] & to) + if (ci.checkSquares[type_of(piece_on(from))] & to) return true; // Is there a discovered check? @@ -725,7 +708,7 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) { do_castling(us, from, to, rfrom, rto); captured = NO_PIECE_TYPE; - st->psq += psq[us][ROOK][rto] - psq[us][ROOK][rfrom]; + st->psq += PSQT::psq[us][ROOK][rto] - PSQT::psq[us][ROOK][rfrom]; k ^= Zobrist::psq[us][ROOK][rfrom] ^ Zobrist::psq[us][ROOK][rto]; } @@ -764,7 +747,7 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) { prefetch(thisThread->materialTable[st->materialKey]); // Update incremental scores - st->psq -= psq[them][captured][capsq]; + st->psq -= PSQT::psq[them][captured][capsq]; // Reset rule 50 counter st->rule50 = 0; @@ -820,7 +803,7 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) { ^ Zobrist::psq[us][PAWN][pieceCount[us][PAWN]]; // Update incremental score - st->psq += psq[us][promotion][to] - psq[us][PAWN][to]; + st->psq += PSQT::psq[us][promotion][to] - PSQT::psq[us][PAWN][to]; // Update material st->nonPawnMaterial[us] += PieceValue[MG][promotion]; @@ -835,7 +818,7 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) { } // Update incremental scores - st->psq += psq[us][pt][to] - psq[us][pt][from]; + st->psq += PSQT::psq[us][pt][to] - PSQT::psq[us][pt][from]; // Set capture piece st->capturedType = captured; @@ -844,7 +827,7 @@ void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) { st->key = k; // Calculate checkers bitboard (if move gives check) - st->checkersBB = givesCheck ? attackers_to(king_square(them)) & pieces(us) : 0; + st->checkersBB = givesCheck ? attackers_to(square(them)) & pieces(us) : 0; sideToMove = ~sideToMove; @@ -1151,8 +1134,8 @@ bool Position::pos_is_ok(int* failedStep) const { if (step == Default) if ( (sideToMove != WHITE && sideToMove != BLACK) - || piece_on(king_square(WHITE)) != W_KING - || piece_on(king_square(BLACK)) != B_KING + || piece_on(square(WHITE)) != W_KING + || piece_on(square(BLACK)) != B_KING || ( ep_square() != SQ_NONE && relative_rank(sideToMove, ep_square()) != RANK_6)) return false; @@ -1160,7 +1143,7 @@ bool Position::pos_is_ok(int* failedStep) const { if (step == King) if ( std::count(board, board + SQUARE_NB, W_KING) != 1 || std::count(board, board + SQUARE_NB, B_KING) != 1 - || attackers_to(king_square(~sideToMove)) & pieces(sideToMove)) + || attackers_to(square(~sideToMove)) & pieces(sideToMove)) return false; if (step == Bitboards) @@ -1205,7 +1188,7 @@ bool Position::pos_is_ok(int* failedStep) const { if ( piece_on(castlingRookSquare[c | s]) != make_piece(c, ROOK) || castlingRightsMask[castlingRookSquare[c | s]] != (c | s) - ||(castlingRightsMask[king_square(c)] & (c | s)) != (c | s)) + ||(castlingRightsMask[square(c)] & (c | s)) != (c | s)) return false; } }