void move_set_attr(board_t *b, move_t *move)
{
int check, mated;
board_t board = *b;
if (move_is_capture(b, move))
move->type = CAPTURE;
else
move->type = NORMAL;
if (PIECE(b->square[move->source]) == KING)
{
int hor = move->destination % 8 - move->source % 8;
if (hor > 1)
move->type = KINGSIDE_CASTLE;
else if (hor < -1)
move->type = QUEENSIDE_CASTLE;
}
make_move(&board, move);
check = in_check(&board, board.turn);
mated = is_mated(&board, board.turn);
if (check && mated)
move->state = MOVE_CHECKMATE;
else if (check)
move->state = MOVE_CHECK;
else if (mated)
move->state = MOVE_STALEMATE;
else
move->state = MOVE_NORMAL;
}
Value
evaluate(const Position &pos, SearchStack *ss)
{
Value score;
Move last_move = (ss - 1)->current_move;
if ((ss - 1)->evaluated && !(move_piece_type(last_move) == kKing && move_is_capture(last_move)) && is_ok(last_move))
{
calc_difference(pos, last_move, ss);
score = ss->black_kpp + ss->white_kpp + ss->kkp + ss->material;
assert(calc_full(pos, ss) == score);
ss->evaluated = true;
score = pos.side_to_move() == kWhite ? -score : score;
score /= kFvScale;
assert(score > -kValueInfinite && score < kValueInfinite);
}
else
{
score = calc_full(pos, ss);
ss->evaluated = true;
score = pos.side_to_move() == kWhite ? -score : score;
score /= kFvScale;
assert(score > -kValueInfinite && score < kValueInfinite);
}
return score + kTempo;
}
static bool capture_is_good(int move, const board_t * board) {
int piece, capture;
ASSERT(move_is_ok(move));
ASSERT(board!=NULL);
ASSERT(MOVE_IS_TACTICAL(move,board));
// special cases
if (MOVE_IS_EN_PASSANT(move)) return true;
if (MOVE_IS_UNDER_PROMOTE(move)) return false; // REMOVE ME?
// captures and queen promotes
capture = board->square[MOVE_TO(move)];
if (capture != Empty) {
// capture
ASSERT(move_is_capture(move,board));
if (MOVE_IS_PROMOTE(move)) return true; // promote-capture
piece = board->square[MOVE_FROM(move)];
if (VALUE_PIECE(capture) >= VALUE_PIECE(piece)) return true;
}
return see_move(move,board,0) >= 0;
}
bool capture_is_good(int move, const board_t * board, bool in_pv) {
#else
static bool capture_is_good(int move, const board_t * board, bool in_pv) {
#endif
int piece, capture;
int see_value; // WHM 11/22/08
ASSERT(move_is_ok(move));
ASSERT(board!=NULL);
ASSERT(move_is_tactical(move,board));
// special cases
if (MOVE_IS_EN_PASSANT(move)) return true;
if (move_is_under_promote(move)) return false; // REMOVE ME? Keep, looks good to me. WHM;
// if (MOVE_IS_PROMOTE(move)) return true; // WHM; promote-to-queen, measures a little weaker
// too many garbage lines going nuts.
// captures and queen promotes
capture = board->square[MOVE_TO(move)];
piece = board->square[MOVE_FROM(move)];
if (capture != Empty) {
// capture
ASSERT(move_is_capture(move,board));
if (MOVE_IS_PROMOTE(move)) return true; // capture a piece on Rank8 and promote to queen
if (VALUE_PIECE(capture) >= VALUE_PIECE(piece)) return true;
}
// return see_move(move,board) >= 0; WHM 11/22/08
// WHM 11/22/08 START
see_value = see_move(move,board);
if (see_value >= 0) return true;
if (TryNodePVQueenPromotes) {
if (in_pv && MOVE_IS_PROMOTE(move)) {
ASSERT(!move_is_under_promote(move));
return true; // WHM:
}
}
if (TryKingAttackSacs || TryKingBoxSacs || TryPasserSacs) {
if (in_pv && see_value > -ValueBishop && capture != Empty) {
ASSERT(COLOUR_IS(capture,COLOUR_OPP(board->turn)));
// king attack sacs.
if (TryKingAttackSacs) {
if (narrow_piece_attack_king(board, piece, MOVE_TO(move), KING_POS(board,COLOUR_OPP(board->turn)))) {
return true;
}
}
// sacrifice attacks around the narrow/close king box can be examined more fully. Rybka lessons.
if (TryKingBoxSacs) {
if (DISTANCE(MOVE_TO(move),KING_POS(board,COLOUR_OPP(board->turn))) <= 1) {
return true;
}
}
// passer sacrifices...
if (TryPasserSacs) {
if (PIECE_IS_PAWN(capture) && PAWN_RANK(MOVE_TO(move),COLOUR_OPP(board->turn)) >= Rank6) {
return true;
}
}
}
} // WHM 11/22/08 END
return false;
}
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;
}
