kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-29 16:23:09 +00:00
Code Issues Releases Wiki Activity

Use generate_moves() in san.cpp

Browse source 
Instead of MovePicker and cleanup san.cpp

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2010-12-25 11:22:55 +01:00
parent 61c03b9d22
commit a0f0a7dc4f
2 changed files with 70 additions and 71 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/movegen.cpp
View file

@ -659,7 +659,7 @@ namespace {
Color us = pos.side_to_move(); Color us = pos.side_to_move();
if ( (Side == KING_SIDE && pos.can_castle_kingside(us)) if ( (Side == KING_SIDE && pos.can_castle_kingside(us))
||(Side == QUEEN_SIDE && pos.can_castle_queenside(us))) ||(Side == QUEEN_SIDE && pos.can_castle_queenside(us)))
{ {
Color them = opposite_color(us); Color them = opposite_color(us);

139
src/san.cpp
View file

@ -28,8 +28,7 @@
#include <string> #include <string>
#include <sstream> #include <sstream>
#include "history.h" #include "movegen.h"
#include "movepick.h"
#include "san.h" #include "san.h"
using std::string; using std::string;
@ -41,14 +40,9 @@ using std::string;
namespace { namespace {
enum Ambiguity { enum Ambiguity {
AMBIGUITY_NONE, AMBIGUITY_NONE, AMBIGUITY_FILE, AMBIGUITY_RANK, AMBIGUITY_BOTH
AMBIGUITY_FILE,
AMBIGUITY_RANK,
AMBIGUITY_BOTH
}; };
const History H; // Used as dummy argument for MovePicker c'tor
Ambiguity move_ambiguity(const Position& pos, Move m); Ambiguity move_ambiguity(const Position& pos, Move m);
const string time_string(int milliseconds); const string time_string(int milliseconds);
const string score_string(Value v); const string score_string(Value v);
@ -71,13 +65,15 @@ const string move_to_san(Position& pos, Move m) {
string san; string san;
Square from = move_from(m); Square from = move_from(m);
Square to = move_to(m); Square to = move_to(m);
PieceType pt = type_of_piece(pos.piece_on(move_from(m))); PieceType pt = type_of_piece(pos.piece_on(from));
if (m == MOVE_NONE) if (m == MOVE_NONE)
return "(none)"; return "(none)";
else if (m == MOVE_NULL)
if (m == MOVE_NULL)
return "(null)"; return "(null)";
else if (move_is_long_castle(m) || (int(to - from) == -2 && pt == KING))
if (move_is_long_castle(m) || (int(to - from) == -2 && pt == KING))
san = "O-O-O"; san = "O-O-O";
else if (move_is_short_castle(m) || (int(to - from) == 2 && pt == KING)) else if (move_is_short_castle(m) || (int(to - from) == 2 && pt == KING))
san = "O-O"; san = "O-O";
@ -103,16 +99,19 @@ const string move_to_san(Position& pos, Move m) {
assert(false); assert(false);
} }
} }
if (pos.move_is_capture(m)) if (pos.move_is_capture(m))
{ {
if (pt == PAWN) if (pt == PAWN)
san += file_to_char(square_file(move_from(m))); san += file_to_char(square_file(from));
san += "x";
san += 'x';
} }
san += square_to_string(move_to(m)); san += square_to_string(to);
if (move_is_promotion(m)) if (move_is_promotion(m))
{ {
san += "="; san += '=';
san += piece_type_to_char(move_promotion_piece(m)); san += piece_type_to_char(move_promotion_piece(m));
} }
} }
@ -138,41 +137,43 @@ Move move_from_san(const Position& pos, const string& movestr) {
assert(pos.is_ok()); assert(pos.is_ok());
MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H); enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
Bitboard pinned = pos.pinned_pieces(pos.side_to_move()); static const string pieceLetters = "KQRBN";
MoveStack mlist[MOVES_MAX], *last;
PieceType pt = PIECE_TYPE_NONE, promotion = PIECE_TYPE_NONE;
File fromFile = FILE_NONE, toFile = FILE_NONE;
Rank fromRank = RANK_NONE, toRank = RANK_NONE;
Move move = MOVE_NONE;
Square from, to;
int matches, state = START;
// Generate all legal moves for the given position
last = generate_moves(pos, mlist);
// Castling moves // Castling moves
if (movestr == "O-O-O" || movestr == "O-O-O+") if (movestr == "O-O-O" || movestr == "O-O-O+")
{ {
Move m; for (MoveStack* cur = mlist; cur != last; cur++)
while ((m = mp.get_next_move()) != MOVE_NONE) if (move_is_long_castle(cur->move))
if (move_is_long_castle(m) && pos.pl_move_is_legal(m, pinned)) return cur->move;
return m;
return MOVE_NONE; return MOVE_NONE;
} }
else if (movestr == "O-O" || movestr == "O-O+") else if (movestr == "O-O" || movestr == "O-O+")
{ {
Move m; for (MoveStack* cur = mlist; cur != last; cur++)
while ((m = mp.get_next_move()) != MOVE_NONE) if (move_is_short_castle(cur->move))
if (move_is_short_castle(m) && pos.pl_move_is_legal(m, pinned)) return cur->move;
return m;
return MOVE_NONE; return MOVE_NONE;
} }
// Normal moves. We use a simple FSM to parse the san string. // Normal moves. We use a simple FSM to parse the san string
enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
static const string pieceLetters = "KQRBN";
PieceType pt = PIECE_TYPE_NONE, promotion = PIECE_TYPE_NONE;
File fromFile = FILE_NONE, toFile = FILE_NONE;
Rank fromRank = RANK_NONE, toRank = RANK_NONE;
Square to;
int state = START;
for (size_t i = 0; i < movestr.length(); i++) for (size_t i = 0; i < movestr.length(); i++)
{ {
char type, c = movestr[i]; char type, c = movestr[i];
if (pieceLetters.find(c) != string::npos) if (pieceLetters.find(c) != string::npos)
type = 'P'; type = 'P';
else if (c >= 'a' && c <= 'h') else if (c >= 'a' && c <= 'h')
@ -192,7 +193,7 @@ Move move_from_san(const Position& pos, const string& movestr) {
else if (state == PROMOTION) else if (state == PROMOTION)
{ {
promotion = piece_type_from_char(c); promotion = piece_type_from_char(c);
state = (i < movestr.length() - 1) ? CHECK : END; state = (i < movestr.length() - 1 ? CHECK : END);
} }
else else
return MOVE_NONE; return MOVE_NONE;
@ -232,7 +233,8 @@ Move move_from_san(const Position& pos, const string& movestr) {
else else
return MOVE_NONE; return MOVE_NONE;
break; break;
case 'x': case 'X': case 'x':
case 'X':
if (state == TO_RANK) if (state == TO_RANK)
{ {
// Previous file was for disambiguation, or it's a pawn capture // Previous file was for disambiguation, or it's a pawn capture
@ -248,7 +250,8 @@ Move move_from_san(const Position& pos, const string& movestr) {
else else
return MOVE_NONE; return MOVE_NONE;
break; break;
case '+': case '#': case '+':
case '#':
if (state == PROMOTION_OR_CHECK || state == CHECK) if (state == PROMOTION_OR_CHECK || state == CHECK)
state = END; state = END;
else else
@ -263,22 +266,25 @@ Move move_from_san(const Position& pos, const string& movestr) {
if (state != END) if (state != END)
return MOVE_NONE; return MOVE_NONE;
// Look for a matching move // Look for an unambiguous matching move
Move m, move = MOVE_NONE;
to = make_square(toFile, toRank); to = make_square(toFile, toRank);
int matches = 0; matches = 0;
while ((m = mp.get_next_move()) != MOVE_NONE) for (MoveStack* cur = mlist; cur != last; cur++)
if ( pos.type_of_piece_on(move_from(m)) == pt {
&& move_to(m) == to from = move_from(cur->move);
&& move_promotion_piece(m) == promotion
&& (fromFile == FILE_NONE || fromFile == square_file(move_from(m))) if ( pos.type_of_piece_on(from) == pt
&& (fromRank == RANK_NONE || fromRank == square_rank(move_from(m)))) && move_to(cur->move) == to
&& move_promotion_piece(cur->move) == promotion
&& (fromFile == FILE_NONE || fromFile == square_file(from))
&& (fromRank == RANK_NONE || fromRank == square_rank(from)))
{ {
move = m; move = cur->move;
matches++; matches++;
} }
return (matches == 1 ? move : MOVE_NONE); }
return matches == 1 ? move : MOVE_NONE;
} }
@ -359,43 +365,36 @@ namespace {
Ambiguity move_ambiguity(const Position& pos, Move m) { Ambiguity move_ambiguity(const Position& pos, Move m) {
MoveStack mlist[MOVES_MAX], *last;
Move candidates[8];
Square from = move_from(m); Square from = move_from(m);
Square to = move_to(m); Square to = move_to(m);
Piece pc = pos.piece_on(from); Piece pc = pos.piece_on(from);
int matches = 0, f = 0, r = 0;
// King moves are never ambiguous, because there is never two kings of // If there is only one piece 'pc' then move cannot be ambiguous
// the same color. if (pos.piece_count(pos.side_to_move(), type_of_piece(pc)) == 1)
if (type_of_piece(pc) == KING)
return AMBIGUITY_NONE; return AMBIGUITY_NONE;
MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H); // Collect all legal moves of piece 'pc' with destination 'to'
Bitboard pinned = pos.pinned_pieces(pos.side_to_move()); last = generate_moves(pos, mlist);
Move mv, moveList[8]; for (MoveStack* cur = mlist; cur != last; cur++)
if (move_to(cur->move) == to && pos.piece_on(move_from(cur->move)) == pc)
candidates[matches++] = cur->move;
int n = 0; if (matches == 1)
while ((mv = mp.get_next_move()) != MOVE_NONE)
if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv, pinned))
moveList[n++] = mv;
if (n == 1)
return AMBIGUITY_NONE; return AMBIGUITY_NONE;
int f = 0, r = 0; for (int i = 0; i < matches; i++)
for (int i = 0; i < n; i++)
{ {
if (square_file(move_from(moveList[i])) == square_file(from)) if (square_file(move_from(candidates[i])) == square_file(from))
f++; f++;
if (square_rank(move_from(moveList[i])) == square_rank(from)) if (square_rank(move_from(candidates[i])) == square_rank(from))
r++; r++;
} }
if (f == 1)
return AMBIGUITY_FILE;
if (r == 1) return f == 1 ? AMBIGUITY_FILE : r == 1 ? AMBIGUITY_RANK : AMBIGUITY_BOTH;
return AMBIGUITY_RANK;
return AMBIGUITY_BOTH;
} }