Add clock support.
authorSteinar H. Gunderson <sgunderson@bigfoot.com>
Sun, 23 Nov 2014 00:42:13 +0000 (01:42 +0100)
committerSteinar H. Gunderson <sgunderson@bigfoot.com>
Sun, 23 Nov 2014 00:42:13 +0000 (01:42 +0100)
Position.pm
remoteglot.pl
www/css/remoteglot.css
www/index.html
www/js/remoteglot.js

index 9333bcd..2e368f2 100644 (file)
@@ -28,6 +28,8 @@ sub new {
        $pos->{'player_b'} = $x[18];
        $pos->{'player_w'} =~ s/^W?[FCIG]M//;
        $pos->{'player_b'} =~ s/^W?[FCIG]M//;
+       $pos->{'white_clock'} = $x[24];
+       $pos->{'black_clock'} = $x[25];
        $pos->{'move_num'} = $x[26];
        if ($x[27] =~ /([a-h][1-8])-([a-h][1-8])/) {
                $pos->{'last_move_uci'} = $1 . $2;
index 39a0f4b..b546589 100755 (executable)
@@ -36,6 +36,9 @@ my $tb_retry_timer = undef;
 my %tb_cache = ();
 my $tb_lookup_running = 0;
 
+# TODO: Persist (parts of) this so that we can restart.
+my %clock_target_for_pos = ();
+
 $| = 1;
 
 open(FICSLOG, ">ficslog.txt")
@@ -269,7 +272,7 @@ sub handle_pgn {
                warn "Error in parsing PGN from $url\n";
        } else {
                eval {
-                       $pgn->quick_parse_game;
+                       $pgn->parse_game({ save_comments => 'yes' });
                        my $pos = Position->start_pos($pgn->white, $pgn->black);
                        my $moves = $pgn->moves;
                        my @uci_moves = ();
@@ -278,8 +281,11 @@ sub handle_pgn {
                                ($pos, $uci_move) = $pos->make_pretty_move($move);
                                push @uci_moves, $uci_move;
                        }
+                       $pos->{'result'} = $pgn->result;
                        $pos->{'pretty_history'} = $moves;
 
+                       extract_clock($pgn, $pos);
+
                        # Sometimes, PGNs lose a move or two for a short while,
                        # or people push out new ones non-atomically. 
                        # Thus, if we PGN doesn't change names but becomes
@@ -313,6 +319,7 @@ sub handle_pgn {
 
 sub handle_position {
        my ($pos) = @_;
+       find_clock_start($pos);
                
        # if this is already in the queue, ignore it
        return if (defined($pos_waiting) && $pos->fen() eq $pos_waiting->fen());
@@ -325,6 +332,19 @@ sub handle_position {
        # if we're already thinking on something, stop and wait for the engine
        # to approve
        if (defined($pos_calculating)) {
+               # Store the final data we have for this position in the history,
+               # with the precise clock information we just got from the new
+               # position. (Historic positions store the clock at the end of
+               # the position.)
+               #
+               # Do not output anything new to the main analysis; that's
+               # going to be obsolete really soon.
+               $pos_calculating->{'white_clock'} = $pos->{'white_clock'};
+               $pos_calculating->{'black_clock'} = $pos->{'black_clock'};
+               delete $pos_calculating->{'white_clock_target'};
+               delete $pos_calculating->{'black_clock_target'};
+               output_json(1);
+
                if (!defined($pos_waiting)) {
                        uciprint($engine, "stop");
                }
@@ -572,7 +592,7 @@ sub output {
        }
 
        output_screen();
-       output_json();
+       output_json(0);
        $latest_update = [Time::HiRes::gettimeofday];
 }
 
@@ -694,6 +714,7 @@ sub output_screen {
 }
 
 sub output_json {
+       my $historic_json_only = shift;
        my $info = $engine->{'info'};
 
        my $json = {};
@@ -739,13 +760,13 @@ sub output_json {
        $json->{'refutation_lines'} = \%refutation_lines;
 
        my $encoded = JSON::XS::encode_json($json);
-       atomic_set_contents($remoteglotconf::json_output, $encoded);
+       unless ($historic_json_only) {
+               atomic_set_contents($remoteglotconf::json_output, $encoded);
+       }
 
        if (exists($pos_calculating->{'pretty_history'}) &&
            defined($remoteglotconf::json_history_dir)) {
-               my $halfmove_num = scalar @{$pos_calculating->{'pretty_history'}};
-               (my $fen = $pos_calculating->fen()) =~ tr,/ ,-_,;
-               my $filename = $remoteglotconf::json_history_dir . "/move$halfmove_num-$fen.json";
+               my $filename = $remoteglotconf::json_history_dir . "/" . id_for_pos($pos_calculating) . ".json";
 
                # Overwrite old analysis (assuming it exists at all) if we're
                # using a different engine, or if we've calculated deeper.
@@ -773,6 +794,14 @@ sub atomic_set_contents {
        rename($filename . ".tmp", $filename);
 }
 
+sub id_for_pos {
+       my $pos = shift;
+
+       my $halfmove_num = scalar @{$pos->{'pretty_history'}};
+       (my $fen = $pos->fen()) =~ tr,/ ,-_,;
+       return "move$halfmove_num-$fen";
+}
+
 sub get_json_analysis_stats {
        my $filename = shift;
 
@@ -946,6 +975,80 @@ sub book_info {
        return $text;
 }
 
+sub extract_clock {
+       my ($pgn, $pos) = @_;
+
+       # Look for extended PGN clock tags.
+       my $tags = $pgn->tags;
+       if (exists($tags->{'WhiteClock'}) && exists($tags->{'BlackClock'})) {
+               $pos->{'white_clock'} = $tags->{'WhiteClock'};
+               $pos->{'black_clock'} = $tags->{'BlackClock'};
+               return;
+       }
+
+       # Look for TCEC-style time comments.
+       my $moves = $pgn->moves;
+       my $comments = $pgn->comments;
+       my $last_black_move = int((scalar @$moves) / 2);
+       my $last_white_move = int((1 + scalar @$moves) / 2);
+
+       my $black_key = $last_black_move . "b";
+       my $white_key = $last_white_move . "w";
+
+       if (exists($comments->{$white_key}) &&
+           exists($comments->{$black_key}) &&
+           $comments->{$white_key} =~ /tl=(\d+:\d+:\d+)/ &&
+           $comments->{$black_key} =~ /tl=(\d+:\d+:\d+)/) {
+               $comments->{$white_key} =~ /tl=(\d+:\d+:\d+)/;
+               $pos->{'white_clock'} = $1;
+               $comments->{$black_key} =~ /tl=(\d+:\d+:\d+)/;
+               $pos->{'black_clock'} = $1;
+               return;
+       }
+}
+
+sub find_clock_start {
+       my $pos = shift;
+
+       # If the game is over, the clock is stopped.
+       if ($pos->{'result'} eq '1-0' ||
+           $pos->{'result'} eq '1/2-1/2' ||
+           $pos->{'result'} eq '0-1') {
+               return;
+       }
+
+       # When we don't have any moves, we assume the clock hasn't started yet.
+       if ($pos->{'move_num'} == 1 && $pos->{'toplay'} eq 'W') {
+               return;
+       }
+
+       my $id = id_for_pos($pos);
+       if (exists($clock_target_for_pos{$id})) {
+               if ($pos->{'toplay'} eq 'W') {
+                       $pos->{'white_clock_target'} = $clock_target_for_pos{$id};
+               } else {
+                       $pos->{'black_clock_target'} = $clock_target_for_pos{$id};
+               }
+               return;
+       }
+
+       # OK, we haven't seen this position before, so we assume the move
+       # happened right now.
+       my $key = ($pos->{'toplay'} eq 'W') ? 'white_clock' : 'black_clock';
+       if (!exists($pos->{$key})) {
+               # No clock information.
+               return;
+       }
+       $pos->{$key} =~ /(\d+):(\d+):(\d+)/;
+       my $time_left = $1 * 3600 + $2 * 60 + $3;
+       $clock_target_for_pos{$id} = time + $time_left;
+       if ($pos->{'toplay'} eq 'W') {
+               $pos->{'white_clock_target'} = $clock_target_for_pos{$id};
+       } else {
+               $pos->{'black_clock_target'} = $clock_target_for_pos{$id};
+       }
+}
+
 sub schedule_tb_lookup {
        return if (!defined($remoteglotconf::tb_serial_key));
        my $pos = $pos_waiting // $pos_calculating;
index 23bbeca..8551289 100644 (file)
@@ -83,14 +83,28 @@ p {
 #hiddenboard {
        display: none;
 }
-#numviewers {
+#bottompanel {
        display: block;
        width: 100%;
-       text-align: center;
        font-size: smaller;
        margin-top: 0.5em;
        margin-bottom: 0;
 }
+#numviewers {
+       width: auto;
+       text-align: center;
+}
+#whiteclock {
+       float: left;
+       width: 20%;
+       text-align: left;
+}
+#blackclock {
+       float: right;
+       width: 20%;
+       text-align: right;
+       margin-right: 5px;
+}
 #analysis {
        display: block;
        min-width: 400px;
index aece701..cf6093e 100644 (file)
 <h1 id="headline">Analysis</h1>
 <div id="boardcontainer">
   <div id="board"></div>
-  <p id="numviewers"></p>
+  <div id="bottompanel">
+    <p id="whiteclock"></p>
+    <p id="blackclock"></p>
+    <p id="numviewers"></p>
+  </div>
 </div>
 <div id="analysis">
   <p id="score">Score:</p>
index 3574453..01fee37 100644 (file)
@@ -68,6 +68,18 @@ var unique = null;
 /** @type {boolean} @private */
 var enable_sound = false;
 
+/**
+ * Our best estimate of how many milliseconds we need to add to 
+ * new Date() to get the true UTC time. Calibrated against the
+ * server clock.
+ *
+ * @type {?number}
+ * @private
+ */
+var client_clock_offset_ms = null;
+
+var clock_timer = null;
+
 /** The current position on the board, represented as a FEN string.
  * @type {?string}
  * @private
@@ -122,6 +134,7 @@ var request_update = function() {
        $.ajax({
                url: "/analysis.pl?ims=" + ims + "&unique=" + unique
        }).done(function(data, textstatus, xhr) {
+               sync_server_clock(xhr.getResponseHeader('Date'));
                ims = xhr.getResponseHeader('X-Remoteglot-Last-Modified');
                var num_viewers = xhr.getResponseHeader('X-Remoteglot-Num-Viewers');
                possibly_play_sound(current_analysis_data, data);
@@ -155,6 +168,23 @@ var possibly_play_sound = function(old_data, new_data) {
        }
 }
 
+/**
+ * @type {!string} server_date_string
+ */
+var sync_server_clock = function(server_date_string) {
+       var server_time_ms = new Date(server_date_string).getTime();
+       var client_time_ms = new Date().getTime();
+       var estimated_offset_ms = server_time_ms - client_time_ms;
+
+       // In order not to let the noise move us too much back and forth
+       // (the server only has one-second resolution anyway), we only
+       // change an existing skew if we are at least five seconds off.
+       if (client_clock_offset_ms === null ||
+           Math.abs(estimated_offset_ms - client_clock_offset_ms) > 5000) {
+               client_clock_offset_ms = estimated_offset_ms;
+       }
+}
+
 var clear_arrows = function() {
        for (var i = 0; i < arrows.length; ++i) {
                if (arrows[i].svg) {
@@ -690,6 +720,8 @@ var update_board = function(current_data, display_data) {
                $("#pv").empty();
                $("#searchstats").html("&nbsp;");
                $("#refutationlines").empty();
+               $("#whiteclock").empty();
+               $("#blackclock").empty();
                refutation_lines = [];
                update_refutation_lines();
                clear_arrows();
@@ -697,6 +729,8 @@ var update_board = function(current_data, display_data) {
                return;
        }
 
+       update_clock();
+
        // The engine id.
        if (data['id'] && data['id']['name'] !== null) {
                $("#engineid").text(data['id']['name']);
@@ -808,6 +842,93 @@ var update_num_viewers = function(num_viewers) {
        }
 }
 
+var update_clock = function() {
+       clearTimeout(clock_timer);
+
+       var data = displayed_analysis_data || current_analysis_data;
+       if (data['position']) {
+               var result = data['position']['result'];
+               if (result === '1-0') {
+                       $("#whiteclock").text("1");
+                       $("#blackclock").text("0");
+                       return;
+               }
+               if (result === '1/2-1/2') {
+                       $("#whiteclock").text("1/2");
+                       $("#blackclock").text("1/2");
+                       return;
+               }       
+               if (result === '0-1') {
+                       $("#whiteclock").text("0");
+                       $("#blackclock").text("1");
+                       return;
+               }
+       }
+
+       var white_clock = "";
+       var black_clock = "";
+
+       // Static clocks.
+       if (data['position'] &&
+           data['position']['white_clock'] &&
+           data['position']['black_clock']) {
+               white_clock = data['position']['white_clock'];
+               black_clock = data['position']['black_clock'];
+       }
+
+       // Dynamic clock (only one, obviously).
+       var color;
+       if (data['position']['white_clock_target']) {
+               color = "white";
+       } else if (data['position']['black_clock_target']) {
+               color = "black";
+       }
+       if (color) {
+               var now = new Date().getTime() + client_clock_offset_ms;
+               var remaining_ms = data['position'][color + '_clock_target'] * 1000 - now;
+               if (color === "white") {
+                       white_clock = format_clock(remaining_ms);
+               } else {
+                       black_clock = format_clock(remaining_ms);
+               }
+
+               // See when the clock will change next, and update right after that.
+               var next_update_ms = remaining_ms % 1000 + 100;
+               clock_timer = setTimeout(update_clock, next_update_ms);
+       }
+
+       $("#whiteclock").text(white_clock);
+       $("#blackclock").text(black_clock);
+}
+
+/**
+ * @param {Number} remaining_ms
+ */
+var format_clock = function(remaining_ms) {
+       if (remaining_ms <= 0) {
+               return "00: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;
+       return format_2d(hours) + ":" + format_2d(minutes) + ":" + format_2d(seconds);  
+}
+
+/**
+ * @param {Number} x
+ */
+var format_2d = function(x) {
+       if (x >= 10) {
+               return x;
+       } else {
+               return "0" + x;
+       }
+}
+
 /**
  * @param {string} move
  * @param {Number} move_num