]> git.sesse.net Git - stockfish/blob - src/san.cpp
190121a1f7245a302f17db4edd67758d2d6a0e1e
[stockfish] / src / san.cpp
1 /*
2   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4   Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
5
6   Stockfish is free software: you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation, either version 3 of the License, or
9   (at your option) any later version.
10
11   Stockfish is distributed in the hope that it will be useful,
12   but WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   GNU General Public License for more details.
15
16   You should have received a copy of the GNU General Public License
17   along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20
21 ////
22 //// Includes
23 ////
24
25 #include <cassert>
26 #include <cstring>
27 #include <iomanip>
28 #include <string>
29 #include <sstream>
30
31 #include "history.h"
32 #include "movepick.h"
33 #include "san.h"
34
35 using std::string;
36
37 ////
38 //// Local definitions
39 ////
40
41 namespace {
42
43   enum Ambiguity {
44     AMBIGUITY_NONE,
45     AMBIGUITY_FILE,
46     AMBIGUITY_RANK,
47     AMBIGUITY_BOTH
48   };
49
50   const History H; // Used as dummy argument for MovePicker c'tor
51
52   Ambiguity move_ambiguity(const Position& pos, Move m);
53   const string time_string(int milliseconds);
54   const string score_string(Value v);
55 }
56
57
58 ////
59 //// Functions
60 ////
61
62 /// move_to_san() takes a position and a move as input, where it is assumed
63 /// that the move is a legal move from the position. The return value is
64 /// a string containing the move in short algebraic notation.
65
66 const string move_to_san(Position& pos, Move m) {
67
68   assert(pos.is_ok());
69   assert(move_is_ok(m));
70
71   string san;
72   Square from = move_from(m);
73   Square to = move_to(m);
74   PieceType pt = type_of_piece(pos.piece_on(move_from(m)));
75
76   if (m == MOVE_NONE)
77       return "(none)";
78   else if (m == MOVE_NULL)
79       return "(null)";
80   else if (move_is_long_castle(m)  || (int(to - from) == -2 && pt == KING))
81       san = "O-O-O";
82   else if (move_is_short_castle(m) || (int(to - from) ==  2 && pt == KING))
83       san = "O-O";
84   else
85   {
86       if (pt != PAWN)
87       {
88           san += piece_type_to_char(pt, true);
89
90           switch (move_ambiguity(pos, m)) {
91           case AMBIGUITY_NONE:
92             break;
93           case AMBIGUITY_FILE:
94             san += file_to_char(square_file(from));
95             break;
96           case AMBIGUITY_RANK:
97             san += rank_to_char(square_rank(from));
98             break;
99           case AMBIGUITY_BOTH:
100             san += square_to_string(from);
101             break;
102           default:
103             assert(false);
104           }
105       }
106       if (pos.move_is_capture(m))
107       {
108           if (pt == PAWN)
109               san += file_to_char(square_file(move_from(m)));
110           san += "x";
111       }
112       san += square_to_string(move_to(m));
113       if (move_is_promotion(m))
114       {
115           san += "=";
116           san += piece_type_to_char(move_promotion_piece(m), true);
117       }
118   }
119
120   // The move gives check ? We don't use pos.move_is_check() here
121   // because we need to test for mate after the move is done.
122   StateInfo st;
123   pos.do_move(m, st);
124   if (pos.is_check())
125       san += pos.is_mate() ? "#" : "+";
126   pos.undo_move(m);
127
128   return san;
129 }
130
131
132 /// move_from_san() takes a position and a string as input, and tries to
133 /// interpret the string as a move in short algebraic notation. On success,
134 /// the move is returned.  On failure (i.e. if the string is unparsable, or
135 /// if the move is illegal or ambiguous), MOVE_NONE is returned.
136
137 Move move_from_san(const Position& pos, const string& movestr) {
138
139   assert(pos.is_ok());
140
141   MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H);
142   Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
143
144   // Castling moves
145   if (movestr == "O-O-O" || movestr == "O-O-O+")
146   {
147       Move m;
148       while ((m = mp.get_next_move()) != MOVE_NONE)
149           if (move_is_long_castle(m) && pos.pl_move_is_legal(m, pinned))
150               return m;
151
152       return MOVE_NONE;
153   }
154   else if (movestr == "O-O" || movestr == "O-O+")
155   {
156       Move m;
157       while ((m = mp.get_next_move()) != MOVE_NONE)
158           if (move_is_short_castle(m) && pos.pl_move_is_legal(m, pinned))
159               return m;
160
161     return MOVE_NONE;
162   }
163
164   // Normal moves. We use a simple FSM to parse the san string.
165   enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
166   static const string pieceLetters = "KQRBN";
167   PieceType pt = PIECE_TYPE_NONE, promotion = PIECE_TYPE_NONE;
168   File fromFile = FILE_NONE, toFile = FILE_NONE;
169   Rank fromRank = RANK_NONE, toRank = RANK_NONE;
170   Square to;
171   int state = START;
172
173   for (size_t i = 0; i < movestr.length(); i++)
174   {
175       char type, c = movestr[i];
176       if (pieceLetters.find(c) != string::npos)
177           type = 'P';
178       else if (c >= 'a' && c <= 'h')
179           type = 'F';
180       else if (c >= '1' && c <= '8')
181           type = 'R';
182       else
183           type = c;
184
185       switch (type) {
186       case 'P':
187           if (state == START)
188           {
189               pt = piece_type_from_char(c);
190               state = TO_FILE;
191           }
192           else if (state == PROMOTION)
193           {
194               promotion = piece_type_from_char(c);
195               state = (i < movestr.length() - 1) ? CHECK : END;
196           }
197           else
198               return MOVE_NONE;
199           break;
200       case 'F':
201           if (state == START)
202           {
203               pt = PAWN;
204               fromFile = toFile = file_from_char(c);
205               state = TO_RANK;
206           }
207           else if (state == TO_FILE)
208           {
209               toFile = file_from_char(c);
210               state = TO_RANK;
211           }
212           else if (state == TO_RANK && toFile != FILE_NONE)
213           {
214               // Previous file was for disambiguation
215               fromFile = toFile;
216               toFile = file_from_char(c);
217           }
218           else
219               return MOVE_NONE;
220           break;
221       case 'R':
222           if (state == TO_RANK)
223           {
224               toRank = rank_from_char(c);
225               state = (i < movestr.length() - 1) ? PROMOTION_OR_CHECK : END;
226           }
227           else if (state == TO_FILE && fromRank == RANK_NONE)
228           {
229               // It's a disambiguation rank instead of a file
230               fromRank = rank_from_char(c);
231           }
232           else
233               return MOVE_NONE;
234           break;
235       case 'x': case 'X':
236           if (state == TO_RANK)
237           {
238               // Previous file was for disambiguation, or it's a pawn capture
239               fromFile = toFile;
240               state = TO_FILE;
241           }
242           else if (state != TO_FILE)
243               return MOVE_NONE;
244           break;
245       case '=':
246           if (state == PROMOTION_OR_CHECK)
247               state = PROMOTION;
248           else
249               return MOVE_NONE;
250           break;
251       case '+': case '#':
252           if (state == PROMOTION_OR_CHECK || state == CHECK)
253               state = END;
254           else
255               return MOVE_NONE;
256           break;
257       default:
258           return MOVE_NONE;
259           break;
260       }
261   }
262
263   if (state != END)
264       return MOVE_NONE;
265
266   // Look for a matching move
267   Move m, move = MOVE_NONE;
268   to = make_square(toFile, toRank);
269   int matches = 0;
270
271   while ((m = mp.get_next_move()) != MOVE_NONE)
272       if (   pos.type_of_piece_on(move_from(m)) == pt
273           && move_to(m) == to
274           && move_promotion_piece(m) == promotion
275           && (fromFile == FILE_NONE || fromFile == square_file(move_from(m)))
276           && (fromRank == RANK_NONE || fromRank == square_rank(move_from(m))))
277       {
278           move = m;
279           matches++;
280       }
281   return (matches == 1 ? move : MOVE_NONE);
282 }
283
284
285 /// line_to_san() takes a position and a line (an array of moves representing
286 /// a sequence of legal moves from the position) as input, and returns a
287 /// string containing the line in short algebraic notation.  If the boolean
288 /// parameter 'breakLines' is true, line breaks are inserted, with a line
289 /// length of 80 characters.  After a line break, 'startColumn' spaces are
290 /// inserted at the beginning of the new line.
291
292 const string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
293
294   StateInfo st;
295   std::stringstream s;
296   string moveStr;
297   size_t length = 0;
298   size_t maxLength = 80 - startColumn;
299   Position p(pos, pos.thread());
300
301   for (Move* m = line; *m != MOVE_NONE; m++)
302   {
303       moveStr = move_to_san(p, *m);
304       length += moveStr.length() + 1;
305       if (breakLines && length > maxLength)
306       {
307           s << "\n" << std::setw(startColumn) << " ";
308           length = moveStr.length() + 1;
309       }
310       s << moveStr << ' ';
311
312       if (*m == MOVE_NULL)
313           p.do_null_move(st);
314       else
315           p.do_move(*m, st);
316   }
317   return s.str();
318 }
319
320
321 /// pretty_pv() creates a human-readable string from a position and a PV.
322 /// It is used to write search information to the log file (which is created
323 /// when the UCI parameter "Use Search Log" is "true").
324
325 const string pretty_pv(const Position& pos, int time, int depth, uint64_t nodes,
326                        Value score, ValueType type, Move pv[]) {
327
328   const uint64_t K = 1000;
329   const uint64_t M = 1000000;
330
331   std::stringstream s;
332
333   // Depth
334   s << std::setw(2) << depth << "  ";
335
336   // Score
337   s << (type == VALUE_TYPE_LOWER ? ">" : type == VALUE_TYPE_UPPER ? "<" : " ")
338     << std::setw(7) << score_string(score);
339
340   // Time
341   s << std::setw(8) << time_string(time) << " ";
342
343   // Nodes
344   if (nodes < M)
345       s << std::setw(8) << nodes / 1 << " ";
346   else if (nodes < K * M)
347       s << std::setw(7) << nodes / K << "K ";
348   else
349       s << std::setw(7) << nodes / M << "M ";
350
351   // PV
352   s << line_to_san(pos, pv, 30, true);
353
354   return s.str();
355 }
356
357
358 namespace {
359
360   Ambiguity move_ambiguity(const Position& pos, Move m) {
361
362     Square from = move_from(m);
363     Square to = move_to(m);
364     Piece pc = pos.piece_on(from);
365
366     // King moves are never ambiguous, because there is never two kings of
367     // the same color.
368     if (type_of_piece(pc) == KING)
369         return AMBIGUITY_NONE;
370
371     MovePicker mp = MovePicker(pos, MOVE_NONE, OnePly, H);
372     Bitboard pinned = pos.pinned_pieces(pos.side_to_move());
373     Move mv, moveList[8];
374
375     int n = 0;
376     while ((mv = mp.get_next_move()) != MOVE_NONE)
377         if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv, pinned))
378             moveList[n++] = mv;
379
380     if (n == 1)
381         return AMBIGUITY_NONE;
382
383     int f = 0, r = 0;
384     for (int i = 0; i < n; i++)
385     {
386         if (square_file(move_from(moveList[i])) == square_file(from))
387             f++;
388
389         if (square_rank(move_from(moveList[i])) == square_rank(from))
390             r++;
391     }
392     if (f == 1)
393         return AMBIGUITY_FILE;
394
395     if (r == 1)
396         return AMBIGUITY_RANK;
397
398     return AMBIGUITY_BOTH;
399   }
400
401
402   const string time_string(int millisecs) {
403
404     const int MSecMinute = 1000 * 60;
405     const int MSecHour   = 1000 * 60 * 60;
406
407     std::stringstream s;
408     s << std::setfill('0');
409
410     int hours = millisecs / MSecHour;
411     int minutes = (millisecs - hours * MSecHour) / MSecMinute;
412     int seconds = (millisecs - hours * MSecHour - minutes * MSecMinute) / 1000;
413
414     if (hours)
415         s << hours << ':';
416
417     s << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
418     return s.str();
419   }
420
421
422   const string score_string(Value v) {
423
424     std::stringstream s;
425
426     if (v >= VALUE_MATE - 200)
427         s << "#" << (VALUE_MATE - v + 1) / 2;
428     else if (v <= -VALUE_MATE + 200)
429         s << "-#" << (VALUE_MATE + v) / 2;
430     else
431     {
432         float floatScore = float(v) / float(PawnValueMidgame);
433         if (v >= 0)
434             s << '+';
435
436         s << std::setprecision(2) << std::fixed << floatScore;
437     }
438     return s.str();
439   }
440 }