ScaleFactor ScalingFunction<KPsK>::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO); assert(pos.piece_count(strongerSide, PAWN) >= 2); assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO); assert(pos.piece_count(weakerSide, PAWN) == 0); Square ksq = pos.king_square(weakerSide); Bitboard pawns = pos.pieces(PAWN, strongerSide); // Are all pawns on the 'a' file? if ((pawns & ~FileABB) == EmptyBoardBB) { // Does the defending king block the pawns? if ( square_distance(ksq, relative_square(strongerSide, SQ_A8)) <= 1 || ( square_file(ksq) == FILE_A && (in_front_bb(strongerSide, ksq) & pawns) == EmptyBoardBB)) return SCALE_FACTOR_ZERO; } // Are all pawns on the 'h' file? else if ((pawns & ~FileHBB) == EmptyBoardBB) { // Does the defending king block the pawns? if ( square_distance(ksq, relative_square(strongerSide, SQ_H8)) <= 1 || ( square_file(ksq) == FILE_H && (in_front_bb(strongerSide, ksq) & pawns) == EmptyBoardBB)) return SCALE_FACTOR_ZERO; } return SCALE_FACTOR_NONE; }
static int ambiguity(int move, const board_t * board) { int from, to, piece; list_t list[1]; int i, n, m; // init from = move_from(move); to = move_to(move); piece = move_piece(move,board); gen_legal_moves(list,board); // no ambiguity? n = 0; for (i = 0; i < list_size(list); i++) { m = list_move(list,i); if (move_piece(m,board) == piece && move_to(m) == to) { n++; } } if (n == 1) return AMBIGUITY_NONE; // file ambiguity? n = 0; for (i = 0; i < list_size(list); i++) { m = list_move(list,i); if (move_piece(m,board) == piece && move_to(m) == to) { if (square_file(move_from(m)) == square_file(from)) n++; } } if (n == 1) return AMBIGUITY_FILE; // rank ambiguity? n = 0; for (i = 0; i < list_size(list); i++) { m = list_move(list,i); if (move_piece(m,board) == piece && move_to(m) == to) { if (square_rank(move_from(m)) == square_rank(from)) n++; } } if (n == 1) return AMBIGUITY_RANK; // square ambiguity return AMBIGUITY_SQUARE; }
Value EvaluationFunction<KRKP>::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 0); assert(pos.non_pawn_material(weakerSide) == 0); assert(pos.piece_count(weakerSide, PAWN) == 1); Square wksq, wrsq, bksq, bpsq; int tempo = (pos.side_to_move() == strongerSide); wksq = pos.king_square(strongerSide); wrsq = pos.piece_list(strongerSide, ROOK, 0); bksq = pos.king_square(weakerSide); bpsq = pos.piece_list(weakerSide, PAWN, 0); if (strongerSide == BLACK) { wksq = flip_square(wksq); wrsq = flip_square(wrsq); bksq = flip_square(bksq); bpsq = flip_square(bpsq); } Square queeningSq = make_square(square_file(bpsq), RANK_1); Value result; // If the stronger side's king is in front of the pawn, it's a win if (wksq < bpsq && square_file(wksq) == square_file(bpsq)) result = RookValueEndgame - Value(square_distance(wksq, bpsq)); // If the weaker side's king is too far from the pawn and the rook, // it's a win else if ( square_distance(bksq, bpsq) - (tempo ^ 1) >= 3 && square_distance(bksq, wrsq) >= 3) result = RookValueEndgame - Value(square_distance(wksq, bpsq)); // If the pawn is far advanced and supported by the defending king, // the position is drawish else if ( square_rank(bksq) <= RANK_3 && square_distance(bksq, bpsq) == 1 && square_rank(wksq) >= RANK_4 && square_distance(wksq, bpsq) - tempo > 2) result = Value(80 - square_distance(wksq, bpsq) * 8); else result = Value(200) - Value(square_distance(wksq, bpsq + DELTA_S) * 8) + Value(square_distance(bksq, bpsq + DELTA_S) * 8) + Value(square_distance(bpsq, queeningSq) * 8); return strongerSide == pos.side_to_move() ? result : -result; }
ScaleFactor ScalingFunction<KBPKB>::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); assert(pos.piece_count(strongerSide, PAWN) == 1); assert(pos.non_pawn_material(weakerSide) == BishopValueMidgame); assert(pos.piece_count(weakerSide, BISHOP) == 1); assert(pos.piece_count(weakerSide, PAWN) == 0); Square pawnSq = pos.piece_list(strongerSide, PAWN, 0); Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0); Square weakerBishopSq = pos.piece_list(weakerSide, BISHOP, 0); Square weakerKingSq = pos.king_square(weakerSide); // Case 1: Defending king blocks the pawn, and cannot be driven away if ( square_file(weakerKingSq) == square_file(pawnSq) && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq) && ( !same_color_squares(weakerKingSq, strongerBishopSq) || relative_rank(strongerSide, weakerKingSq) <= RANK_6)) return SCALE_FACTOR_ZERO; // Case 2: Opposite colored bishops if (!same_color_squares(strongerBishopSq, weakerBishopSq)) { // We assume that the position is drawn in the following three situations: // // a. The pawn is on rank 5 or further back. // b. The defending king is somewhere in the pawn's path. // c. The defending bishop attacks some square along the pawn's path, // and is at least three squares away from the pawn. // // These rules are probably not perfect, but in practice they work // reasonably well. if (relative_rank(strongerSide, pawnSq) <= RANK_5) return SCALE_FACTOR_ZERO; else { Bitboard path = squares_in_front_of(strongerSide, pawnSq); if (path & pos.pieces(KING, weakerSide)) return SCALE_FACTOR_ZERO; if ( (pos.attacks_from<BISHOP>(weakerBishopSq) & path) && square_distance(weakerBishopSq, pawnSq) >= 3) return SCALE_FACTOR_ZERO; } } return SCALE_FACTOR_NONE; }
ScaleFactor ScalingFunction<KBPsK>::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); assert(pos.piece_count(strongerSide, PAWN) >= 1); // No assertions about the material of weakerSide, because we want draws to // be detected even when the weaker side has some pawns. Bitboard pawns = pos.pieces(PAWN, strongerSide); File pawnFile = square_file(pos.piece_list(strongerSide, PAWN, 0)); // All pawns are on a single rook file ? if ( (pawnFile == FILE_A || pawnFile == FILE_H) && (pawns & ~file_bb(pawnFile)) == EmptyBoardBB) { Square bishopSq = pos.piece_list(strongerSide, BISHOP, 0); Square queeningSq = relative_square(strongerSide, make_square(pawnFile, RANK_8)); Square kingSq = pos.king_square(weakerSide); if ( !same_color_squares(queeningSq, bishopSq) && file_distance(square_file(kingSq), pawnFile) <= 1) { // The bishop has the wrong color, and the defending king is on the // file of the pawn(s) or the neighboring file. Find the rank of the // frontmost pawn. Rank rank; if (strongerSide == WHITE) { for (rank = RANK_7; (rank_bb(rank) & pawns) == EmptyBoardBB; rank--) {} assert(rank >= RANK_2 && rank <= RANK_7); } else { for (rank = RANK_2; (rank_bb(rank) & pawns) == EmptyBoardBB; rank++) {} rank = Rank(rank ^ 7); // HACK to get the relative rank assert(rank >= RANK_2 && rank <= RANK_7); } // If the defending king has distance 1 to the promotion square or // is placed somewhere in front of the pawn, it's a draw. if ( square_distance(kingSq, queeningSq) <= 1 || relative_rank(strongerSide, kingSq) >= rank) return SCALE_FACTOR_ZERO; } } return SCALE_FACTOR_NONE; }
ScaleFactor ScalingFunction<KPKP>::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO); assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO); assert(pos.piece_count(WHITE, PAWN) == 1); assert(pos.piece_count(BLACK, PAWN) == 1); Square wksq, bksq, wpsq; Color stm; if (strongerSide == WHITE) { wksq = pos.king_square(WHITE); bksq = pos.king_square(BLACK); wpsq = pos.piece_list(WHITE, PAWN, 0); stm = pos.side_to_move(); } else { wksq = flip_square(pos.king_square(BLACK)); bksq = flip_square(pos.king_square(WHITE)); wpsq = flip_square(pos.piece_list(BLACK, PAWN, 0)); stm = opposite_color(pos.side_to_move()); } if (square_file(wpsq) >= FILE_E) { wksq = flop_square(wksq); bksq = flop_square(bksq); wpsq = flop_square(wpsq); } // If the pawn has advanced to the fifth rank or further, and is not a // rook pawn, it's too dangerous to assume that it's at least a draw. if ( square_rank(wpsq) >= RANK_5 && square_file(wpsq) != FILE_A) return SCALE_FACTOR_NONE; // Probe the KPK bitbase with the weakest side's pawn removed. If it's a // draw, it's probably at least a draw even with the pawn. return probe_kpk(wksq, wpsq, bksq, stm) ? SCALE_FACTOR_NONE : SCALE_FACTOR_ZERO; }
ScaleFactor ScalingFunction<KBPKN>::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); assert(pos.piece_count(strongerSide, PAWN) == 1); assert(pos.non_pawn_material(weakerSide) == KnightValueMidgame); assert(pos.piece_count(weakerSide, KNIGHT) == 1); assert(pos.piece_count(weakerSide, PAWN) == 0); Square pawnSq = pos.piece_list(strongerSide, PAWN, 0); Square strongerBishopSq = pos.piece_list(strongerSide, BISHOP, 0); Square weakerKingSq = pos.king_square(weakerSide); if ( square_file(weakerKingSq) == square_file(pawnSq) && relative_rank(strongerSide, pawnSq) < relative_rank(strongerSide, weakerKingSq) && ( !same_color_squares(weakerKingSq, strongerBishopSq) || relative_rank(strongerSide, weakerKingSq) <= RANK_6)) return SCALE_FACTOR_ZERO; return SCALE_FACTOR_NONE; }
Value EvaluationFunction<KPK>::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == VALUE_ZERO); assert(pos.non_pawn_material(weakerSide) == VALUE_ZERO); assert(pos.piece_count(strongerSide, PAWN) == 1); assert(pos.piece_count(weakerSide, PAWN) == 0); Square wksq, bksq, wpsq; Color stm; if (strongerSide == WHITE) { wksq = pos.king_square(WHITE); bksq = pos.king_square(BLACK); wpsq = pos.piece_list(WHITE, PAWN, 0); stm = pos.side_to_move(); } else { wksq = flip_square(pos.king_square(BLACK)); bksq = flip_square(pos.king_square(WHITE)); wpsq = flip_square(pos.piece_list(BLACK, PAWN, 0)); stm = opposite_color(pos.side_to_move()); } if (square_file(wpsq) >= FILE_E) { wksq = flop_square(wksq); bksq = flop_square(bksq); wpsq = flop_square(wpsq); } if (!probe_kpk(wksq, wpsq, bksq, stm)) return VALUE_DRAW; Value result = VALUE_KNOWN_WIN + PawnValueEndgame + Value(square_rank(wpsq)); return strongerSide == pos.side_to_move() ? result : -result; }
const std::string move_to_san(Position &pos, Move m) { std::string str; assert(pos.is_ok()); assert(move_is_ok(m)); Square from, to; Piece pc; from = move_from(m); to = move_to(m); pc = pos.piece_on(move_from(m)); if(m == MOVE_NONE) { str = "(none)"; return str; } else if(m == MOVE_NULL) { str = "(null)"; return str; } else if(move_is_long_castle(m) || (int(to - from) == -2 && type_of_piece(pc) == KING)) str = "O-O-O"; else if(move_is_short_castle(m) || (int(to - from) == 2 && type_of_piece(pc) == KING)) str = "O-O"; else { str = ""; if(type_of_piece(pc) == PAWN) { if(pos.move_is_capture(m)) str += file_to_char(square_file(move_from(m))); } else { str += piece_type_to_char(type_of_piece(pc), true); Ambiguity amb = move_ambiguity(pos, m); switch(amb) { case AMBIGUITY_NONE: break; case AMBIGUITY_FILE: str += file_to_char(square_file(from)); break; case AMBIGUITY_RANK: str += rank_to_char(square_rank(from)); break; case AMBIGUITY_BOTH: str += square_to_string(from); break; default: assert(false); } } if(pos.move_is_capture(m)) str += "x"; str += square_to_string(move_to(m)); if(move_promotion(m)) { str += "="; str += piece_type_to_char(move_promotion(m), true); } } // Is the move check? We don't use pos.move_is_check(m) here, because // Position::move_is_check doesn't detect all checks (not castling moves, // promotions and en passant captures). UndoInfo u; pos.do_move(m, u); if(pos.is_check()) str += pos.is_mate()? "#" : "+"; pos.undo_move(m, u); return str; }
Move move_from_san(Position &pos, const std::string &movestr) { assert(pos.is_ok()); MovePicker mp = MovePicker(pos, false, MOVE_NONE, MOVE_NONE, MOVE_NONE, MOVE_NONE, OnePly); // Castling moves if(movestr == "O-O-O") { Move m; while((m = mp.get_next_move()) != MOVE_NONE) if(move_is_long_castle(m) && pos.move_is_legal(m)) return m; return MOVE_NONE; } else if(movestr == "O-O") { Move m; while((m = mp.get_next_move()) != MOVE_NONE) if(move_is_short_castle(m) && pos.move_is_legal(m)) return m; return MOVE_NONE; } // Normal moves const char *cstr = movestr.c_str(); const char *c; char *cc; char str[10]; int i; // Initialize str[] by making a copy of movestr with the characters // 'x', '=', '+' and '#' removed. cc = str; for(i=0, c=cstr; i<10 && *c!='\0' && *c!='\n' && *c!=' '; i++, c++) if(!strchr("x=+#", *c)) { *cc = strchr("nrq", *c)? toupper(*c) : *c; cc++; } *cc = '\0'; int left = 0, right = strlen(str) - 1; PieceType pt = NO_PIECE_TYPE, promotion; Square to; File fromFile = FILE_NONE; Rank fromRank = RANK_NONE; // Promotion? if(strchr("BNRQ", str[right])) { promotion = piece_type_from_char(str[right]); right--; } else promotion = NO_PIECE_TYPE; // Find the moving piece: if(left < right) { if(strchr("BNRQK", str[left])) { pt = piece_type_from_char(str[left]); left++; } else pt = PAWN; } // Find the to square: if(left < right) { if(str[right] < '1' || str[right] > '8' || str[right-1] < 'a' || str[right-1] > 'h') return MOVE_NONE; to = make_square(file_from_char(str[right-1]), rank_from_char(str[right])); right -= 2; } else return MOVE_NONE; // Find the file and/or rank of the from square: if(left <= right) { if(strchr("abcdefgh", str[left])) { fromFile = file_from_char(str[left]); left++; } if(strchr("12345678", str[left])) fromRank = rank_from_char(str[left]); } // Look for a matching move: Move m, move = MOVE_NONE; int matches = 0; while((m = mp.get_next_move()) != MOVE_NONE) { bool match = true; if(pos.type_of_piece_on(move_from(m)) != pt) match = false; else if(move_to(m) != to) match = false; else if(move_promotion(m) != promotion) match = false; else if(fromFile != FILE_NONE && fromFile != square_file(move_from(m))) match = false; else if(fromRank != RANK_NONE && fromRank != square_rank(move_from(m))) match = false; if(match) { move = m; matches++; } } if(matches == 1) return move; else return MOVE_NONE; }
void move_do(board_t * board, int move) { int me, opp; int from, to; int piece, pos, capture; int old_flags, new_flags; int sq, ep_square; int pawn; ASSERT(board_is_ok(board)); ASSERT(move_is_ok(move)); ASSERT(move_is_pseudo(move,board)); // init me = board->turn; opp = colour_opp(me); from = move_from(move); to = move_to(move); piece = board->square[from]; ASSERT(colour_equal(piece,me)); pos = board->pos[from]; ASSERT(pos>=0); // update turn board->turn = opp; board->key ^= random_64(RandomTurn); // update castling rights old_flags = board_flags(board); if (piece_is_king(piece)) { board->castle[me][SideH] = SquareNone; board->castle[me][SideA] = SquareNone; } if (board->castle[me][SideH] == from) board->castle[me][SideH] = SquareNone; if (board->castle[me][SideA] == from) board->castle[me][SideA] = SquareNone; if (board->castle[opp][SideH] == to) board->castle[opp][SideH] = SquareNone; if (board->castle[opp][SideA] == to) board->castle[opp][SideA] = SquareNone; new_flags = board_flags(board); board->key ^= hash_castle_key(new_flags^old_flags); // HACK // update en-passant square ep_square = sq = board->ep_square; if (sq != SquareNone) { board->key ^= random_64(RandomEnPassant+square_file(sq)); board->ep_square = SquareNone; } if (piece_is_pawn(piece) && abs(to-from) == 32) { pawn = piece_make_pawn(opp); if (board->square[to-1] == pawn || board->square[to+1] == pawn) { board->ep_square = sq = (from + to) / 2; board->key ^= random_64(RandomEnPassant+square_file(sq)); } } // update ply number (captures are handled later) board->ply_nb++; if (piece_is_pawn(piece)) board->ply_nb = 0; // conversion // update move number if (me == Black) board->move_nb++; // castle if (colour_equal(board->square[to],me)) { int rank; int king_from, king_to; int rook_from, rook_to; int rook; rank = colour_is_white(me) ? Rank1 : Rank8; king_from = from; rook_from = to; if (to > from) { // h side king_to = square_make(FileG,rank); rook_to = square_make(FileF,rank); } else { // a side king_to = square_make(FileC,rank); rook_to = square_make(FileD,rank); } // remove the rook pos = board->pos[rook_from]; ASSERT(pos>=0); rook = Rook64 | me; // HACK square_clear(board,rook_from,rook); // move the king square_move(board,king_from,king_to,piece); // put the rook back square_set(board,rook_to,rook,pos); ASSERT(board->key==hash_key(board)); return; } // remove the captured piece if (piece_is_pawn(piece) && to == ep_square) { // en-passant capture sq = square_ep_dual(to); capture = board->square[sq]; ASSERT(capture==piece_make_pawn(opp)); square_clear(board,sq,capture); board->ply_nb = 0; // conversion } else { capture = board->square[to]; if (capture != Empty) { // normal capture ASSERT(colour_equal(capture,opp)); ASSERT(!piece_is_king(capture)); square_clear(board,to,capture); board->ply_nb = 0; // conversion } } // move the piece if (move_is_promote(move)) { // promote square_clear(board,from,piece); piece = move_promote_hack(move) | me; // HACK square_set(board,to,piece,pos); } else { // normal move square_move(board,from,to,piece); } ASSERT(board->key==hash_key(board)); }
bool board_to_fen(const board_t * board, char string[], int size) { int pos; int file, rank; int sq, piece; int c; int len; int old_pos; ASSERT(board_is_ok(board)); ASSERT(string!=NULL); ASSERT(size>=92); // init if (size < 92) return false; pos = 0; // piece placement for (rank = 7; rank >= 0; rank--) { for (file = 0; file < 8;) { sq = square_make(file,rank); piece = board->square[sq]; ASSERT(piece==Empty||piece_is_ok(piece)); if (piece == Empty) { len = 0; for (; file < 8 && board->square[square_make(file,rank)] == Empty; file++) { len++; } ASSERT(len>=1&&len<=8); c = '0' + len; } else { c = piece_to_char(piece); file++; } string[pos++] = c; } string[pos++] = '/'; } string[pos-1] = ' '; // HACK: remove the last '/' // active colour string[pos++] = (colour_is_white(board->turn)) ? 'w' : 'b'; string[pos++] = ' '; // castling old_pos = pos; if (option_get_bool("Chess960")) { // FEN-960 if (board->castle[White][SideH] != SquareNone) { string[pos++] = toupper(file_to_char(square_file(board->castle[White][SideH]))); } if (board->castle[White][SideA] != SquareNone) { string[pos++] = toupper(file_to_char(square_file(board->castle[White][SideA]))); } if (board->castle[Black][SideH] != SquareNone) { string[pos++] = tolower(file_to_char(square_file(board->castle[Black][SideH]))); } if (board->castle[Black][SideA] != SquareNone) { string[pos++] = tolower(file_to_char(square_file(board->castle[Black][SideA]))); } } else { // FEN if (board->castle[White][SideH] != SquareNone) string[pos++] = 'K'; if (board->castle[White][SideA] != SquareNone) string[pos++] = 'Q'; if (board->castle[Black][SideH] != SquareNone) string[pos++] = 'k'; if (board->castle[Black][SideA] != SquareNone) string[pos++] = 'q'; } if (pos == old_pos) string[pos++] = '-'; string[pos++] = ' '; // en-passant if (board->ep_square == SquareNone) { string[pos++] = '-'; } else { if (!square_to_string(board->ep_square,&string[pos],3)) return false; pos += 2; } string[pos++] = ' '; // halfmove clock and fullmove number sprintf(&string[pos],"%d %d",board->ply_nb,board->move_nb+1); return true; }
ScaleFactor ScalingFunction<KBPPKB>::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == BishopValueMidgame); assert(pos.piece_count(strongerSide, BISHOP) == 1); assert(pos.piece_count(strongerSide, PAWN) == 2); assert(pos.non_pawn_material(weakerSide) == BishopValueMidgame); assert(pos.piece_count(weakerSide, BISHOP) == 1); assert(pos.piece_count(weakerSide, PAWN) == 0); Square wbsq = pos.piece_list(strongerSide, BISHOP, 0); Square bbsq = pos.piece_list(weakerSide, BISHOP, 0); if (same_color_squares(wbsq, bbsq)) // Not opposite-colored bishops, no scaling return SCALE_FACTOR_NONE; Square ksq = pos.king_square(weakerSide); Square psq1 = pos.piece_list(strongerSide, PAWN, 0); Square psq2 = pos.piece_list(strongerSide, PAWN, 1); Rank r1 = square_rank(psq1); Rank r2 = square_rank(psq2); Square blockSq1, blockSq2; if (relative_rank(strongerSide, psq1) > relative_rank(strongerSide, psq2)) { blockSq1 = psq1 + pawn_push(strongerSide); blockSq2 = make_square(square_file(psq2), square_rank(psq1)); } else { blockSq1 = psq2 + pawn_push(strongerSide); blockSq2 = make_square(square_file(psq1), square_rank(psq2)); } switch (file_distance(psq1, psq2)) { case 0: // Both pawns are on the same file. Easy draw if defender firmly controls // some square in the frontmost pawn's path. if ( square_file(ksq) == square_file(blockSq1) && relative_rank(strongerSide, ksq) >= relative_rank(strongerSide, blockSq1) && !same_color_squares(ksq, wbsq)) return SCALE_FACTOR_ZERO; else return SCALE_FACTOR_NONE; case 1: // Pawns on neighboring files. Draw if defender firmly controls the square // in front of the frontmost pawn's path, and the square diagonally behind // this square on the file of the other pawn. if ( ksq == blockSq1 && !same_color_squares(ksq, wbsq) && ( bbsq == blockSq2 || (pos.attacks_from<BISHOP>(blockSq2) & pos.pieces(BISHOP, weakerSide)) || rank_distance(r1, r2) >= 2)) return SCALE_FACTOR_ZERO; else if ( ksq == blockSq2 && !same_color_squares(ksq, wbsq) && ( bbsq == blockSq1 || (pos.attacks_from<BISHOP>(blockSq1) & pos.pieces(BISHOP, weakerSide)))) return SCALE_FACTOR_ZERO; else return SCALE_FACTOR_NONE; default: // The pawns are not on the same file or adjacent files. No scaling. return SCALE_FACTOR_NONE; } }
ScaleFactor ScalingFunction<KRPKR>::apply(const Position& pos) const { assert(pos.non_pawn_material(strongerSide) == RookValueMidgame); assert(pos.piece_count(strongerSide, PAWN) == 1); assert(pos.non_pawn_material(weakerSide) == RookValueMidgame); assert(pos.piece_count(weakerSide, PAWN) == 0); Square wksq = pos.king_square(strongerSide); Square wrsq = pos.piece_list(strongerSide, ROOK, 0); Square wpsq = pos.piece_list(strongerSide, PAWN, 0); Square bksq = pos.king_square(weakerSide); Square brsq = pos.piece_list(weakerSide, ROOK, 0); // Orient the board in such a way that the stronger side is white, and the // pawn is on the left half of the board. if (strongerSide == BLACK) { wksq = flip_square(wksq); wrsq = flip_square(wrsq); wpsq = flip_square(wpsq); bksq = flip_square(bksq); brsq = flip_square(brsq); } if (square_file(wpsq) > FILE_D) { wksq = flop_square(wksq); wrsq = flop_square(wrsq); wpsq = flop_square(wpsq); bksq = flop_square(bksq); brsq = flop_square(brsq); } File f = square_file(wpsq); Rank r = square_rank(wpsq); Square queeningSq = make_square(f, RANK_8); int tempo = (pos.side_to_move() == strongerSide); // If the pawn is not too far advanced and the defending king defends the // queening square, use the third-rank defence. if ( r <= RANK_5 && square_distance(bksq, queeningSq) <= 1 && wksq <= SQ_H5 && (square_rank(brsq) == RANK_6 || (r <= RANK_3 && square_rank(wrsq) != RANK_6))) return SCALE_FACTOR_ZERO; // The defending side saves a draw by checking from behind in case the pawn // has advanced to the 6th rank with the king behind. if ( r == RANK_6 && square_distance(bksq, queeningSq) <= 1 && square_rank(wksq) + tempo <= RANK_6 && (square_rank(brsq) == RANK_1 || (!tempo && abs(square_file(brsq) - f) >= 3))) return SCALE_FACTOR_ZERO; if ( r >= RANK_6 && bksq == queeningSq && square_rank(brsq) == RANK_1 && (!tempo || square_distance(wksq, wpsq) >= 2)) return SCALE_FACTOR_ZERO; // White pawn on a7 and rook on a8 is a draw if black's king is on g7 or h7 // and the black rook is behind the pawn. if ( wpsq == SQ_A7 && wrsq == SQ_A8 && (bksq == SQ_H7 || bksq == SQ_G7) && square_file(brsq) == FILE_A && (square_rank(brsq) <= RANK_3 || square_file(wksq) >= FILE_D || square_rank(wksq) <= RANK_5)) return SCALE_FACTOR_ZERO; // If the defending king blocks the pawn and the attacking king is too far // away, it's a draw. if ( r <= RANK_5 && bksq == wpsq + DELTA_N && square_distance(wksq, wpsq) - tempo >= 2 && square_distance(wksq, brsq) - tempo >= 2) return SCALE_FACTOR_ZERO; // Pawn on the 7th rank supported by the rook from behind usually wins if the // attacking king is closer to the queening square than the defending king, // and the defending king cannot gain tempi by threatening the attacking rook. if ( r == RANK_7 && f != FILE_A && square_file(wrsq) == f && wrsq != queeningSq && (square_distance(wksq, queeningSq) < square_distance(bksq, queeningSq) - 2 + tempo) && (square_distance(wksq, queeningSq) < square_distance(bksq, wrsq) + tempo)) return ScaleFactor(SCALE_FACTOR_MAX - 2 * square_distance(wksq, queeningSq)); // Similar to the above, but with the pawn further back if ( f != FILE_A && square_file(wrsq) == f && wrsq < wpsq && (square_distance(wksq, queeningSq) < square_distance(bksq, queeningSq) - 2 + tempo) && (square_distance(wksq, wpsq + DELTA_N) < square_distance(bksq, wpsq + DELTA_N) - 2 + tempo) && ( square_distance(bksq, wrsq) + tempo >= 3 || ( square_distance(wksq, queeningSq) < square_distance(bksq, wrsq) + tempo && (square_distance(wksq, wpsq + DELTA_N) < square_distance(bksq, wrsq) + tempo)))) return ScaleFactor( SCALE_FACTOR_MAX - 8 * square_distance(wpsq, queeningSq) - 2 * square_distance(wksq, queeningSq)); // If the pawn is not far advanced, and the defending king is somewhere in // the pawn's path, it's probably a draw. if (r <= RANK_4 && bksq > wpsq) { if (square_file(bksq) == square_file(wpsq)) return ScaleFactor(10); if ( abs(square_file(bksq) - square_file(wpsq)) == 1 && square_distance(wksq, bksq) > 2) return ScaleFactor(24 - 2 * square_distance(wksq, bksq)); } return SCALE_FACTOR_NONE; }
bool move_to_san(int move, const board_t * board, char string[], int size) { int from, to, piece; char tmp_string[256]; ASSERT(move_is_ok(move)); ASSERT(board_is_ok(board)); ASSERT(string!=NULL); ASSERT(size>=8); ASSERT(move_is_legal(move,board)); if (size < 8) return false; // init from = move_from(move); to = move_to(move); string[0] = '\0'; // castle if (move_is_castle(move,board)) { if (to > from) { strcat(string,"O-O"); } else { strcat(string,"O-O-O"); } goto check; } // from piece = board->square[from]; if (piece_is_pawn(piece)) { // pawn if (move_is_capture(move,board)) { sprintf(tmp_string,"%c",file_to_char(square_file(from))); strcat(string,tmp_string); } } else { // piece sprintf(tmp_string,"%c",toupper(piece_to_char(piece))); strcat(string,tmp_string); // ambiguity switch (ambiguity(move,board)) { case AMBIGUITY_NONE: break; case AMBIGUITY_FILE: sprintf(tmp_string,"%c",file_to_char(square_file(from))); strcat(string,tmp_string); break; case AMBIGUITY_RANK: sprintf(tmp_string,"%c",rank_to_char(square_rank(from))); strcat(string,tmp_string); break; case AMBIGUITY_SQUARE: if (!square_to_string(from,tmp_string,256)) return false; strcat(string,tmp_string); break; default: ASSERT(false); break; } } // capture if (move_is_capture(move,board)) strcat(string,"x"); // to if (!square_to_string(to,tmp_string,256)) return false; strcat(string,tmp_string); // promote if (move_is_promote(move)) { sprintf(tmp_string,"=%c",toupper(piece_to_char(move_promote(move,board)))); strcat(string,tmp_string); } // check check: if (move_is_mate(move,board)) { strcat(string,"#"); } else if (move_is_check(move,board)) { strcat(string,"+"); } return true; }
static int move_from_lan(const char string[], const board_t * board) { int len; int move; int promote; char s[256]; int from, to; int colour; int inc; int piece_char; int n; const uint8 * ptr; int piece; int side; ASSERT(string!=NULL); ASSERT(board_is_ok(board)); // init len = strlen(string); if (len != 7) return MoveNone; move = MoveNone; colour = board->turn; // promote promote = 0; switch (string[6]) { case '?': // not a promotion break; case 'N': promote = MovePromoteKnight; break; case 'B': promote = MovePromoteBishop; break; case 'R': promote = MovePromoteRook; break; case 'Q': promote = MovePromoteQueen; break; default: return MoveNone; break; } // to square s[0] = string[4]; s[1] = string[5]; s[2] = '\0'; to = square_from_string(s); if (to == SquareNone) return MoveNone; // known from square? if (string[1] != '?' && string[2] != '?') { // from square s[0] = string[1]; s[1] = string[2]; s[2] = '\0'; from = square_from_string(s); if (from == SquareNone) return MoveNone; // convert "king slide" castling to KxR if (piece_is_king(board->square[from]) && square_rank(to) == square_rank(from) && abs(to-from) > 1) { side = (to > from) ? SideH : SideA; to = board->castle[colour][side]; if (to == SquareNone) return MoveNone; } // move move = move_make(from,to) | promote; return move; } // pawn non-capture? if (string[0] == '?' && string[1] == '?') { if (board->square[to] != Empty) return MoveNone; // useful? inc = (colour_is_white(colour)) ? +16 : -16; from = to - inc; if (board->square[from] == Empty && square_side_rank(to,colour) == Rank4) { from -= inc; } if (board->square[from] != piece_make_pawn(colour)) { // useful? return MoveNone; } // move move = move_make(from,to) | promote; return move; } // pawn capture? piece_char = string[0]; if (piece_char == '?' && string[1] != '?') { piece_char = 'P'; } // attack loop n = 0; for (ptr = board->list[colour]; (from=*ptr) != SquareNone; ptr++) { piece = board->square[from]; if (toupper(piece_to_char(piece)) == piece_char) { if (piece_attack(board,piece,from,to)) { if (true && (string[1] == '?' || file_to_char(square_file(from)) == string[1]) && (string[2] == '?' || rank_to_char(square_rank(from)) == string[2])) { if (!is_pinned(board,from,to,colour)) { move = move_make(from,to) | promote; n++; } } } } } if (n != 1) move = MoveNone; return move; }