Add a Makefile for the book builder stuff.
[remoteglot] / remoteglot.pl
index e3433aa..6a5778a 100755 (executable)
@@ -35,6 +35,10 @@ my $stop_pgn_fetch = 0;
 my $tb_retry_timer = undef;
 my %tb_cache = ();
 my $tb_lookup_running = 0;
+my $last_written_json = undef;
+
+# TODO: Persist (parts of) this so that we can restart.
+my %clock_target_for_pos = ();
 
 $| = 1;
 
@@ -209,7 +213,6 @@ sub handle_fics {
                for my $pos ($pos_waiting, $pos_calculating) {
                        next if (!defined($pos));
                        if ($pos->fen() eq $pos_for_movelist->fen()) {
-                               $pos->{'history'} = \@uci_movelist;
                                $pos->{'pretty_history'} = \@pretty_movelist;
                        }
                }
@@ -266,11 +269,11 @@ sub handle_pgn {
        }
 
        my $pgn = Chess::PGN::Parse->new(undef, $body);
-       if (!defined($pgn) || !$pgn->read_game()) {
+       if (!defined($pgn) || !$pgn->read_game() || $body !~ /^\[/) {
                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 = ();
@@ -279,9 +282,11 @@ sub handle_pgn {
                                ($pos, $uci_move) = $pos->make_pretty_move($move);
                                push @uci_moves, $uci_move;
                        }
-                       $pos->{'history'} = \@uci_moves;
+                       $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
@@ -315,6 +320,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());
@@ -327,6 +333,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");
                }
@@ -574,7 +593,7 @@ sub output {
        }
 
        output_screen();
-       output_json();
+       output_json(0);
        $latest_update = [Time::HiRes::gettimeofday];
 }
 
@@ -696,6 +715,7 @@ sub output_screen {
 }
 
 sub output_json {
+       my $historic_json_only = shift;
        my $info = $engine->{'info'};
 
        my $json = {};
@@ -711,8 +731,7 @@ sub output_json {
        $json->{'seldepth'} = $info->{'seldepth'};
        $json->{'tablebase'} = $info->{'tablebase'};
 
-       # single-PV only for now
-       $json->{'pv_uci'} = $info->{'pv'};
+       $json->{'pv_uci'} = $info->{'pv'};  # Still needs to be there for the JS to calculate arrows; only for the primary PV, though!
        $json->{'pv_pretty'} = [ prettyprint_pv($pos_calculating, @{$info->{'pv'}}) ];
 
        my %refutation_lines = ();
@@ -736,20 +755,21 @@ sub output_json {
                                        pretty_move => $pretty_move,
                                        pv_pretty => \@pretty_pv,
                                };
-                               $refutation_lines{$pv->[0]}->{'pv_uci'} = $pv;
                        };
                }
        }
        $json->{'refutation_lines'} = \%refutation_lines;
 
        my $encoded = JSON::XS::encode_json($json);
-       atomic_set_contents($remoteglotconf::json_output, $encoded);
+       unless ($historic_json_only || !defined($remoteglotconf::json_output) ||
+               (defined($last_written_json) && $last_written_json eq $encoded)) {
+               atomic_set_contents($remoteglotconf::json_output, $encoded);
+               $last_written_json = $encoded;
+       }
 
-       if (exists($pos_calculating->{'history'}) &&
+       if (exists($pos_calculating->{'pretty_history'}) &&
            defined($remoteglotconf::json_history_dir)) {
-               my $halfmove_num = scalar @{$pos_calculating->{'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.
@@ -777,6 +797,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;
 
@@ -950,6 +978,89 @@ 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'};
+
+               $pos->{'white_clock'} =~ s/\b(\d)\b/0$1/g;
+               $pos->{'black_clock'} =~ s/\b(\d)\b/0$1/g;
+               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 (exists($pos->{'result'}) &&
+           ($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;
+       }
+
+       # TODO(sesse): Maybe we can get the number of moves somehow else for FICS games.
+       if (!exists($pos->{'pretty_history'})) {
+               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;