+ // Update the sparkline last, since its size depends on how everything else reflowed.
+ update_sparkline(data);
+}
+
+var update_sparkline = function(data) {
+ if (data && data['score_history']) {
+ var first_move_num = undefined;
+ for (var halfmove_num in data['score_history']) {
+ halfmove_num = parseInt(halfmove_num);
+ if (first_move_num === undefined || halfmove_num < first_move_num) {
+ first_move_num = halfmove_num;
+ }
+ }
+ if (first_move_num !== undefined) {
+ var last_move_num = data['position']['move_num'] * 2 - 3;
+ if (data['position']['toplay'] === 'B') {
+ ++last_move_num;
+ }
+
+ // Possibly truncate some moves if we don't have enough width.
+ // FIXME: Sometimes width() for #scorecontainer (and by extent,
+ // #scoresparkcontainer) on Chrome for mobile seems to start off
+ // at something very small, and then suddenly snap back into place.
+ // Figure out why.
+ var max_moves = Math.floor($("#scoresparkcontainer").width() / 5) - 5;
+ if (last_move_num - first_move_num > max_moves) {
+ first_move_num = last_move_num - max_moves;
+ }
+
+ var min_score = -100;
+ var max_score = 100;
+ var last_score = null;
+ var scores = [];
+ for (var halfmove_num = first_move_num; halfmove_num <= last_move_num; ++halfmove_num) {
+ if (data['score_history'][halfmove_num]) {
+ 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;
+ }
+ scores.push(last_score);
+ }
+ if (data['score']) {
+ scores.push(compute_plot_score(data['score']));
+ }
+ // FIXME: at some widths, calling sparkline() seems to push
+ // #scorecontainer under the board.
+ $("#scorespark").sparkline(scores, {
+ type: 'bar',
+ zeroColor: 'gray',
+ chartRangeMin: min_score,
+ chartRangeMax: max_score,
+ tooltipFormatter: function(sparkline, options, fields) {
+ // score_history contains the Nth _position_, but format_tooltip
+ // wants to format the Nth _move_; thus the -1.
+ return format_tooltip(data, fields[0].offset + first_move_num - 1);
+ }
+ });
+ $('#scorespark').bind('sparklineClick', function(event) {
+ var sparkline = event.sparklines[0];
+ var region = sparkline.getCurrentRegionFields();
+ if (region[0].offset !== undefined) {
+ show_line(0, first_move_num + region[0].offset - 1);
+ }
+ });
+ } else {
+ $("#scorespark").text("");
+ }
+ } else {
+ $("#scorespark").text("");
+ }
+}
+
+/**
+ * @param {number} num_viewers
+ */
+var update_num_viewers = function(num_viewers) {
+ if (num_viewers === null) {
+ $("#numviewers").text("");
+ } else if (num_viewers == 1) {
+ $("#numviewers").text("You are the only current viewer");
+ } else {
+ $("#numviewers").text(num_viewers + " current viewers");
+ }
+}
+
+var update_clock = function() {
+ clearTimeout(clock_timer);
+
+ var data = displayed_analysis_data || current_analysis_data;
+ if (!data) return;
+
+ if (data['position']) {
+ var result = data['position']['result'];
+ if (result === '1-0') {
+ $("#whiteclock").text("1");
+ $("#blackclock").text("0");
+ $("#whiteclock").removeClass("running-clock");
+ $("#blackclock").removeClass("running-clock");
+ return;
+ }
+ if (result === '1/2-1/2') {
+ $("#whiteclock").text("1/2");
+ $("#blackclock").text("1/2");
+ $("#whiteclock").removeClass("running-clock");
+ $("#blackclock").removeClass("running-clock");
+ return;
+ }
+ if (result === '0-1') {
+ $("#whiteclock").text("0");
+ $("#blackclock").text("1");
+ $("#whiteclock").removeClass("running-clock");
+ $("#blackclock").removeClass("running-clock");
+ return;
+ }
+ }
+
+ var white_clock_ms = null;
+ var black_clock_ms = null;
+
+ // Static clocks.
+ if (data['position'] &&
+ data['position']['white_clock'] &&
+ data['position']['black_clock']) {
+ white_clock_ms = data['position']['white_clock'] * 1000;
+ black_clock_ms = data['position']['black_clock'] * 1000;
+ }
+
+ // Dynamic clock (only one, obviously).
+ var color;
+ if (data['position']['white_clock_target']) {
+ color = "white";
+ $("#whiteclock").addClass("running-clock");
+ $("#blackclock").removeClass("running-clock");
+ } else if (data['position']['black_clock_target']) {
+ color = "black";
+ $("#whiteclock").removeClass("running-clock");
+ $("#blackclock").addClass("running-clock");
+ } else {
+ $("#whiteclock").removeClass("running-clock");
+ $("#blackclock").removeClass("running-clock");
+ }
+ var remaining_ms;
+ if (color) {
+ var now = new Date().getTime() + client_clock_offset_ms;
+ remaining_ms = data['position'][color + '_clock_target'] * 1000 - now;
+ if (color === "white") {
+ white_clock_ms = remaining_ms;
+ } else {
+ black_clock_ms = remaining_ms;
+ }
+ }
+
+ if (white_clock_ms === null || black_clock_ms === null) {
+ $("#whiteclock").empty();
+ $("#blackclock").empty();
+ return;
+ }
+
+ // If either player has twenty minutes or less left, add the second counters.
+ // This matches what DGT clocks do.
+ var show_seconds = (white_clock_ms < 60 * 20 * 1000 || black_clock_ms < 60 * 20 * 1000);
+
+ if (color) {
+ // See when the clock will change next, and update right after that.
+ var next_update_ms;
+ if (show_seconds) {
+ next_update_ms = remaining_ms % 1000 + 100;
+ } else {
+ next_update_ms = remaining_ms % 60000 + 100;
+ }
+ clock_timer = setTimeout(update_clock, next_update_ms);
+ }
+
+ $("#whiteclock").text(format_clock(white_clock_ms, show_seconds));
+ $("#blackclock").text(format_clock(black_clock_ms, show_seconds));
+}
+
+/**
+ * @param {Number} remaining_ms
+ * @param {boolean} show_seconds
+ */
+var format_clock = function(remaining_ms, show_seconds) {
+ if (remaining_ms <= 0) {
+ if (show_seconds) {
+ return "00:00:00";
+ } else {
+ return "00:00";
+ }
+ }
+
+ var remaining = Math.floor(remaining_ms / 1000);
+ var seconds = remaining % 60;
+ remaining = (remaining - seconds) / 60;
+ var minutes = remaining % 60;
+ remaining = (remaining - minutes) / 60;
+ var hours = remaining;
+ if (show_seconds) {
+ return format_2d(hours) + ":" + format_2d(minutes) + ":" + format_2d(seconds);
+ } else {
+ return format_2d(hours) + ":" + format_2d(minutes);
+ }
+}
+
+/**
+ * @param {Number} x
+ */
+var format_2d = function(x) {
+ if (x >= 10) {
+ return x;
+ } else {
+ return "0" + x;
+ }
+}
+
+/**
+ * @param {string} move
+ * @param {Number} move_num Move number of this move.
+ * @param {boolean} white_to_play Whether white is to play this move.
+ */
+var format_move_with_number = function(move, move_num, white_to_play) {
+ var ret;
+ if (white_to_play) {
+ ret = move_num + '. ';
+ } else {
+ ret = move_num + '… ';
+ }
+ ret += move;
+ return ret;
+}
+
+/**
+ * @param {string} move
+ * @param {Number} halfmove_num Half-move number that is to be played,
+ * starting from 0.
+ */
+var format_halfmove_with_number = function(move, halfmove_num) {
+ return format_move_with_number(
+ move,
+ Math.floor(halfmove_num / 2) + 1,
+ halfmove_num % 2 == 0);
+}
+
+/**
+ * @param {Object} data
+ * @param {Number} halfmove_num
+ */
+var format_tooltip = function(data, halfmove_num) {
+ if (data['score_history'][halfmove_num + 1] ||
+ (halfmove_num + 1) === data['position']['history'].length) {
+ // Position is in the history, or it is the current position
+ // (which is implicitly tacked onto the history).
+ var move;
+ var short_score;
+ if ((halfmove_num + 1) === data['position']['history'].length) {
+ move = data['position']['last_move'];
+ short_score = format_short_score(data['score']);
+ } else {
+ move = data['position']['history'][halfmove_num];
+ short_score = format_short_score(data['score_history'][halfmove_num + 1]);
+ }
+ if (halfmove_num === -1) {
+ return "Start position: " + short_score;
+ } else {
+ var move_with_number = format_halfmove_with_number(move, halfmove_num);
+ return "After " + move_with_number + ": " + short_score;
+ }
+ } else {
+ for (var i = halfmove_num; i --> -1; ) {
+ if (data['score_history'][i]) {
+ var move = data['position']['history'][i];
+ if (i === -1) {
+ return "[Analysis kept from start position]";
+ } else {
+ return "[Analysis kept from " + format_halfmove_with_number(move, i) + "]";
+ }
+ }
+ }
+ }
+}
+
+/**
+ * @param {boolean} sort_by_score
+ */
+var resort_refutation_lines = function(sort_by_score) {
+ sort_refutation_lines_by_score = sort_by_score;
+ if (supports_html5_storage()) {
+ localStorage['sort_refutation_lines_by_score'] = sort_by_score ? 1 : 0;
+ }
+ update_refutation_lines();
+}
+window['resort_refutation_lines'] = resort_refutation_lines;
+
+/**
+ * @param {boolean} truncate_history
+ */
+var set_truncate_history = function(truncate_history) {
+ truncate_display_history = truncate_history;
+ update_refutation_lines();
+}
+window['set_truncate_history'] = set_truncate_history;
+
+/**
+ * @param {number} line_num
+ * @param {number} move_num
+ */
+var show_line = function(line_num, move_num) {
+ if (line_num == -1) {
+ current_display_line = null;
+ current_display_move = null;
+ hash_refutation_lines = null;
+ if (displayed_analysis_data) {
+ // TODO: Support exiting to history position if we are in an
+ // analysis line of a history position.
+ displayed_analysis_data = null;
+ }
+ update_board();
+ return;
+ } else {
+ current_display_line = jQuery.extend({}, display_lines[line_num]); // Shallow clone.
+ current_display_move = move_num + current_display_line.start_display_move_num;
+ }
+ current_display_line_is_history = (line_num == 0);
+
+ update_historic_analysis();
+ update_displayed_line();
+ update_board_highlight();
+ update_move_highlight();
+ redraw_arrows();
+}
+window['show_line'] = show_line;
+
+var prev_move = function() {
+ if (current_display_line &&
+ current_display_move >= current_display_line.start_display_move_num) {
+ --current_display_move;
+ }
+ update_historic_analysis();
+ update_displayed_line();
+ update_move_highlight();
+}
+window['prev_move'] = prev_move;
+
+var next_move = function() {
+ if (current_display_line &&
+ current_display_move < current_display_line.pv.length - 1) {
+ ++current_display_move;
+ }
+ update_historic_analysis();
+ update_displayed_line();
+ update_move_highlight();
+}
+window['next_move'] = next_move;
+
+var next_game = function() {
+ if (current_games === null) {
+ return;
+ }
+
+ // Try to find the game we are currently looking at.
+ for (var game_num = 0; game_num < current_games.length; ++game_num) {
+ var game = current_games[game_num];
+ if (game['url'] === backend_url) {
+ var next_game_num = (game_num + 1) % current_games.length;
+ switch_backend(current_games[next_game_num]);
+ return;
+ }
+ }
+
+ // Couldn't find it; give up.
+}
+
+var update_historic_analysis = function() {
+ if (!current_display_line_is_history) {
+ return;
+ }
+ if (current_display_move == current_display_line.pv.length - 1) {
+ displayed_analysis_data = null;
+ update_board();
+ }
+
+ // Fetch old analysis for this line if it exists.
+ var hiddenboard = chess_from(null, current_display_line.pv, current_display_move);
+ var filename = "/history/move" + (current_display_move + 1) + "-" +
+ hiddenboard.fen().replace(/ /g, '_').replace(/\//g, '-') + ".json";
+
+ current_historic_xhr = $.ajax({
+ url: filename
+ }).done(function(data, textstatus, xhr) {
+ displayed_analysis_data = data;
+ update_board();
+ }).fail(function(jqXHR, textStatus, errorThrown) {
+ if (textStatus === "abort") {
+ // Aborted because we are switching backends. Don't do anything;
+ // we will already have been cleared.
+ } else {
+ displayed_analysis_data = {'failed': true};
+ update_board();
+ }
+ });
+}
+
+/**
+ * @param {string} fen
+ */
+var update_imbalance = function(fen) {
+ var hiddenboard = new Chess(fen);
+ var imbalance = {'k': 0, 'q': 0, 'r': 0, 'b': 0, 'n': 0, 'p': 0};
+ for (var row = 0; row < 8; ++row) {
+ for (var col = 0; col < 8; ++col) {
+ var col_text = String.fromCharCode('a1'.charCodeAt(0) + col);
+ var row_text = String.fromCharCode('a1'.charCodeAt(1) + row);
+ var square = col_text + row_text;
+ var contents = hiddenboard.get(square);
+ if (contents !== null) {
+ if (contents.color === 'w') {
+ ++imbalance[contents.type];
+ } else {
+ --imbalance[contents.type];
+ }
+ }
+ }
+ }
+ var white_imbalance = '';
+ var black_imbalance = '';
+ for (var piece in imbalance) {
+ for (var i = 0; i < imbalance[piece]; ++i) {
+ white_imbalance += '<img src="img/chesspieces/wikipedia/w' + piece.toUpperCase() + '.png" alt="" style="width: 15px;height: 15px;">';
+ }
+ for (var i = 0; i < -imbalance[piece]; ++i) {
+ black_imbalance += '<img src="img/chesspieces/wikipedia/b' + piece.toUpperCase() + '.png" alt="" style="width: 15px;height: 15px;">';
+ }
+ }
+ $('#whiteimbalance').html(white_imbalance);
+ $('#blackimbalance').html(black_imbalance);
+}
+
+/** Mark the currently selected move in red.
+ * Also replaces the PV with the current displayed line if it's not shown
+ * anywhere else on the screen.
+ */
+var update_move_highlight = function() {
+ if (highlighted_move !== null) {
+ highlighted_move.removeClass('highlight');
+ }
+ if (current_display_line) {
+ var display_line_num = find_display_line_matching_num();
+ if (display_line_num === null) {
+ // Replace the PV with the (complete) line.
+ $("#pvtitle").text("Exploring:");
+ current_display_line.start_display_move_num = 0;
+ display_lines.push(current_display_line);
+ $("#pv").html(print_pv(display_lines.length - 1));
+ display_line_num = display_lines.length - 1;
+
+ // Clear out the PV, so it's not selected by anything later.
+ display_lines[1].pv = [];
+ }
+
+ highlighted_move = $("#automove" + display_line_num + "-" + (current_display_move - current_display_line.start_display_move_num));
+ highlighted_move.addClass('highlight');
+ }
+}
+
+/**
+ * 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.pv.length !== line.pv.length) continue;
+ var ok = true;
+ for (var j = 0; j < line.pv.length; ++j) {
+ if (current_display_line.pv[j] !== line.pv[j]) {
+ ok = false;
+ break;
+ }
+ }
+ if (ok) {
+ return i;
+ }
+ }
+ return null;
+}
+
+/** Update the board based on the currently displayed line.
+ *
+ * TODO: This should really be called only whenever something changes,
+ * instead of all the time.
+ */
+var update_displayed_line = function() {
+ if (current_display_line === null) {
+ $("#linenav").hide();
+ $("#linemsg").show();
+ display_fen = base_fen;
+ set_board_position(base_fen);
+ update_imbalance(base_fen);
+ return;
+ }
+
+ $("#linenav").show();
+ $("#linemsg").hide();
+
+ if (current_display_move <= 0) {
+ $("#prevmove").html("Previous");
+ } else {
+ $("#prevmove").html("<a href=\"javascript:prev_move();\">Previous</a></span>");
+ }
+ if (current_display_move == current_display_line.pv.length - 1) {
+ $("#nextmove").html("Next");
+ } else {
+ $("#nextmove").html("<a href=\"javascript:next_move();\">Next</a></span>");
+ }
+
+ var hiddenboard = chess_from(current_display_line.start_fen, current_display_line.pv, current_display_move);
+ set_board_position(hiddenboard.fen());
+ if (display_fen !== hiddenboard.fen() && !current_display_line_is_history) {
+ // Fire off a hash request, since we're now off the main position
+ // and it just changed.
+ explore_hash(hiddenboard.fen());
+ }
+ display_fen = hiddenboard.fen();
+ update_imbalance(hiddenboard.fen());
+}
+
+var set_board_position = function(new_fen) {
+ board_is_animating = true;
+ var old_fen = board.fen();
+ board.position(new_fen);
+ if (board.fen() === old_fen) {
+ board_is_animating = false;
+ }
+}
+
+/**
+ * @param {boolean} param_enable_sound
+ */
+var set_sound = function(param_enable_sound) {
+ enable_sound = param_enable_sound;
+ if (enable_sound) {
+ $("#soundon").html("<strong>On</strong>");
+ $("#soundoff").html("<a href=\"javascript:set_sound(false)\">Off</a>");
+
+ // Seemingly at least Firefox prefers MP3 over Opus; tell it otherwise,
+ // and also preload the file since the user has selected audio.
+ var ding = document.getElementById('ding');
+ if (ding && ding.canPlayType && ding.canPlayType('audio/ogg; codecs="opus"') === 'probably') {
+ ding.src = 'ding.opus';
+ ding.load();
+ }
+ } else {
+ $("#soundon").html("<a href=\"javascript:set_sound(true)\">On</a>");
+ $("#soundoff").html("<strong>Off</strong>");
+ }
+ if (supports_html5_storage()) {
+ localStorage['enable_sound'] = enable_sound ? 1 : 0;
+ }
+}
+window['set_sound'] = set_sound;
+
+/** Send off a hash probe request to the backend.
+ * @param {string} fen
+ */
+var explore_hash = function(fen) {
+ // If we already have a backend response going, abort it.
+ if (current_hash_xhr) {
+ current_hash_xhr.abort();
+ }
+ if (current_hash_display_timer) {
+ 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) {
+ show_explore_hash_results(data, fen);
+ });
+}
+
+/** Process the JSON response from a hash probe request.
+ * @param {!Object} data
+ * @param {string} fen
+ */
+var show_explore_hash_results = function(data, fen) {
+ if (board_is_animating) {
+ // Updating while the animation is still going causes
+ // the animation to jerk. This is pretty crude, but it will do.
+ current_hash_display_timer = setTimeout(function() { show_explore_hash_results(data, fen); }, 100);
+ return;
+ }
+ current_hash_display_timer = null;
+ hash_refutation_lines = data['lines'];
+ 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');