* @private */
var highlighted_move = null;
+/** Currently suggested/recommended move when dragging.
+ * @type {?{from: !string, to: !string}}
+ * @private
+ */
+var recommended_move = null;
+
+/** If reverse-dragging (dragging from the destination square to the
+ * source square), the destination square.
+ * @type {?string}
+ * @private
+ */
+var reverse_dragging_from = null;
+
/** @type {?number} @private */
var unique = null;
* pretty_pv: Array.<string>,
* move_num: number,
* toplay: string,
+ * score: string,
* start_display_move_num: number
* }} DisplayLine
*
* "start_display_move_num" is the (half-)move number to start displaying the PV at.
+ * "score" is also evaluated at this point.
*/
/** All PVs that we currently know of.
head.setAttribute("fill", arrow.fg_color);
svg.appendChild(head);
- $(svg).css({ top: pos.top, left: pos.left });
+ $(svg).css({ top: pos.top, left: pos.left, 'pointer-events': 'none' });
document.body.appendChild(svg);
arrow.svg = svg;
}
arrows.push(arrow);
}
-var compare_by_sort_key = function(refutation_lines, a, b) {
+// Note: invert is ignored.
+var compare_by_sort_key = function(refutation_lines, invert, a, b) {
var ska = refutation_lines[a]['sort_key'];
var skb = refutation_lines[b]['sort_key'];
if (ska < skb) return -1;
return 0;
};
-var compare_by_score = function(refutation_lines, a, b) {
- var sa = parseInt(refutation_lines[b]['score_sort_key'], 10);
- var sb = parseInt(refutation_lines[a]['score_sort_key'], 10);
+var compare_by_score = function(refutation_lines, invert, a, b) {
+ var sa = compute_score_sort_key(refutation_lines[b]['score'], invert);
+ var sb = compute_score_sort_key(refutation_lines[a]['score'], invert);
return sa - sb;
}
* @param {!Object} data
* @param {number} margin The maximum number of centipawns worse than the
* best move can be and still be included.
+ * @param {boolean} margin Whether black is to play.
* @return {Array.<string>} The UCI representation (e.g. e1g1) of all
* moves, in score order.
*/
-var find_nonstupid_moves = function(data, margin) {
+var find_nonstupid_moves = function(data, margin, invert) {
// First of all, if there are any moves that are more than 0.5 ahead of
// the primary move, the refutation lines are probably bunk, so just
// kill them all.
var best_score = undefined;
var pv_score = undefined;
for (var move in data['refutation_lines']) {
- var score = parseInt(data['refutation_lines'][move]['score_sort_key'], 10);
+ var score = compute_score_sort_key(data['refutation_lines'][move]['score'], invert);
if (move == data['pv_uci'][0]) {
pv_score = score;
}
// The PV move will always be first.
var moves = [];
for (var move in data['refutation_lines']) {
- var score = parseInt(data['refutation_lines'][move]['score_sort_key'], 10);
+ var score = compute_score_sort_key(data['refutation_lines'][move]['score'], invert);
if (move != data['pv_uci'][0] && best_score - score <= margin) {
moves.push(move);
}
}
- moves = moves.sort(function(a, b) { return compare_by_score(data['refutation_lines'], a, b) });
+ moves = moves.sort(function(a, b) { return compare_by_score(data['refutation_lines'], data['position']['toplay'] === 'B', a, b) });
moves.unshift(data['pv_uci'][0]);
return moves;
* @param {Array.<string>} pretty_pv
* @param {number} move_num
* @param {!string} toplay
+ * @param {!string} score
* @param {number} start_display_move_num
* @param {number=} opt_limit
* @param {boolean=} opt_showlast
*/
-var add_pv = function(start_fen, pretty_pv, move_num, toplay, start_display_move_num, opt_limit, opt_showlast) {
+var add_pv = function(start_fen, pretty_pv, move_num, toplay, score, start_display_move_num, opt_limit, opt_showlast) {
display_lines.push({
start_fen: start_fen,
pretty_pv: pretty_pv,
move_num: parseInt(move_num),
toplay: toplay,
- start_display_move_num: start_display_move_num,
+ score: score,
+ start_display_move_num: start_display_move_num
});
return print_pv(display_lines.length - 1, opt_limit, opt_showlast);
}
for (var move in refutation_lines) {
moves.push(move);
}
+
+ var invert = (toplay === 'B');
+ if (current_display_line && current_display_move % 2 == 0) {
+ invert = !invert;
+ }
var compare = sort_refutation_lines_by_score ? compare_by_score : compare_by_sort_key;
- moves = moves.sort(function(a, b) { return compare(refutation_lines, a, b) });
+ moves = moves.sort(function(a, b) { return compare(refutation_lines, invert, a, b) });
for (var i = 0; i < moves.length; ++i) {
var line = refutation_lines[moves[i]];
$(move_td).addClass("move");
if (line['pv_pretty'].length == 0) {
- // Not found.
- $(move_td).text(line['pretty_move']);
+ // Not found, so just make a one-move PV.
+ var move = "<a class=\"move\" href=\"javascript:show_line(" + display_lines.length + ", " + 0 + ");\">" + line['pretty_move'] + "</a>";
+ $(move_td).html(move);
var score_td = document.createElement("td");
$(score_td).addClass("score");
$(depth_td).addClass("depth");
$(depth_td).text("—");
+ var pv_td = document.createElement("td");
+ tr.appendChild(pv_td);
+ $(pv_td).addClass("pv");
+ $(pv_td).html(add_pv(base_fen, base_line.concat([ line['pretty_move'] ]), move_num, toplay, line['score'], start_display_move_num));
+
tbl.append(tr);
continue;
}
- if (line['pv_pretty'].length == 0) {
- $(move_td).text(line['pretty_move']);
- } else {
- var move = "<a class=\"move\" href=\"javascript:show_line(" + display_lines.length + ", " + 0 + ");\">" + line['pretty_move'] + "</a>";
- $(move_td).html(move);
- }
+ var move = "<a class=\"move\" href=\"javascript:show_line(" + display_lines.length + ", " + 0 + ");\">" + line['pretty_move'] + "</a>";
+ $(move_td).html(move);
var score_td = document.createElement("td");
tr.appendChild(score_td);
$(score_td).addClass("score");
- $(score_td).text(line['pretty_score']);
+ $(score_td).text(format_short_score(line['score']));
var depth_td = document.createElement("td");
tr.appendChild(depth_td);
var pv_td = document.createElement("td");
tr.appendChild(pv_td);
$(pv_td).addClass("pv");
- $(pv_td).html(add_pv(base_fen, base_line.concat(line['pv_pretty']), move_num, toplay, start_display_move_num, 10));
+ $(pv_td).html(add_pv(base_fen, base_line.concat(line['pv_pretty']), move_num, toplay, line['score'], start_display_move_num, 10));
tbl.append(tr);
}
// unconditionally taken from current_data (we're not interested in
// historic history).
if (current_data['position']['pretty_history']) {
- add_pv('start', current_data['position']['pretty_history'], 1, 'W', 0, 8, true);
+ add_pv('start', current_data['position']['pretty_history'], 1, 'W', null, 0, 8, true);
} else {
display_lines.push(null);
}
// The <title> contains a very brief headline.
var title_elems = [];
- if (data['short_score'] !== undefined && data['short_score'] !== null) {
- title_elems.push(data['short_score'].replace(/^ /, ""));
+ if (data['score']) {
+ title_elems.push(format_short_score(data['score']).replace(/^ /, ""));
}
if (last_move !== null) {
title_elems.push(last_move);
update_clock();
// The score.
- if (data['score'] !== null) {
- $("#score").text(data['score']);
+ if (current_display_line) {
+ if (current_display_line.score) {
+ $("#score").text(format_long_score(current_display_line.score));
+ } else {
+ $("#score").text("No score for this move");
+ }
+ } else if (data['score']) {
+ $("#score").text(format_long_score(data['score']));
}
// The search stats.
// Print the PV.
$("#pvtitle").text("PV:");
- $("#pv").html(add_pv(data['position']['fen'], data['pv_pretty'], data['position']['move_num'], data['position']['toplay'], 0));
+ $("#pv").html(add_pv(data['position']['fen'], data['pv_pretty'], data['position']['move_num'], data['position']['toplay'], data['score'], 0));
// Update the PV arrow.
clear_arrows();
create_arrow(from, to, '#f66', 6, 20);
}
- var alt_moves = find_nonstupid_moves(data, 30);
+ var alt_moves = find_nonstupid_moves(data, 30, data['position']['toplay'] === 'B');
for (var i = 1; i < alt_moves.length && i < 3; ++i) {
create_arrow(alt_moves[i].substr(0, 2),
alt_moves[i].substr(2, 2), '#f66', 1, 10);
// See if all semi-reasonable moves have only one possible response.
if (data['pv_uci'].length >= 2) {
- var nonstupid_moves = find_nonstupid_moves(data, 300);
+ var nonstupid_moves = find_nonstupid_moves(data, 300, data['position']['toplay'] === 'B');
var response = data['pv_uci'][1];
for (var i = 0; i < nonstupid_moves.length; ++i) {
if (nonstupid_moves[i] == data['pv_uci'][0]) {
var scores = [];
for (var halfmove_num = first_move_num; halfmove_num <= last_move_num; ++halfmove_num) {
if (data['score_history'][halfmove_num]) {
- var score = data['score_history'][halfmove_num][0];
+ var score = compute_plot_score(data['score_history'][halfmove_num]);
+ last_score = score;
if (score < min_score) min_score = score;
if (score > max_score) max_score = score;
- last_score = data['score_history'][halfmove_num][0];
}
scores.push(last_score);
}
- if (data['plot_score']) {
- scores.push(data['plot_score']);
+ if (data['score']) {
+ scores.push(compute_plot_score(data['score']));
}
// FIXME: at some widths, calling sparkline() seems to push
// #scorecontainer under the board.
var short_score;
if (halfmove_num === data['position']['pretty_history'].length) {
move = data['position']['last_move'];
- short_score = data['short_score'];
+ short_score = format_short_score(data['score']);
} else {
move = data['position']['pretty_history'][halfmove_num];
- short_score = data['score_history'][halfmove_num][1];
+ short_score = format_short_score(data['score_history'][halfmove_num]);
}
var move_with_number = format_halfmove_with_number(move, halfmove_num);
highlighted_move.removeClass('highlight');
}
if (current_display_line) {
- // See if the current displayed line is identical to any of the ones
- // we have on screen. (It might not be if e.g. the analysis reloaded
- // since we started looking.)
- var display_line_num = null;
- for (var i = 0; i < display_lines.length; ++i) {
- var line = display_lines[i];
- if (line.start_display_move_num > 0) continue;
- if (current_display_line.start_fen !== line.start_fen) continue;
- if (current_display_line.pretty_pv.length !== line.pretty_pv.length) continue;
- var ok = true;
- for (var j = 0; j < line.pretty_pv.length; ++j) {
- if (current_display_line.pretty_pv[j] !== line.pretty_pv[j]) {
- ok = false;
- break;
- }
- }
- if (ok) {
- display_line_num = i;
- break;
- }
- }
-
+ var display_line_num = find_display_line_matching_num();
if (display_line_num === null) {
// Replace the PV with the (complete) line.
$("#pvtitle").text("Exploring:");
}
}
+/**
+ * See if the current displayed line is identical to any of the ones
+ * we have on screen. (It might not be if e.g. the analysis reloaded
+ * since we started looking.)
+ *
+ * @return {?number}
+ */
+var find_display_line_matching_num = function() {
+ for (var i = 0; i < display_lines.length; ++i) {
+ var line = display_lines[i];
+ if (line.start_display_move_num > 0) continue;
+ if (current_display_line.start_fen !== line.start_fen) continue;
+ if (current_display_line.pretty_pv.length !== line.pretty_pv.length) continue;
+ var ok = true;
+ for (var j = 0; j < line.pretty_pv.length; ++j) {
+ if (current_display_line.pretty_pv[j] !== line.pretty_pv[j]) {
+ ok = false;
+ break;
+ }
+ }
+ if (ok) {
+ return i;
+ }
+ }
+ return null;
+}
+
var update_displayed_line = function() {
if (current_display_line === null) {
$("#linenav").hide();
board.position(hiddenboard.fen());
if (board.fen() === old_fen) {
board_is_animating = false;
- } else {
+ } else if (!current_display_line_is_history) {
// Fire off a hash request, since we're now off the main position
// and it just changed.
explore_hash(display_fen);
clearTimeout(current_hash_display_timer);
current_hash_display_timer = null;
}
+ $("#refutationlines").empty();
current_hash_xhr = $.ajax({
url: backend_hash_url + "?fen=" + fen
}).done(function(data, textstatus, xhr) {
update_board();
}
+// almost all of this stuff comes from the chessboard.js example page
+var onDragStart = function(source, piece, position, orientation) {
+ var pseudogame = new Chess(display_fen);
+ if (pseudogame.game_over() === true ||
+ (pseudogame.turn() === 'w' && piece.search(/^b/) !== -1) ||
+ (pseudogame.turn() === 'b' && piece.search(/^w/) !== -1)) {
+ return false;
+ }
+
+ recommended_move = get_best_move(pseudogame, source, null, pseudogame.turn() === 'b');
+ if (recommended_move) {
+ var squareEl = $('#board .square-' + recommended_move.to);
+ squareEl.addClass('highlight1-32417');
+ }
+ return true;
+}
+
+var mousedownSquare = function(e) {
+ reverse_dragging_from = null;
+ var square = $(this).attr('data-square');
+
+ var pseudogame = new Chess(display_fen);
+ if (pseudogame.game_over() === true) {
+ return;
+ }
+
+ // If the square is empty, or has a piece of the side not to move,
+ // we handle it. If not, normal piece dragging will take it.
+ var position = board.position();
+ if (!position.hasOwnProperty(square) ||
+ (pseudogame.turn() === 'w' && position[square].search(/^b/) !== -1) ||
+ (pseudogame.turn() === 'b' && position[square].search(/^w/) !== -1)) {
+ reverse_dragging_from = square;
+ recommended_move = get_best_move(pseudogame, null, square, pseudogame.turn() === 'b');
+ if (recommended_move) {
+ var squareEl = $('#board .square-' + recommended_move.from);
+ squareEl.addClass('highlight1-32417');
+ squareEl = $('#board .square-' + recommended_move.to);
+ squareEl.addClass('highlight1-32417');
+ }
+ }
+}
+
+var mouseupSquare = function(e) {
+ if (reverse_dragging_from === null) {
+ return;
+ }
+ var source = $(this).attr('data-square');
+ var target = reverse_dragging_from;
+ reverse_dragging_from = null;
+ if (onDrop(source, target) !== 'snapback') {
+ onSnapEnd(source, target);
+ }
+ $("#board").find('.square-55d63').removeClass('highlight1-32417');
+}
+
+var get_best_move = function(game, source, target, invert) {
+ var moves = game.moves({ verbose: true });
+ if (source !== null) {
+ moves = moves.filter(function(move) { return move.from == source; });
+ }
+ if (target !== null) {
+ moves = moves.filter(function(move) { return move.to == target; });
+ }
+ if (moves.length == 0) {
+ return null;
+ }
+ if (moves.length == 1) {
+ return moves[0];
+ }
+
+ // More than one move. Use the display lines (if we have them)
+ // to disambiguate; otherwise, we have no information.
+ var move_hash = {};
+ for (var i = 0; i < moves.length; ++i) {
+ move_hash[moves[i].san] = moves[i];
+ }
+
+ // History and PV take priority over the display lines.
+ for (var i = 0; i < 2; ++i) {
+ var line = display_lines[i];
+ var first_move = line.pretty_pv[line.start_display_move_num];
+ if (move_hash[first_move]) {
+ return move_hash[first_move];
+ }
+ }
+
+ var best_move = null;
+ var best_move_score = null;
+
+ for (var move in refutation_lines) {
+ var line = refutation_lines[move];
+ if (!line['score']) {
+ continue;
+ }
+ var first_move = line['pv_pretty'][0];
+ if (move_hash[first_move]) {
+ var score = compute_score_sort_key(line['score'], invert);
+ if (best_move_score === null || score > best_move_score) {
+ best_move = move_hash[first_move];
+ best_move_score = score;
+ }
+ }
+ }
+ return best_move;
+}
+
+var onDrop = function(source, target) {
+ if (source === target) {
+ if (recommended_move === null) {
+ return 'snapback';
+ } else {
+ // Accept the move. It will be changed in onSnapEnd.
+ return;
+ }
+ } else {
+ // Suggestion not asked for.
+ recommended_move = null;
+ }
+
+ // see if the move is legal
+ var pseudogame = new Chess(display_fen);
+ var move = pseudogame.move({
+ from: source,
+ to: target,
+ promotion: 'q' // NOTE: always promote to a queen for example simplicity
+ });
+
+ // illegal move
+ if (move === null) return 'snapback';
+}
+
+var onSnapEnd = function(source, target) {
+ if (source === target && recommended_move !== null) {
+ source = recommended_move.from;
+ target = recommended_move.to;
+ }
+ recommended_move = null;
+ var pseudogame = new Chess(display_fen);
+ var move = pseudogame.move({
+ from: source,
+ to: target,
+ promotion: 'q' // NOTE: always promote to a queen for example simplicity
+ });
+
+ if (current_display_line &&
+ current_display_move < current_display_line.pretty_pv.length - 1 &&
+ current_display_line.pretty_pv[current_display_move + 1] === move.san) {
+ next_move();
+ return;
+ }
+
+ // Walk down the displayed lines until we find one that starts with
+ // this move, then select that. Note that this gives us a good priority
+ // order (history first, then PV, then multi-PV lines).
+ for (var i = 0; i < display_lines.length; ++i) {
+ var line = display_lines[i];
+ if (line.pretty_pv[line.start_display_move_num] === move.san) {
+ show_line(i, 0);
+ return;
+ }
+ }
+
+ // Shouldn't really be here if we have hash probes, but there's really
+ // nothing we can do.
+}
+// End of dragging-related code.
+
+var pad = function(val, num_digits) {
+ var s = val.toString();
+ while (s.length < num_digits) {
+ s = " " + s;
+ }
+ return s;
+}
+
+var fmt_cp = function(v) {
+ if (v === 0) {
+ return "0.00";
+ } else if (v > 0) {
+ return "+" + (v / 100).toFixed(2);
+ } else {
+ v = -v;
+ return "-" + (v / 100).toFixed(2);
+ }
+}
+
+var format_short_score = function(score) {
+ if (!score) {
+ return "???";
+ }
+ if (score[0] === 'm') {
+ if (score[2]) { // Is a bound.
+ return score[2] + "\u00a0M" + pad(score[1], 3);
+ } else {
+ return "M" + pad(score[1], 3);
+ }
+ } else if (score[0] === 'd') {
+ return "TB draw";
+ } else if (score[0] === 'cp') {
+ if (score[2]) { // Is a bound.
+ return score[2] + "\u00a0" + fmt_cp(score[1]);
+ } else {
+ return pad(fmt_cp(score[1]), 5);
+ }
+ }
+ return null;
+}
+
+var format_long_score = function(score) {
+ if (score[0] === 'm') {
+ if (score[1] > 0) {
+ return "White mates in " + score[1];
+ } else {
+ return "Black mates in " + (-score[1]);
+ }
+ } else if (score[0] === 'd') {
+ return "Theoretical draw";
+ } else if (score[0] === 'cp') {
+ return "Score: " + format_short_score(score);
+ }
+ return null;
+}
+
+var compute_plot_score = function(score) {
+ if (score[0] === 'm') {
+ if (score[1] > 0) {
+ return 500;
+ } else {
+ return -500;
+ }
+ } else if (score[0] === 'd') {
+ return 0;
+ } else if (score[0] === 'cp') {
+ if (score[1] > 500) {
+ return 500;
+ } else if (score[1] < -500) {
+ return -500;
+ } else {
+ return score[1];
+ }
+ }
+ return null;
+}
+
+/**
+ * @param score The score digest tuple.
+ * @param {boolean} invert Whether black is to play.
+ * @return {number}
+ */
+var compute_score_sort_key = function(score, invert) {
+ var s;
+ if (!score) {
+ return -10000000;
+ }
+ if (score[0] === 'm') {
+ if (score[1] > 0) {
+ // White mates.
+ s = 99999 - score[1];
+ } else {
+ // Black mates (note the double negative for score[1]).
+ s = -99999 - score[1];
+ }
+ if (invert) s = -s;
+ return s;
+ } else if (score[0] === 'd') {
+ return 0;
+ } else if (score[0] === 'cp') {
+ return invert ? -score[1] : score[1];
+ }
+ return null;
+}
+
/**
* @param {string} new_backend_url
*/
// Create board.
board = new window.ChessBoard('board', {
- onMoveEnd: function() { board_is_animating = false; }
+ onMoveEnd: function() { board_is_animating = false; },
+
+ draggable: true,
+ onDragStart: onDragStart,
+ onDrop: onDrop,
+ onSnapEnd: onSnapEnd
});
+ $("#board").on('mousedown', '.square-55d63', mousedownSquare);
+ $("#board").on('mouseup', '.square-55d63', mouseupSquare);
request_update();
$(window).resize(function() {
projects / remoteglot / blobdiff