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

san.cpp pass position as constant reference

Browse source 
Make a copy of the position when needed instead
of passing as a reference. It is cleaner and
let us to simplify also Position::print()

A small space inflate while there.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2008-11-30 01:25:16 +01:00
parent 9d1e4d041d
commit 08265aef81
3 changed files with 109 additions and 115 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/position.cpp
View file

@ -275,9 +275,8 @@ void Position::print(Move m) const {
std::cout << std::endl; std::cout << std::endl;
if (m != MOVE_NONE) if (m != MOVE_NONE)
{ {
Position p(*this);
std::string col = (color_of_piece_on(move_from(m)) == BLACK ? ".." : ""); std::string col = (color_of_piece_on(move_from(m)) == BLACK ? ".." : "");
std::cout << "Move is: " << col << move_to_san(p, m) << std::endl; std::cout << "Move is: " << col << move_to_san(*this, m) << std::endl;
} }
for (Rank rank = RANK_8; rank >= RANK_1; rank--) for (Rank rank = RANK_8; rank >= RANK_1; rank--)
{ {

154
src/san.cpp
View file

@ -51,7 +51,7 @@ namespace {
/// Functions /// Functions
Ambiguity move_ambiguity(Position &pos, Move m); Ambiguity move_ambiguity(const Position& pos, Move m);
const std::string time_string(int milliseconds); const std::string time_string(int milliseconds);
const std::string score_string(Value v); const std::string score_string(Value v);
} }
@ -65,57 +65,51 @@ namespace {
/// that the move is a legal move from the position. The return value is /// that the move is a legal move from the position. The return value is
/// a string containing the move in short algebraic notation. /// a string containing the move in short algebraic notation.
const std::string move_to_san(Position &pos, Move m) { const std::string move_to_san(const Position& pos, Move m) {
std::string str;
assert(pos.is_ok()); assert(pos.is_ok());
assert(move_is_ok(m)); assert(move_is_ok(m));
if(m == MOVE_NONE) { std::string san = "";
str = "(none)";
return str; if (m == MOVE_NONE)
return "(none)";
else if (m == MOVE_NULL)
return "(null)";
else if (move_is_long_castle(m))
san = "O-O-O";
else if (move_is_short_castle(m))
san = "O-O";
else
{
Square from = move_from(m);
Square to = move_to(m);
Piece pc = pos.piece_on(move_from(m));
if (type_of_piece(pc) == PAWN)
{
if (pos.move_is_capture(m))
san += file_to_char(square_file(move_from(m)));
} }
else if(m == MOVE_NULL) { else
str = "(null)"; {
return str; san += piece_type_to_char(type_of_piece(pc), true);
}
else if(move_is_long_castle(m))
str = "O-O-O";
else if(move_is_short_castle(m))
str = "O-O";
else {
Square from, to;
Piece pc;
from = move_from(m); switch (move_ambiguity(pos, m)) {
to = move_to(m);
pc = pos.piece_on(move_from(m));
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: case AMBIGUITY_NONE:
break; break;
case AMBIGUITY_FILE: case AMBIGUITY_FILE:
str += file_to_char(square_file(from)); san += file_to_char(square_file(from));
break; break;
case AMBIGUITY_RANK: case AMBIGUITY_RANK:
str += rank_to_char(square_rank(from)); san += rank_to_char(square_rank(from));
break; break;
case AMBIGUITY_BOTH: case AMBIGUITY_BOTH:
str += square_to_string(from); san += square_to_string(from);
break; break;
default: default:
@ -123,14 +117,15 @@ const std::string move_to_san(Position &pos, Move m) {
} }
} }
if(pos.move_is_capture(m)) if (pos.move_is_capture(m))
str += "x"; san += "x";
str += square_to_string(move_to(m)); san += square_to_string(move_to(m));
if(move_promotion(m)) { if (move_promotion(m))
str += "="; {
str += piece_type_to_char(move_promotion(m), true); san += '=';
san += piece_type_to_char(move_promotion(m), true);
} }
} }
@ -138,12 +133,12 @@ const std::string move_to_san(Position &pos, Move m) {
// Position::move_is_check doesn't detect all checks (not castling moves, // Position::move_is_check doesn't detect all checks (not castling moves,
// promotions and en passant captures). // promotions and en passant captures).
UndoInfo u; UndoInfo u;
pos.do_move(m, u); Position p(pos);
if(pos.is_check()) p.do_move(m, u);
str += pos.is_mate()? "#" : "+"; if (p.is_check())
pos.undo_move(m, u); san += p.is_mate()? "#" : "+";
return str; return san;
} }
@ -152,24 +147,29 @@ const std::string move_to_san(Position &pos, Move m) {
/// the move is returned. On failure (i.e. if the string is unparsable, or /// the move is returned. On failure (i.e. if the string is unparsable, or
/// if the move is illegal or ambiguous), MOVE_NONE is returned. /// if the move is illegal or ambiguous), MOVE_NONE is returned.
Move move_from_san(Position &pos, const std::string &movestr) { Move move_from_san(const Position& pos, const std::string& movestr) {
assert(pos.is_ok()); assert(pos.is_ok());
MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly); MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
// Castling moves // Castling moves
if(movestr == "O-O-O") { if (movestr == "O-O-O")
{
Move m; Move m;
while((m = mp.get_next_move()) != MOVE_NONE) while ((m = mp.get_next_move()) != MOVE_NONE)
if(move_is_long_castle(m) && pos.pl_move_is_legal(m)) if (move_is_long_castle(m) && pos.pl_move_is_legal(m))
return m; return m;
return MOVE_NONE; return MOVE_NONE;
} }
else if(movestr == "O-O") { else if (movestr == "O-O")
{
Move m; Move m;
while((m = mp.get_next_move()) != MOVE_NONE) while ((m = mp.get_next_move()) != MOVE_NONE)
if(move_is_short_castle(m) && pos.pl_move_is_legal(m)) if(move_is_short_castle(m) && pos.pl_move_is_legal(m))
return m; return m;
return MOVE_NONE; return MOVE_NONE;
} }
@ -271,8 +271,8 @@ Move move_from_san(Position &pos, const std::string &movestr) {
/// length of 80 characters. After a line break, 'startColumn' spaces are /// length of 80 characters. After a line break, 'startColumn' spaces are
/// inserted at the beginning of the new line. /// inserted at the beginning of the new line.
const std::string line_to_san(const Position &pos, Move line[], int startColumn, const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
bool breakLines) {
Position p = Position(pos); Position p = Position(pos);
UndoInfo u; UndoInfo u;
std::stringstream s; std::stringstream s;
@ -307,7 +307,7 @@ const std::string line_to_san(const Position &pos, Move line[], int startColumn,
/// It is used to write search information to the log file (which is created /// It is used to write search information to the log file (which is created
/// when the UCI parameter "Use Search Log" is "true"). /// when the UCI parameter "Use Search Log" is "true").
const std::string pretty_pv(const Position &pos, int time, int depth, const std::string pretty_pv(const Position& pos, int time, int depth,
uint64_t nodes, Value score, Move pv[]) { uint64_t nodes, Value score, Move pv[]) {
std::stringstream s; std::stringstream s;
@ -337,43 +337,41 @@ const std::string pretty_pv(const Position &pos, int time, int depth,
namespace { namespace {
Ambiguity move_ambiguity(Position &pos, Move m) { Ambiguity move_ambiguity(const Position& pos, Move m) {
Square from, to;
Piece pc;
from = move_from(m); Square from = move_from(m);
to = move_to(m); Square to = move_to(m);
pc = pos.piece_on(from); Piece pc = pos.piece_on(from);
// King moves are never ambiguous, because there is never two kings of // King moves are never ambiguous, because there is never two kings of
// the same color. // the same color.
if(type_of_piece(pc) == KING) if (type_of_piece(pc) == KING)
return AMBIGUITY_NONE; return AMBIGUITY_NONE;
MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly); MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
Move mv, moveList[8]; Move mv, moveList[8];
int i, j, n;
n = 0; int n = 0;
while((mv = mp.get_next_move()) != MOVE_NONE) while ((mv = mp.get_next_move()) != MOVE_NONE)
if(move_to(mv) == to && pos.piece_on(move_from(mv)) == pc if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv))
&& pos.pl_move_is_legal(mv))
moveList[n++] = mv; moveList[n++] = mv;
if(n == 1)
if (n == 1)
return AMBIGUITY_NONE; return AMBIGUITY_NONE;
j = 0; int f = 0, r = 0;
for(i = 0; i < n; i++) for (int i = 0; i < n; i++)
if(square_file(move_from(moveList[i])) == square_file(from)) {
j++; if (square_file(move_from(moveList[i])) == square_file(from))
if(j == 1) f++;
if (square_rank(move_from(moveList[i])) == square_rank(from))
r++;
}
if (f == 1)
return AMBIGUITY_FILE; return AMBIGUITY_FILE;
j = 0; if (r == 1)
for(i = 0; i < n; i++)
if(square_rank(move_from(moveList[i])) == square_rank(from))
j++;
if(j == 1)
return AMBIGUITY_RANK; return AMBIGUITY_RANK;
return AMBIGUITY_BOTH; return AMBIGUITY_BOTH;

11
src/san.h
View file

@ -36,12 +36,9 @@
//// Prototypes //// Prototypes
//// ////
extern const std::string move_to_san(Position &pos, Move m); extern const std::string move_to_san(const Position& pos, Move m);
extern Move move_from_san(Position &pos, const std::string &str); extern Move move_from_san(const Position& pos, const std::string& str);
extern const std::string line_to_san(const Position &pos, Move line[], extern const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines);
int startColumn, bool breakLines); extern const std::string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes, Value score, Move pv[]);
extern const std::string pretty_pv(const Position &pos, int time, int depth,
uint64_t nodes, Value score, Move pv[]);
#endif // !defined(SAN_H_INCLUDED) #endif // !defined(SAN_H_INCLUDED)