Big trailing whitespace cleanup part 1
[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 Marco Costalba
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 "movepick.h"
32 #include "san.h"
33
34 extern SearchStack EmptySearchStack;
35
36 ////
37 //// Local definitions
38 ////
39
40 namespace {
41
42   /// Types
43
44   enum Ambiguity {
45     AMBIGUITY_NONE,
46     AMBIGUITY_FILE,
47     AMBIGUITY_RANK,
48     AMBIGUITY_BOTH
49   };
50
51
52   /// Functions
53
54   Ambiguity move_ambiguity(const Position& pos, Move m);
55   const std::string time_string(int milliseconds);
56   const std::string score_string(Value v);
57 }
58
59
60 ////
61 //// Functions
62 ////
63
64 /// move_to_san() takes a position and a move as input, where it is assumed
65 /// that the move is a legal move from the position. The return value is
66 /// a string containing the move in short algebraic notation.
67
68 const std::string move_to_san(const Position& pos, Move m) {
69
70   assert(pos.is_ok());
71   assert(move_is_ok(m));
72
73   std::string san = "";
74
75   if (m == MOVE_NONE)
76       return "(none)";
77   else if (m == MOVE_NULL)
78       return "(null)";
79   else if (move_is_long_castle(m))
80       san = "O-O-O";
81   else if (move_is_short_castle(m))
82       san = "O-O";
83   else
84   {
85       Piece pc = pos.piece_on(move_from(m));
86       if (type_of_piece(pc) != PAWN)
87       {
88           san += piece_type_to_char(type_of_piece(pc), true);
89           Square from = move_from(m);
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 (type_of_piece(pc) == 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_promotion(m))
114       {
115           san += '=';
116           san += piece_type_to_char(move_promotion(m), true);
117       }
118   }
119   // Is the move check?  We don't use pos.move_is_check(m) here, because
120   // Position::move_is_check doesn't detect all checks (not castling moves,
121   // promotions and en passant captures).
122   UndoInfo u;
123   Position p(pos);
124   p.do_move(m, u);
125   if (p.is_check())
126       san += p.is_mate()? "#" : "+";
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 std::string& movestr) {
138
139   assert(pos.is_ok());
140
141   MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
142
143   // Castling moves
144   if (movestr == "O-O-O" || movestr == "O-O-O+")
145   {
146       Move m;
147       while ((m = mp.get_next_move()) != MOVE_NONE)
148           if (move_is_long_castle(m) && pos.pl_move_is_legal(m))
149               return m;
150
151       return MOVE_NONE;
152   }
153   else if (movestr == "O-O" || movestr == "O-O+")
154   {
155       Move m;
156       while ((m = mp.get_next_move()) != MOVE_NONE)
157           if (move_is_short_castle(m) && pos.pl_move_is_legal(m))
158               return m;
159
160     return MOVE_NONE;
161   }
162
163   // Normal moves. We use a simple FSM to parse the san string.
164   enum { START, TO_FILE, TO_RANK, PROMOTION_OR_CHECK, PROMOTION, CHECK, END };
165   static const std::string pieceLetters = "KQRBN";
166   PieceType pt = NO_PIECE_TYPE, promotion = NO_PIECE_TYPE;
167   File fromFile = FILE_NONE, toFile = FILE_NONE;
168   Rank fromRank = RANK_NONE, toRank = RANK_NONE;
169   Square to;
170   int state = START;
171
172   for (size_t i = 0; i < movestr.length(); i++)
173   {
174       char type, c = movestr[i];
175       if (pieceLetters.find(c) != std::string::npos)
176           type = 'P';
177       else if (c >= 'a' && c <= 'h')
178           type = 'F';
179       else if (c >= '1' && c <= '8')
180           type = 'R';
181       else
182           type = c;
183
184       switch (type) {
185       case 'P':
186           if (state == START)
187           {
188               pt = piece_type_from_char(c);
189               state = TO_FILE;
190           }
191           else if (state == PROMOTION)
192           {
193               promotion = piece_type_from_char(c);
194               state = (i < movestr.length() - 1) ? CHECK : END;
195           }
196           else
197               return MOVE_NONE;
198           break;
199       case 'F':
200           if (state == START)
201           {
202               pt = PAWN;
203               fromFile = toFile = file_from_char(c);
204               state = TO_RANK;
205           }
206           else if (state == TO_FILE)
207           {
208               toFile = file_from_char(c);
209               state = TO_RANK;
210           }
211           else if (state == TO_RANK && toFile != FILE_NONE)
212           {
213               // Previous file was for disambiguation
214               fromFile = toFile;
215               toFile = file_from_char(c);
216           }
217           else
218               return MOVE_NONE;
219           break;
220       case 'R':
221           if (state == TO_RANK)
222           {
223               toRank = rank_from_char(c);
224               state = (i < movestr.length() - 1) ? PROMOTION_OR_CHECK : END;
225           }
226           else if (state == TO_FILE && fromRank == RANK_NONE)
227           {
228               // It's a disambiguation rank instead of a file
229               fromRank = rank_from_char(c);
230           }
231           else
232               return MOVE_NONE;
233           break;
234       case 'x': case 'X':
235           if (state == TO_RANK)
236           {
237               // Previous file was for disambiguation, or it's a pawn capture
238               fromFile = toFile;
239               state = TO_FILE;
240           }
241           else if (state != TO_FILE)
242               return MOVE_NONE;
243           break;
244       case '=':
245           if (state == PROMOTION_OR_CHECK)
246               state = PROMOTION;
247           else
248               return MOVE_NONE;
249           break;
250       case '+': case '#':
251           if (state == PROMOTION_OR_CHECK || state == CHECK)
252               state = END;
253           else
254               return MOVE_NONE;
255           break;
256       default:
257           return MOVE_NONE;
258           break;
259       }
260   }
261
262   if (state != END)
263       return MOVE_NONE;
264
265   // Look for a matching move
266   Move m, move = MOVE_NONE;
267   to = make_square(toFile, toRank);
268   int matches = 0;
269
270   while ((m = mp.get_next_move()) != MOVE_NONE)
271       if (   pos.type_of_piece_on(move_from(m)) == pt
272           && move_to(m) == to
273           && move_promotion(m) == promotion
274           && (fromFile == FILE_NONE || fromFile == square_file(move_from(m)))
275           && (fromRank == RANK_NONE || fromRank == square_rank(move_from(m))))
276       {
277           move = m;
278           matches++;
279       }
280   return (matches == 1 ? move : MOVE_NONE);
281 }
282
283
284 /// line_to_san() takes a position and a line (an array of moves representing
285 /// a sequence of legal moves from the position) as input, and returns a
286 /// string containing the line in short algebraic notation.  If the boolean
287 /// parameter 'breakLines' is true, line breaks are inserted, with a line
288 /// length of 80 characters.  After a line break, 'startColumn' spaces are
289 /// inserted at the beginning of the new line.
290
291 const std::string line_to_san(const Position& pos, Move line[], int startColumn, bool breakLines) {
292
293   UndoInfo u;
294   std::stringstream s;
295   std::string moveStr;
296   size_t length = 0;
297   size_t maxLength = 80 - startColumn;
298   Position p(pos);
299
300   for (int i = 0; line[i] != MOVE_NONE; i++)
301   {
302       moveStr = move_to_san(p, line[i]);
303       length += moveStr.length() + 1;
304       if (breakLines && length > maxLength)
305       {
306           s << '\n' << std::setw(startColumn) << ' ';
307           length = moveStr.length() + 1;
308       }
309       s << moveStr << ' ';
310
311       if (line[i] == MOVE_NULL)
312           p.do_null_move(u);
313       else
314           p.do_move(line[i], u);
315   }
316   return s.str();
317 }
318
319
320 /// pretty_pv() creates a human-readable string from a position and a PV.
321 /// It is used to write search information to the log file (which is created
322 /// when the UCI parameter "Use Search Log" is "true").
323
324 const std::string pretty_pv(const Position& pos, int time, int depth,
325                             uint64_t nodes, Value score, Move pv[]) {
326   std::stringstream s;
327
328   // Depth
329   s << std::setw(2) << depth << "  ";
330
331   // Score
332   s << std::setw(8) << score_string(score);
333
334   // Time
335   s << std::setw(8) << time_string(time) << " ";
336
337   // Nodes
338   if (nodes < 1000000ULL)
339     s << std::setw(8) << nodes << " ";
340   else if (nodes < 1000000000ULL)
341     s << std::setw(7) << nodes/1000ULL << 'k' << " ";
342   else
343     s << std::setw(7) << nodes/1000000ULL << 'M' << " ";
344
345   // PV
346   s << line_to_san(pos, pv, 30, true);
347
348   return s.str();
349 }
350
351
352 namespace {
353
354   Ambiguity move_ambiguity(const Position& pos, Move m) {
355
356     Square from = move_from(m);
357     Square to = move_to(m);
358     Piece pc = pos.piece_on(from);
359
360     // King moves are never ambiguous, because there is never two kings of
361     // the same color.
362     if (type_of_piece(pc) == KING)
363         return AMBIGUITY_NONE;
364
365     MovePicker mp = MovePicker(pos, false, MOVE_NONE, EmptySearchStack, OnePly);
366     Move mv, moveList[8];
367
368     int n = 0;
369     while ((mv = mp.get_next_move()) != MOVE_NONE)
370         if (move_to(mv) == to && pos.piece_on(move_from(mv)) == pc && pos.pl_move_is_legal(mv))
371             moveList[n++] = mv;
372
373     if (n == 1)
374         return AMBIGUITY_NONE;
375
376     int f = 0, r = 0;
377     for (int i = 0; i < n; i++)
378     {
379         if (square_file(move_from(moveList[i])) == square_file(from))
380             f++;
381
382         if (square_rank(move_from(moveList[i])) == square_rank(from))
383             r++;
384     }
385     if (f == 1)
386         return AMBIGUITY_FILE;
387
388     if (r == 1)
389         return AMBIGUITY_RANK;
390
391     return AMBIGUITY_BOTH;
392   }
393
394
395   const std::string time_string(int milliseconds) {
396
397     std::stringstream s;
398     s << std::setfill('0');
399
400     int hours = milliseconds / (1000*60*60);
401     int minutes = (milliseconds - hours*1000*60*60) / (1000*60);
402     int seconds = (milliseconds - hours*1000*60*60 - minutes*1000*60) / 1000;
403
404     if (hours)
405         s << hours << ':';
406
407     s << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
408     return s.str();
409   }
410
411
412   const std::string score_string(Value v) {
413
414     std::stringstream s;
415
416     if (v >= VALUE_MATE - 200)
417         s << "#" << (VALUE_MATE - v + 1) / 2;
418     else if(v <= -VALUE_MATE + 200)
419         s << "-#" << (VALUE_MATE + v) / 2;
420     else
421     {
422         float floatScore = float(v) / float(PawnValueMidgame);
423         if (v >= 0)
424             s << '+';
425
426         s << std::setprecision(2) << std::fixed << floatScore;
427     }
428     return s.str();
429   }
430 }