Clean up the minification stuff a bit; still not really in use.
[remoteglot] / www / js / chess.js
1 'use strict';
2 /*
3  * Copyright (c) 2014, Jeff Hlywa (jhlywa@gmail.com)
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright notice,
10  *    this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright notice,
12  *    this list of conditions and the following disclaimer in the documentation
13  *    and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25  * POSSIBILITY OF SUCH DAMAGE.
26  *
27  *----------------------------------------------------------------------------*/
28
29 /* minified license below  */
30
31 /*! Copyright (c) 2014, Jeff Hlywa (jhlywa@gmail.com)
32  *  Released under the BSD license
33  *  https://github.com/jhlywa/chess.js/blob/master/LICENSE
34  */
35
36 /** @constructor */
37 var Chess = function(fen) {
38
39   /* jshint indent: false */
40
41   var BLACK = 'b';
42   var WHITE = 'w';
43
44   var EMPTY = -1;
45
46   var PAWN = 'p';
47   var KNIGHT = 'n';
48   var BISHOP = 'b';
49   var ROOK = 'r';
50   var QUEEN = 'q';
51   var KING = 'k';
52
53   var SYMBOLS = 'pnbrqkPNBRQK';
54
55   var DEFAULT_POSITION = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1';
56
57   var POSSIBLE_RESULTS = ['1-0', '0-1', '1/2-1/2', '*'];
58
59   var PAWN_OFFSETS = {
60     b: [16, 32, 17, 15],
61     w: [-16, -32, -17, -15]
62   };
63
64   var PIECE_OFFSETS = {
65     n: [-18, -33, -31, -14,  18, 33, 31,  14],
66     b: [-17, -15,  17,  15],
67     r: [-16,   1,  16,  -1],
68     q: [-17, -16, -15,   1,  17, 16, 15,  -1],
69     k: [-17, -16, -15,   1,  17, 16, 15,  -1]
70   };
71
72   var ATTACKS = [
73     20, 0, 0, 0, 0, 0, 0, 24,  0, 0, 0, 0, 0, 0,20, 0,
74      0,20, 0, 0, 0, 0, 0, 24,  0, 0, 0, 0, 0,20, 0, 0,
75      0, 0,20, 0, 0, 0, 0, 24,  0, 0, 0, 0,20, 0, 0, 0,
76      0, 0, 0,20, 0, 0, 0, 24,  0, 0, 0,20, 0, 0, 0, 0,
77      0, 0, 0, 0,20, 0, 0, 24,  0, 0,20, 0, 0, 0, 0, 0,
78      0, 0, 0, 0, 0,20, 2, 24,  2,20, 0, 0, 0, 0, 0, 0,
79      0, 0, 0, 0, 0, 2,53, 56, 53, 2, 0, 0, 0, 0, 0, 0,
80     24,24,24,24,24,24,56,  0, 56,24,24,24,24,24,24, 0,
81      0, 0, 0, 0, 0, 2,53, 56, 53, 2, 0, 0, 0, 0, 0, 0,
82      0, 0, 0, 0, 0,20, 2, 24,  2,20, 0, 0, 0, 0, 0, 0,
83      0, 0, 0, 0,20, 0, 0, 24,  0, 0,20, 0, 0, 0, 0, 0,
84      0, 0, 0,20, 0, 0, 0, 24,  0, 0, 0,20, 0, 0, 0, 0,
85      0, 0,20, 0, 0, 0, 0, 24,  0, 0, 0, 0,20, 0, 0, 0,
86      0,20, 0, 0, 0, 0, 0, 24,  0, 0, 0, 0, 0,20, 0, 0,
87     20, 0, 0, 0, 0, 0, 0, 24,  0, 0, 0, 0, 0, 0,20
88   ];
89
90   var RAYS = [
91      17,  0,  0,  0,  0,  0,  0, 16,  0,  0,  0,  0,  0,  0, 15, 0,
92       0, 17,  0,  0,  0,  0,  0, 16,  0,  0,  0,  0,  0, 15,  0, 0,
93       0,  0, 17,  0,  0,  0,  0, 16,  0,  0,  0,  0, 15,  0,  0, 0,
94       0,  0,  0, 17,  0,  0,  0, 16,  0,  0,  0, 15,  0,  0,  0, 0,
95       0,  0,  0,  0, 17,  0,  0, 16,  0,  0, 15,  0,  0,  0,  0, 0,
96       0,  0,  0,  0,  0, 17,  0, 16,  0, 15,  0,  0,  0,  0,  0, 0,
97       0,  0,  0,  0,  0,  0, 17, 16, 15,  0,  0,  0,  0,  0,  0, 0,
98       1,  1,  1,  1,  1,  1,  1,  0, -1, -1,  -1,-1, -1, -1, -1, 0,
99       0,  0,  0,  0,  0,  0,-15,-16,-17,  0,  0,  0,  0,  0,  0, 0,
100       0,  0,  0,  0,  0,-15,  0,-16,  0,-17,  0,  0,  0,  0,  0, 0,
101       0,  0,  0,  0,-15,  0,  0,-16,  0,  0,-17,  0,  0,  0,  0, 0,
102       0,  0,  0,-15,  0,  0,  0,-16,  0,  0,  0,-17,  0,  0,  0, 0,
103       0,  0,-15,  0,  0,  0,  0,-16,  0,  0,  0,  0,-17,  0,  0, 0,
104       0,-15,  0,  0,  0,  0,  0,-16,  0,  0,  0,  0,  0,-17,  0, 0,
105     -15,  0,  0,  0,  0,  0,  0,-16,  0,  0,  0,  0,  0,  0,-17
106   ];
107
108   var SHIFTS = { p: 0, n: 1, b: 2, r: 3, q: 4, k: 5 };
109
110   var FLAGS = {
111     NORMAL: 'n',
112     CAPTURE: 'c',
113     BIG_PAWN: 'b',
114     EP_CAPTURE: 'e',
115     PROMOTION: 'p',
116     KSIDE_CASTLE: 'k',
117     QSIDE_CASTLE: 'q'
118   };
119
120   var BITS = {
121     NORMAL: 1,
122     CAPTURE: 2,
123     BIG_PAWN: 4,
124     EP_CAPTURE: 8,
125     PROMOTION: 16,
126     KSIDE_CASTLE: 32,
127     QSIDE_CASTLE: 64
128   };
129
130   var RANK_1 = 7;
131   var RANK_2 = 6;
132   var RANK_3 = 5;
133   var RANK_4 = 4;
134   var RANK_5 = 3;
135   var RANK_6 = 2;
136   var RANK_7 = 1;
137   var RANK_8 = 0;
138
139   var SQUARES = {
140     a8:   0, b8:   1, c8:   2, d8:   3, e8:   4, f8:   5, g8:   6, h8:   7,
141     a7:  16, b7:  17, c7:  18, d7:  19, e7:  20, f7:  21, g7:  22, h7:  23,
142     a6:  32, b6:  33, c6:  34, d6:  35, e6:  36, f6:  37, g6:  38, h6:  39,
143     a5:  48, b5:  49, c5:  50, d5:  51, e5:  52, f5:  53, g5:  54, h5:  55,
144     a4:  64, b4:  65, c4:  66, d4:  67, e4:  68, f4:  69, g4:  70, h4:  71,
145     a3:  80, b3:  81, c3:  82, d3:  83, e3:  84, f3:  85, g3:  86, h3:  87,
146     a2:  96, b2:  97, c2:  98, d2:  99, e2: 100, f2: 101, g2: 102, h2: 103,
147     a1: 112, b1: 113, c1: 114, d1: 115, e1: 116, f1: 117, g1: 118, h1: 119
148   };
149
150   var ROOKS = {
151     w: [{square: SQUARES.a1, flag: BITS.QSIDE_CASTLE},
152         {square: SQUARES.h1, flag: BITS.KSIDE_CASTLE}],
153     b: [{square: SQUARES.a8, flag: BITS.QSIDE_CASTLE},
154         {square: SQUARES.h8, flag: BITS.KSIDE_CASTLE}]
155   };
156
157   var board = new Array(128);
158   var kings = {w: EMPTY, b: EMPTY};
159   var turn = WHITE;
160   var castling = {w: 0, b: 0};
161   var ep_square = EMPTY;
162   var half_moves = 0;
163   var move_number = 1;
164   var history = [];
165   var header = {};
166
167   /* if the user passes in a fen string, load it, else default to
168    * starting position
169    */
170   if (typeof fen === 'undefined') {
171     load(DEFAULT_POSITION);
172   } else {
173     load(fen);
174   }
175
176   function clear() {
177     board = new Array(128);
178     kings = {w: EMPTY, b: EMPTY};
179     turn = WHITE;
180     castling = {w: 0, b: 0};
181     ep_square = EMPTY;
182     half_moves = 0;
183     move_number = 1;
184     history = [];
185     header = {};
186     update_setup(generate_fen());
187   }
188
189   function reset() {
190     load(DEFAULT_POSITION);
191   }
192
193   function load(fen) {
194     var tokens = fen.split(/\s+/);
195     var position = tokens[0];
196     var square = 0;
197     var valid = SYMBOLS + '12345678/';
198
199     if (!validate_fen(fen).valid) {
200       return false;
201     }
202
203     clear();
204
205     for (var i = 0; i < position.length; i++) {
206       var piece = position.charAt(i);
207
208       if (piece === '/') {
209         square += 8;
210       } else if (is_digit(piece)) {
211         square += parseInt(piece, 10);
212       } else {
213         var color = (piece < 'a') ? WHITE : BLACK;
214         put({type: piece.toLowerCase(), color: color}, algebraic(square));
215         square++;
216       }
217     }
218
219     turn = tokens[1];
220
221     if (tokens[2].indexOf('K') > -1) {
222       castling.w |= BITS.KSIDE_CASTLE;
223     }
224     if (tokens[2].indexOf('Q') > -1) {
225       castling.w |= BITS.QSIDE_CASTLE;
226     }
227     if (tokens[2].indexOf('k') > -1) {
228       castling.b |= BITS.KSIDE_CASTLE;
229     }
230     if (tokens[2].indexOf('q') > -1) {
231       castling.b |= BITS.QSIDE_CASTLE;
232     }
233
234     ep_square = (tokens[3] === '-') ? EMPTY : SQUARES[tokens[3]];
235     half_moves = parseInt(tokens[4], 10);
236     move_number = parseInt(tokens[5], 10);
237
238     update_setup(generate_fen());
239
240     return true;
241   }
242
243   function validate_fen(fen) {
244     var errors = {
245        0: 'No errors.',
246        1: 'FEN string must contain six space-delimited fields.',
247        2: '6th field (move number) must be a positive integer.',
248        3: '5th field (half move counter) must be a non-negative integer.',
249        4: '4th field (en-passant square) is invalid.',
250        5: '3rd field (castling availability) is invalid.',
251        6: '2nd field (side to move) is invalid.',
252        7: '1st field (piece positions) does not contain 8 \'/\'-delimited rows.',
253        8: '1st field (piece positions) is invalid [consecutive numbers].',
254        9: '1st field (piece positions) is invalid [invalid piece].',
255       10: '1st field (piece positions) is invalid [row too large].',
256     };
257
258     /* 1st criterion: 6 space-seperated fields? */
259     var tokens = fen.split(/\s+/);
260     if (tokens.length !== 6) {
261       return {valid: false, error_number: 1, error: errors[1]};
262     }
263
264     /* 2nd criterion: move number field is a integer value > 0? */
265     if (isNaN(tokens[5]) || (parseInt(tokens[5], 10) <= 0)) {
266       return {valid: false, error_number: 2, error: errors[2]};
267     }
268
269     /* 3rd criterion: half move counter is an integer >= 0? */
270     if (isNaN(tokens[4]) || (parseInt(tokens[4], 10) < 0)) {
271       return {valid: false, error_number: 3, error: errors[3]};
272     }
273
274     /* 4th criterion: 4th field is a valid e.p.-string? */
275     if (!/^(-|[abcdefgh][36])$/.test(tokens[3])) {
276       return {valid: false, error_number: 4, error: errors[4]};
277     }
278
279     /* 5th criterion: 3th field is a valid castle-string? */
280     if( !/^(KQ?k?q?|Qk?q?|kq?|q|-)$/.test(tokens[2])) {
281       return {valid: false, error_number: 5, error: errors[5]};
282     }
283
284     /* 6th criterion: 2nd field is "w" (white) or "b" (black)? */
285     if (!/^(w|b)$/.test(tokens[1])) {
286       return {valid: false, error_number: 6, error: errors[6]};
287     }
288
289     /* 7th criterion: 1st field contains 8 rows? */
290     var rows = tokens[0].split('/');
291     if (rows.length !== 8) {
292       return {valid: false, error_number: 7, error: errors[7]};
293     }
294
295     /* 8th criterion: every row is valid? */
296     for (var i = 0; i < rows.length; i++) {
297       /* check for right sum of fields AND not two numbers in succession */
298       var sum_fields = 0;
299       var previous_was_number = false;
300
301       for (var k = 0; k < rows[i].length; k++) {
302         if (!isNaN(rows[i][k])) {
303           if (previous_was_number) {
304             return {valid: false, error_number: 8, error: errors[8]};
305           }
306           sum_fields += parseInt(rows[i][k], 10);
307           previous_was_number = true;
308         } else {
309           if (!/^[prnbqkPRNBQK]$/.test(rows[i][k])) {
310             return {valid: false, error_number: 9, error: errors[9]};
311           }
312           sum_fields += 1;
313           previous_was_number = false;
314         }
315       }
316       if (sum_fields !== 8) {
317         return {valid: false, error_number: 10, error: errors[10]};
318       }
319     }
320
321     /* everything's okay! */
322     return {valid: true, error_number: 0, error: errors[0]};
323   }
324
325   function generate_fen() {
326     var empty = 0;
327     var fen = '';
328
329     for (var i = SQUARES.a8; i <= SQUARES.h1; i++) {
330       if (board[i] == null) {
331         empty++;
332       } else {
333         if (empty > 0) {
334           fen += empty;
335           empty = 0;
336         }
337         var color = board[i].color;
338         var piece = board[i].type;
339
340         fen += (color === WHITE) ?
341                  piece.toUpperCase() : piece.toLowerCase();
342       }
343
344       if ((i + 1) & 0x88) {
345         if (empty > 0) {
346           fen += empty;
347         }
348
349         if (i !== SQUARES.h1) {
350           fen += '/';
351         }
352
353         empty = 0;
354         i += 8;
355       }
356     }
357
358     var cflags = '';
359     if (castling[WHITE] & BITS.KSIDE_CASTLE) { cflags += 'K'; }
360     if (castling[WHITE] & BITS.QSIDE_CASTLE) { cflags += 'Q'; }
361     if (castling[BLACK] & BITS.KSIDE_CASTLE) { cflags += 'k'; }
362     if (castling[BLACK] & BITS.QSIDE_CASTLE) { cflags += 'q'; }
363
364     /* do we have an empty castling flag? */
365     cflags = cflags || '-';
366     var epflags = (ep_square === EMPTY) ? '-' : algebraic(ep_square);
367
368     return [fen, turn, cflags, epflags, half_moves, move_number].join(' ');
369   }
370
371   function set_header(args) {
372     for (var i = 0; i < args.length; i += 2) {
373       if (typeof args[i] === 'string' &&
374           typeof args[i + 1] === 'string') {
375         header[args[i]] = args[i + 1];
376       }
377     }
378     return header;
379   }
380
381   /* called when the initial board setup is changed with put() or remove().
382    * modifies the SetUp and FEN properties of the header object.  if the FEN is
383    * equal to the default position, the SetUp and FEN are deleted
384    * the setup is only updated if history.length is zero, ie moves haven't been
385    * made.
386    */
387   function update_setup(fen) {
388     if (history.length > 0) return;
389
390     if (fen !== DEFAULT_POSITION) {
391       header['SetUp'] = '1';
392       header['FEN'] = fen;
393     } else {
394       delete header['SetUp'];
395       delete header['FEN'];
396     }
397   }
398
399   function get(square) {
400     var piece = board[SQUARES[square]];
401     return (piece) ? {type: piece.type, color: piece.color} : null;
402   }
403
404   function put(piece, square) {
405     /* check for valid piece object */
406     if (!('type' in piece && 'color' in piece)) {
407       return false;
408     }
409
410     /* check for piece */
411     if (SYMBOLS.indexOf(piece.type.toLowerCase()) === -1) {
412       return false;
413     }
414
415     /* check for valid square */
416     if (!(square in SQUARES)) {
417       return false;
418     }
419
420     var sq = SQUARES[square];
421
422     /* don't let the user place more than one king */
423     if (piece.type == KING &&
424         !(kings[piece.color] == EMPTY || kings[piece.color] == sq)) {
425       return false;
426     }
427
428     board[sq] = {type: piece.type, color: piece.color};
429     if (piece.type === KING) {
430       kings[piece.color] = sq;
431     }
432
433     update_setup(generate_fen());
434
435     return true;
436   }
437
438   function remove(square) {
439     var piece = get(square);
440     board[SQUARES[square]] = null;
441     if (piece && piece.type === KING) {
442       kings[piece.color] = EMPTY;
443     }
444
445     update_setup(generate_fen());
446
447     return piece;
448   }
449
450   function build_move(board, from, to, flags, promotion) {
451     var move = {
452       color: turn,
453       from: from,
454       to: to,
455       flags: flags,
456       piece: board[from].type
457     };
458
459     if (promotion) {
460       move.flags |= BITS.PROMOTION;
461       move.promotion = promotion;
462     }
463
464     if (board[to]) {
465       move.captured = board[to].type;
466     } else if (flags & BITS.EP_CAPTURE) {
467         move.captured = PAWN;
468     }
469     return move;
470   }
471
472   function generate_moves(options) {
473     function add_move(board, moves, from, to, flags) {
474       /* if pawn promotion */
475       if (board[from].type === PAWN &&
476          (rank(to) === RANK_8 || rank(to) === RANK_1)) {
477           var pieces = [QUEEN, ROOK, BISHOP, KNIGHT];
478           for (var i = 0, len = pieces.length; i < len; i++) {
479             moves.push(build_move(board, from, to, flags, pieces[i]));
480           }
481       } else {
482        moves.push(build_move(board, from, to, flags));
483       }
484     }
485
486     var moves = [];
487     var us = turn;
488     var them = swap_color(us);
489     var second_rank = {b: RANK_7, w: RANK_2};
490
491     var first_sq = SQUARES.a8;
492     var last_sq = SQUARES.h1;
493     var single_square = false;
494
495     /* do we want legal moves? */
496     var legal = (typeof options !== 'undefined' && 'legal' in options) ?
497                 options.legal : true;
498
499     /* are we generating moves for a single square? */
500     if (typeof options !== 'undefined' && 'square' in options) {
501       if (options.square in SQUARES) {
502         first_sq = last_sq = SQUARES[options.square];
503         single_square = true;
504       } else {
505         /* invalid square */
506         return [];
507       }
508     }
509
510     for (var i = first_sq; i <= last_sq; i++) {
511       /* did we run off the end of the board */
512       if (i & 0x88) { i += 7; continue; }
513
514       var piece = board[i];
515       if (piece == null || piece.color !== us) {
516         continue;
517       }
518
519       if (piece.type === PAWN) {
520         /* single square, non-capturing */
521         var square = i + PAWN_OFFSETS[us][0];
522         if (board[square] == null) {
523             add_move(board, moves, i, square, BITS.NORMAL);
524
525           /* double square */
526           square = i + PAWN_OFFSETS[us][1];
527           if (second_rank[us] === rank(i) && board[square] == null) {
528             add_move(board, moves, i, square, BITS.BIG_PAWN);
529           }
530         }
531
532         /* pawn captures */
533         for (var j = 2; j < 4; j++) {
534           square = i + PAWN_OFFSETS[us][j];
535           if (square & 0x88) continue;
536
537           if (board[square] != null &&
538               board[square].color === them) {
539               add_move(board, moves, i, square, BITS.CAPTURE);
540           } else if (square === ep_square) {
541               add_move(board, moves, i, ep_square, BITS.EP_CAPTURE);
542           }
543         }
544       } else {
545         for (var j = 0, len = PIECE_OFFSETS[piece.type].length; j < len; j++) {
546           var offset = PIECE_OFFSETS[piece.type][j];
547           var square = i;
548
549           while (true) {
550             square += offset;
551             if (square & 0x88) break;
552
553             if (board[square] == null) {
554               add_move(board, moves, i, square, BITS.NORMAL);
555             } else {
556               if (board[square].color === us) break;
557               add_move(board, moves, i, square, BITS.CAPTURE);
558               break;
559             }
560
561             /* break, if knight or king */
562             if (piece.type === 'n' || piece.type === 'k') break;
563           }
564         }
565       }
566     }
567
568     /* check for castling if: a) we're generating all moves, or b) we're doing
569      * single square move generation on the king's square
570      */
571     if ((!single_square) || last_sq === kings[us]) {
572       /* king-side castling */
573       if (castling[us] & BITS.KSIDE_CASTLE) {
574         var castling_from = kings[us];
575         var castling_to = castling_from + 2;
576
577         if (board[castling_from + 1] == null &&
578             board[castling_to]       == null &&
579             !attacked(them, kings[us]) &&
580             !attacked(them, castling_from + 1) &&
581             !attacked(them, castling_to)) {
582           add_move(board, moves, kings[us] , castling_to,
583                    BITS.KSIDE_CASTLE);
584         }
585       }
586
587       /* queen-side castling */
588       if (castling[us] & BITS.QSIDE_CASTLE) {
589         var castling_from = kings[us];
590         var castling_to = castling_from - 2;
591
592         if (board[castling_from - 1] == null &&
593             board[castling_from - 2] == null &&
594             board[castling_from - 3] == null &&
595             !attacked(them, kings[us]) &&
596             !attacked(them, castling_from - 1) &&
597             !attacked(them, castling_to)) {
598           add_move(board, moves, kings[us], castling_to,
599                    BITS.QSIDE_CASTLE);
600         }
601       }
602     }
603
604     /* return all pseudo-legal moves (this includes moves that allow the king
605      * to be captured)
606      */
607     if (!legal) {
608       return moves;
609     }
610
611     /* filter out illegal moves */
612     var legal_moves = [];
613     for (var i = 0, len = moves.length; i < len; i++) {
614       make_move(moves[i]);
615       if (!king_attacked(us)) {
616         legal_moves.push(moves[i]);
617       }
618       undo_move();
619     }
620
621     return legal_moves;
622   }
623
624   /* convert a move from 0x88 coordinates to Standard Algebraic Notation
625    * (SAN)
626    */
627   function move_to_san(move) {
628     var output = '';
629
630     if (move.flags & BITS.KSIDE_CASTLE) {
631       output = 'O-O';
632     } else if (move.flags & BITS.QSIDE_CASTLE) {
633       output = 'O-O-O';
634     } else {
635       var disambiguator = get_disambiguator(move);
636
637       if (move.piece !== PAWN) {
638         output += move.piece.toUpperCase() + disambiguator;
639       }
640
641       if (move.flags & (BITS.CAPTURE | BITS.EP_CAPTURE)) {
642         if (move.piece === PAWN) {
643           output += algebraic(move.from)[0];
644         }
645         output += 'x';
646       }
647
648       output += algebraic(move.to);
649
650       if (move.flags & BITS.PROMOTION) {
651         output += '=' + move.promotion.toUpperCase();
652       }
653     }
654
655     make_move(move);
656     if (in_check()) {
657       if (in_checkmate()) {
658         output += '#';
659       } else {
660         output += '+';
661       }
662     }
663     undo_move();
664
665     return output;
666   }
667
668   function attacked(color, square) {
669     for (var i = SQUARES.a8; i <= SQUARES.h1; i++) {
670       /* did we run off the end of the board */
671       if (i & 0x88) { i += 7; continue; }
672
673       /* if empty square or wrong color */
674       if (board[i] == null || board[i].color !== color) continue;
675
676       var piece = board[i];
677       var difference = i - square;
678       var index = difference + 119;
679
680       if (ATTACKS[index] & (1 << SHIFTS[piece.type])) {
681         if (piece.type === PAWN) {
682           if (difference > 0) {
683             if (piece.color === WHITE) return true;
684           } else {
685             if (piece.color === BLACK) return true;
686           }
687           continue;
688         }
689
690         /* if the piece is a knight or a king */
691         if (piece.type === 'n' || piece.type === 'k') return true;
692
693         var offset = RAYS[index];
694         var j = i + offset;
695
696         var blocked = false;
697         while (j !== square) {
698           if (board[j] != null) { blocked = true; break; }
699           j += offset;
700         }
701
702         if (!blocked) return true;
703       }
704     }
705
706     return false;
707   }
708
709   function king_attacked(color) {
710     return attacked(swap_color(color), kings[color]);
711   }
712
713   function in_check() {
714     return king_attacked(turn);
715   }
716
717   function in_checkmate() {
718     return in_check() && generate_moves().length === 0;
719   }
720
721   function in_stalemate() {
722     return !in_check() && generate_moves().length === 0;
723   }
724
725   function insufficient_material() {
726     var pieces = {};
727     var bishops = [];
728     var num_pieces = 0;
729     var sq_color = 0;
730
731     for (var i = SQUARES.a8; i<= SQUARES.h1; i++) {
732       sq_color = (sq_color + 1) % 2;
733       if (i & 0x88) { i += 7; continue; }
734
735       var piece = board[i];
736       if (piece) {
737         pieces[piece.type] = (piece.type in pieces) ?
738                               pieces[piece.type] + 1 : 1;
739         if (piece.type === BISHOP) {
740           bishops.push(sq_color);
741         }
742         num_pieces++;
743       }
744     }
745
746     /* k vs. k */
747     if (num_pieces === 2) { return true; }
748
749     /* k vs. kn .... or .... k vs. kb */
750     else if (num_pieces === 3 && (pieces[BISHOP] === 1 ||
751                                  pieces[KNIGHT] === 1)) { return true; }
752
753     /* kb vs. kb where any number of bishops are all on the same color */
754     else if (num_pieces === pieces[BISHOP] + 2) {
755       var sum = 0;
756       var len = bishops.length;
757       for (var i = 0; i < len; i++) {
758         sum += bishops[i];
759       }
760       if (sum === 0 || sum === len) { return true; }
761     }
762
763     return false;
764   }
765
766   function in_threefold_repetition() {
767     /* TODO: while this function is fine for casual use, a better
768      * implementation would use a Zobrist key (instead of FEN). the
769      * Zobrist key would be maintained in the make_move/undo_move functions,
770      * avoiding the costly that we do below.
771      */
772     var moves = [];
773     var positions = {};
774     var repetition = false;
775
776     while (true) {
777       var move = undo_move();
778       if (!move) break;
779       moves.push(move);
780     }
781
782     while (true) {
783       /* remove the last two fields in the FEN string, they're not needed
784        * when checking for draw by rep */
785       var fen = generate_fen().split(' ').slice(0,4).join(' ');
786
787       /* has the position occurred three or move times */
788       positions[fen] = (fen in positions) ? positions[fen] + 1 : 1;
789       if (positions[fen] >= 3) {
790         repetition = true;
791       }
792
793       if (!moves.length) {
794         break;
795       }
796       make_move(moves.pop());
797     }
798
799     return repetition;
800   }
801
802   function push(move) {
803     history.push({
804       move: move,
805       kings: {b: kings.b, w: kings.w},
806       turn: turn,
807       castling: {b: castling.b, w: castling.w},
808       ep_square: ep_square,
809       half_moves: half_moves,
810       move_number: move_number
811     });
812   }
813
814   function make_move(move) {
815     var us = turn;
816     var them = swap_color(us);
817     push(move);
818
819     board[move.to] = board[move.from];
820     board[move.from] = null;
821
822     /* if ep capture, remove the captured pawn */
823     if (move.flags & BITS.EP_CAPTURE) {
824       if (turn === BLACK) {
825         board[move.to - 16] = null;
826       } else {
827         board[move.to + 16] = null;
828       }
829     }
830
831     /* if pawn promotion, replace with new piece */
832     if (move.flags & BITS.PROMOTION) {
833       board[move.to] = {type: move.promotion, color: us};
834     }
835
836     /* if we moved the king */
837     if (board[move.to].type === KING) {
838       kings[board[move.to].color] = move.to;
839
840       /* if we castled, move the rook next to the king */
841       if (move.flags & BITS.KSIDE_CASTLE) {
842         var castling_to = move.to - 1;
843         var castling_from = move.to + 1;
844         board[castling_to] = board[castling_from];
845         board[castling_from] = null;
846       } else if (move.flags & BITS.QSIDE_CASTLE) {
847         var castling_to = move.to + 1;
848         var castling_from = move.to - 2;
849         board[castling_to] = board[castling_from];
850         board[castling_from] = null;
851       }
852
853       /* turn off castling */
854       castling[us] = '';
855     }
856
857     /* turn off castling if we move a rook */
858     if (castling[us]) {
859       for (var i = 0, len = ROOKS[us].length; i < len; i++) {
860         if (move.from === ROOKS[us][i].square &&
861             castling[us] & ROOKS[us][i].flag) {
862           castling[us] ^= ROOKS[us][i].flag;
863           break;
864         }
865       }
866     }
867
868     /* turn off castling if we capture a rook */
869     if (castling[them]) {
870       for (var i = 0, len = ROOKS[them].length; i < len; i++) {
871         if (move.to === ROOKS[them][i].square &&
872             castling[them] & ROOKS[them][i].flag) {
873           castling[them] ^= ROOKS[them][i].flag;
874           break;
875         }
876       }
877     }
878
879     /* if big pawn move, update the en passant square */
880     if (move.flags & BITS.BIG_PAWN) {
881       if (turn === 'b') {
882         ep_square = move.to - 16;
883       } else {
884         ep_square = move.to + 16;
885       }
886     } else {
887       ep_square = EMPTY;
888     }
889
890     /* reset the 50 move counter if a pawn is moved or a piece is captured */
891     if (move.piece === PAWN) {
892       half_moves = 0;
893     } else if (move.flags & (BITS.CAPTURE | BITS.EP_CAPTURE)) {
894       half_moves = 0;
895     } else {
896       half_moves++;
897     }
898
899     if (turn === BLACK) {
900       move_number++;
901     }
902     turn = swap_color(turn);
903   }
904
905   function undo_move() {
906     var old = history.pop();
907     if (old == null) { return null; }
908
909     var move = old.move;
910     kings = old.kings;
911     turn = old.turn;
912     castling = old.castling;
913     ep_square = old.ep_square;
914     half_moves = old.half_moves;
915     move_number = old.move_number;
916
917     var us = turn;
918     var them = swap_color(turn);
919
920     board[move.from] = board[move.to];
921     board[move.from].type = move.piece;  // to undo any promotions
922     board[move.to] = null;
923
924     if (move.flags & BITS.CAPTURE) {
925       board[move.to] = {type: move.captured, color: them};
926     } else if (move.flags & BITS.EP_CAPTURE) {
927       var index;
928       if (us === BLACK) {
929         index = move.to - 16;
930       } else {
931         index = move.to + 16;
932       }
933       board[index] = {type: PAWN, color: them};
934     }
935
936
937     if (move.flags & (BITS.KSIDE_CASTLE | BITS.QSIDE_CASTLE)) {
938       var castling_to, castling_from;
939       if (move.flags & BITS.KSIDE_CASTLE) {
940         castling_to = move.to + 1;
941         castling_from = move.to - 1;
942       } else if (move.flags & BITS.QSIDE_CASTLE) {
943         castling_to = move.to - 2;
944         castling_from = move.to + 1;
945       }
946
947       board[castling_to] = board[castling_from];
948       board[castling_from] = null;
949     }
950
951     return move;
952   }
953
954   /* this function is used to uniquely identify ambiguous moves */
955   function get_disambiguator(move) {
956     var moves = generate_moves();
957
958     var from = move.from;
959     var to = move.to;
960     var piece = move.piece;
961
962     var ambiguities = 0;
963     var same_rank = 0;
964     var same_file = 0;
965
966     for (var i = 0, len = moves.length; i < len; i++) {
967       var ambig_from = moves[i].from;
968       var ambig_to = moves[i].to;
969       var ambig_piece = moves[i].piece;
970
971       /* if a move of the same piece type ends on the same to square, we'll
972        * need to add a disambiguator to the algebraic notation
973        */
974       if (piece === ambig_piece && from !== ambig_from && to === ambig_to) {
975         ambiguities++;
976
977         if (rank(from) === rank(ambig_from)) {
978           same_rank++;
979         }
980
981         if (file(from) === file(ambig_from)) {
982           same_file++;
983         }
984       }
985     }
986
987     if (ambiguities > 0) {
988       /* if there exists a similar moving piece on the same rank and file as
989        * the move in question, use the square as the disambiguator
990        */
991       if (same_rank > 0 && same_file > 0) {
992         return algebraic(from);
993       }
994       /* if the moving piece rests on the same file, use the rank symbol as the
995        * disambiguator
996        */
997       else if (same_file > 0) {
998         return algebraic(from).charAt(1);
999       }
1000       /* else use the file symbol */
1001       else {
1002         return algebraic(from).charAt(0);
1003       }
1004     }
1005
1006     return '';
1007   }
1008
1009   function ascii() {
1010     var s = '   +------------------------+\n';
1011     for (var i = SQUARES.a8; i <= SQUARES.h1; i++) {
1012       /* display the rank */
1013       if (file(i) === 0) {
1014         s += ' ' + '87654321'[rank(i)] + ' |';
1015       }
1016
1017       /* empty piece */
1018       if (board[i] == null) {
1019         s += ' . ';
1020       } else {
1021         var piece = board[i].type;
1022         var color = board[i].color;
1023         var symbol = (color === WHITE) ?
1024                      piece.toUpperCase() : piece.toLowerCase();
1025         s += ' ' + symbol + ' ';
1026       }
1027
1028       if ((i + 1) & 0x88) {
1029         s += '|\n';
1030         i += 8;
1031       }
1032     }
1033     s += '   +------------------------+\n';
1034     s += '     a  b  c  d  e  f  g  h\n';
1035
1036     return s;
1037   }
1038
1039   /*****************************************************************************
1040    * UTILITY FUNCTIONS
1041    ****************************************************************************/
1042   function rank(i) {
1043     return i >> 4;
1044   }
1045
1046   function file(i) {
1047     return i & 15;
1048   }
1049
1050   function algebraic(i){
1051     var f = file(i), r = rank(i);
1052     return 'abcdefgh'.substring(f,f+1) + '87654321'.substring(r,r+1);
1053   }
1054
1055   function swap_color(c) {
1056     return c === WHITE ? BLACK : WHITE;
1057   }
1058
1059   function is_digit(c) {
1060     return '0123456789'.indexOf(c) !== -1;
1061   }
1062
1063   /* pretty = external move object */
1064   function make_pretty(ugly_move) {
1065     var move = clone(ugly_move);
1066     move.san = move_to_san(move);
1067     move.to = algebraic(move.to);
1068     move.from = algebraic(move.from);
1069
1070     var flags = '';
1071
1072     for (var flag in BITS) {
1073       if (BITS[flag] & move.flags) {
1074         flags += FLAGS[flag];
1075       }
1076     }
1077     move.flags = flags;
1078
1079     return move;
1080   }
1081
1082   function clone(obj) {
1083     var dupe = (obj instanceof Array) ? [] : {};
1084
1085     for (var property in obj) {
1086       if (typeof property === 'object') {
1087         dupe[property] = clone(obj[property]);
1088       } else {
1089         dupe[property] = obj[property];
1090       }
1091     }
1092
1093     return dupe;
1094   }
1095
1096   function trim(str) {
1097     return str.replace(/^\s+|\s+$/g, '');
1098   }
1099
1100   /*****************************************************************************
1101    * DEBUGGING UTILITIES
1102    ****************************************************************************/
1103   function perft(depth) {
1104     var moves = generate_moves({legal: false});
1105     var nodes = 0;
1106     var color = turn;
1107
1108     for (var i = 0, len = moves.length; i < len; i++) {
1109       make_move(moves[i]);
1110       if (!king_attacked(color)) {
1111         if (depth - 1 > 0) {
1112           var child_nodes = perft(depth - 1);
1113           nodes += child_nodes;
1114         } else {
1115           nodes++;
1116         }
1117       }
1118       undo_move();
1119     }
1120
1121     return nodes;
1122   }
1123
1124   return {
1125     /***************************************************************************
1126      * PUBLIC CONSTANTS (is there a better way to do this?)
1127      **************************************************************************/
1128     WHITE: WHITE,
1129     BLACK: BLACK,
1130     PAWN: PAWN,
1131     KNIGHT: KNIGHT,
1132     BISHOP: BISHOP,
1133     ROOK: ROOK,
1134     QUEEN: QUEEN,
1135     KING: KING,
1136     SQUARES: (function() {
1137                 /* from the ECMA-262 spec (section 12.6.4):
1138                  * "The mechanics of enumerating the properties ... is
1139                  * implementation dependent"
1140                  * so: for (var sq in SQUARES) { keys.push(sq); } might not be
1141                  * ordered correctly
1142                  */
1143                 var keys = [];
1144                 for (var i = SQUARES.a8; i <= SQUARES.h1; i++) {
1145                   if (i & 0x88) { i += 7; continue; }
1146                   keys.push(algebraic(i));
1147                 }
1148                 return keys;
1149               })(),
1150     FLAGS: FLAGS,
1151
1152     /***************************************************************************
1153      * PUBLIC API
1154      **************************************************************************/
1155     load: function(fen) {
1156       return load(fen);
1157     },
1158
1159     reset: function() {
1160       return reset();
1161     },
1162
1163     moves: function(options) {
1164       /* The internal representation of a chess move is in 0x88 format, and
1165        * not meant to be human-readable.  The code below converts the 0x88
1166        * square coordinates to algebraic coordinates.  It also prunes an
1167        * unnecessary move keys resulting from a verbose call.
1168        */
1169
1170       var ugly_moves = generate_moves(options);
1171       var moves = [];
1172
1173       for (var i = 0, len = ugly_moves.length; i < len; i++) {
1174
1175         /* does the user want a full move object (most likely not), or just
1176          * SAN
1177          */
1178         if (typeof options !== 'undefined' && 'verbose' in options &&
1179             options.verbose) {
1180           moves.push(make_pretty(ugly_moves[i]));
1181         } else {
1182           moves.push(move_to_san(ugly_moves[i]));
1183         }
1184       }
1185
1186       return moves;
1187     },
1188
1189     in_check: function() {
1190       return in_check();
1191     },
1192
1193     in_checkmate: function() {
1194       return in_checkmate();
1195     },
1196
1197     in_stalemate: function() {
1198       return in_stalemate();
1199     },
1200
1201     in_draw: function() {
1202       return half_moves >= 100 ||
1203              in_stalemate() ||
1204              insufficient_material() ||
1205              in_threefold_repetition();
1206     },
1207
1208     insufficient_material: function() {
1209       return insufficient_material();
1210     },
1211
1212     in_threefold_repetition: function() {
1213       return in_threefold_repetition();
1214     },
1215
1216     game_over: function() {
1217       return half_moves >= 100 ||
1218              in_checkmate() ||
1219              in_stalemate() ||
1220              insufficient_material() ||
1221              in_threefold_repetition();
1222     },
1223
1224     validate_fen: function(fen) {
1225       return validate_fen(fen);
1226     },
1227
1228     fen: function() {
1229       return generate_fen();
1230     },
1231
1232     pgn: function(options) {
1233       /* using the specification from http://www.chessclub.com/help/PGN-spec
1234        * example for html usage: .pgn({ max_width: 72, newline_char: "<br />" })
1235        */
1236       var newline = (typeof options === 'object' &&
1237                      typeof options.newline_char === 'string') ?
1238                      options.newline_char : '\n';
1239       var max_width = (typeof options === 'object' &&
1240                        typeof options.max_width === 'number') ?
1241                        options.max_width : 0;
1242       var result = [];
1243       var header_exists = false;
1244
1245       /* add the PGN header headerrmation */
1246       for (var i in header) {
1247         /* TODO: order of enumerated properties in header object is not
1248          * guaranteed, see ECMA-262 spec (section 12.6.4)
1249          */
1250         result.push('[' + i + ' \"' + header[i] + '\"]' + newline);
1251         header_exists = true;
1252       }
1253
1254       if (header_exists && history.length) {
1255         result.push(newline);
1256       }
1257
1258       /* pop all of history onto reversed_history */
1259       var reversed_history = [];
1260       while (history.length > 0) {
1261         reversed_history.push(undo_move());
1262       }
1263
1264       var moves = [];
1265       var move_string = '';
1266       var pgn_move_number = 1;
1267
1268       /* build the list of moves.  a move_string looks like: "3. e3 e6" */
1269       while (reversed_history.length > 0) {
1270         var move = reversed_history.pop();
1271
1272         /* if the position started with black to move, start PGN with 1. ... */
1273         if (pgn_move_number === 1 && move.color === 'b') {
1274           move_string = '1. ...';
1275           pgn_move_number++;
1276         } else if (move.color === 'w') {
1277           /* store the previous generated move_string if we have one */
1278           if (move_string.length) {
1279             moves.push(move_string);
1280           }
1281           move_string = pgn_move_number + '.';
1282           pgn_move_number++;
1283         }
1284
1285         move_string = move_string + ' ' + move_to_san(move);
1286         make_move(move);
1287       }
1288
1289       /* are there any other leftover moves? */
1290       if (move_string.length) {
1291         moves.push(move_string);
1292       }
1293
1294       /* is there a result? */
1295       if (typeof header.Result !== 'undefined') {
1296         moves.push(header.Result);
1297       }
1298
1299       /* history should be back to what is was before we started generating PGN,
1300        * so join together moves
1301        */
1302       if (max_width === 0) {
1303         return result.join('') + moves.join(' ');
1304       }
1305
1306       /* wrap the PGN output at max_width */
1307       var current_width = 0;
1308       for (var i = 0; i < moves.length; i++) {
1309         /* if the current move will push past max_width */
1310         if (current_width + moves[i].length > max_width && i !== 0) {
1311
1312           /* don't end the line with whitespace */
1313           if (result[result.length - 1] === ' ') {
1314             result.pop();
1315           }
1316
1317           result.push(newline);
1318           current_width = 0;
1319         } else if (i !== 0) {
1320           result.push(' ');
1321           current_width++;
1322         }
1323         result.push(moves[i]);
1324         current_width += moves[i].length;
1325       }
1326
1327       return result.join('');
1328     },
1329
1330     load_pgn: function(pgn, options) {
1331       function mask(str) {
1332         return str.replace(/\\/g, '\\');
1333       }
1334
1335       /* convert a move from Standard Algebraic Notation (SAN) to 0x88
1336        * coordinates
1337       */
1338       function move_from_san(move) {
1339         var moves = generate_moves();
1340         for (var i = 0, len = moves.length; i < len; i++) {
1341           /* strip off any trailing move decorations: e.g Nf3+?! */
1342           if (move.replace(/[+#?!=]+$/,'') ==
1343               move_to_san(moves[i]).replace(/[+#?!=]+$/,'')) {
1344             return moves[i];
1345           }
1346         }
1347         return null;
1348       }
1349
1350       function get_move_obj(move) {
1351         return move_from_san(trim(move));
1352       }
1353
1354       function has_keys(object) {
1355         var has_keys = false;
1356         for (var key in object) {
1357           has_keys = true;
1358         }
1359         return has_keys;
1360       }
1361
1362       function parse_pgn_header(header, options) {
1363         var newline_char = (typeof options === 'object' &&
1364                             typeof options.newline_char === 'string') ?
1365                             options.newline_char : '\r?\n';
1366         var header_obj = {};
1367         var headers = header.split(new RegExp(mask(newline_char)));
1368         var key = '';
1369         var value = '';
1370
1371         for (var i = 0; i < headers.length; i++) {
1372           key = headers[i].replace(/^\[([A-Z][A-Za-z]*)\s.*\]$/, '$1');
1373           value = headers[i].replace(/^\[[A-Za-z]+\s"(.*)"\]$/, '$1');
1374           if (trim(key).length > 0) {
1375             header_obj[key] = value;
1376           }
1377         }
1378
1379         return header_obj;
1380       }
1381
1382       var newline_char = (typeof options === 'object' &&
1383                           typeof options.newline_char === 'string') ?
1384                           options.newline_char : '\r?\n';
1385         var regex = new RegExp('^(\\[(.|' + mask(newline_char) + ')*\\])' +
1386                                '(' + mask(newline_char) + ')*' +
1387                                '1.(' + mask(newline_char) + '|.)*$', 'g');
1388
1389       /* get header part of the PGN file */
1390       var header_string = pgn.replace(regex, '$1');
1391
1392       /* no info part given, begins with moves */
1393       if (header_string[0] !== '[') {
1394         header_string = '';
1395       }
1396
1397      reset();
1398
1399       /* parse PGN header */
1400       var headers = parse_pgn_header(header_string, options);
1401       for (var key in headers) {
1402         set_header([key, headers[key]]);
1403       }
1404
1405       /* delete header to get the moves */
1406       var ms = pgn.replace(header_string, '').replace(new RegExp(mask(newline_char), 'g'), ' ');
1407
1408       /* delete comments */
1409       ms = ms.replace(/(\{[^}]+\})+?/g, '');
1410
1411       /* delete move numbers */
1412       ms = ms.replace(/\d+\./g, '');
1413
1414
1415       /* trim and get array of moves */
1416       var moves = trim(ms).split(new RegExp(/\s+/));
1417
1418       /* delete empty entries */
1419       moves = moves.join(',').replace(/,,+/g, ',').split(',');
1420       var move = '';
1421
1422       for (var half_move = 0; half_move < moves.length - 1; half_move++) {
1423         move = get_move_obj(moves[half_move]);
1424
1425         /* move not possible! (don't clear the board to examine to show the
1426          * latest valid position)
1427          */
1428         if (move == null) {
1429           return false;
1430         } else {
1431           make_move(move);
1432         }
1433       }
1434
1435       /* examine last move */
1436       move = moves[moves.length - 1];
1437       if (POSSIBLE_RESULTS.indexOf(move) > -1) {
1438         if (has_keys(header) && typeof header.Result === 'undefined') {
1439           set_header(['Result', move]);
1440         }
1441       }
1442       else {
1443         move = get_move_obj(move);
1444         if (move == null) {
1445           return false;
1446         } else {
1447           make_move(move);
1448         }
1449       }
1450       return true;
1451     },
1452
1453     header: function() {
1454       return set_header(arguments);
1455     },
1456
1457     ascii: function() {
1458       return ascii();
1459     },
1460
1461     turn: function() {
1462       return turn;
1463     },
1464
1465     move: function(move) {
1466       /* The move function can be called with in the following parameters:
1467        *
1468        * .move('Nxb7')      <- where 'move' is a case-sensitive SAN string
1469        *
1470        * .move({ from: 'h7', <- where the 'move' is a move object (additional
1471        *         to :'h8',      fields are ignored)
1472        *         promotion: 'q',
1473        *      })
1474        */
1475       var move_obj = null;
1476       var moves = generate_moves();
1477
1478       if (typeof move === 'string') {
1479         /* convert the move string to a move object */
1480         for (var i = 0, len = moves.length; i < len; i++) {
1481           if (move === move_to_san(moves[i])) {
1482             move_obj = moves[i];
1483             break;
1484           }
1485         }
1486       } else if (typeof move === 'object') {
1487         /* convert the pretty move object to an ugly move object */
1488         for (var i = 0, len = moves.length; i < len; i++) {
1489           if (move.from === algebraic(moves[i].from) &&
1490               move.to === algebraic(moves[i].to) &&
1491               (!('promotion' in moves[i]) ||
1492               move.promotion === moves[i].promotion)) {
1493             move_obj = moves[i];
1494             break;
1495           }
1496         }
1497       }
1498
1499       /* failed to find move */
1500       if (!move_obj) {
1501         return null;
1502       }
1503
1504       /* need to make a copy of move because we can't generate SAN after the
1505        * move is made
1506        */
1507       var pretty_move = make_pretty(move_obj);
1508
1509       make_move(move_obj);
1510
1511       return pretty_move;
1512     },
1513
1514     undo: function() {
1515       var move = undo_move();
1516       return (move) ? make_pretty(move) : null;
1517     },
1518
1519     clear: function() {
1520       return clear();
1521     },
1522
1523     put: function(piece, square) {
1524       return put(piece, square);
1525     },
1526
1527     get: function(square) {
1528       return get(square);
1529     },
1530
1531     remove: function(square) {
1532       return remove(square);
1533     },
1534
1535     perft: function(depth) {
1536       return perft(depth);
1537     },
1538
1539     square_color: function(square) {
1540       if (square in SQUARES) {
1541         var sq_0x88 = SQUARES[square];
1542         return ((rank(sq_0x88) + file(sq_0x88)) % 2 === 0) ? 'light' : 'dark';
1543       }
1544
1545       return null;
1546     },
1547
1548     history: function(options) {
1549       var reversed_history = [];
1550       var move_history = [];
1551       var verbose = (typeof options !== 'undefined' && 'verbose' in options &&
1552                      options.verbose);
1553
1554       while (history.length > 0) {
1555         reversed_history.push(undo_move());
1556       }
1557
1558       while (reversed_history.length > 0) {
1559         var move = reversed_history.pop();
1560         if (verbose) {
1561           move_history.push(make_pretty(move));
1562         } else {
1563           move_history.push(move_to_san(move));
1564         }
1565         make_move(move);
1566       }
1567
1568       return move_history;
1569     }
1570
1571   };
1572 };