--- kgsueme/kgsueme/game.pl	2003/05/31 14:55:55	1.6
+++ kgsueme/kgsueme/game.pl	2003/06/03 04:45:43	1.34
@@ -1,3 +1,187 @@
+package game::goclock;
+
+use Time::HiRes ();
+
+use KGS::Constants;
+
+use base gtk::widget;
+
+sub new {
+   my $class = shift;
+   my $self = $class->SUPER::new(@_);
+
+   $self->{widget} = new Gtk2::Label;
+
+   $self->{set}    = sub { };
+   $self->{format} = sub { "ERROR" };
+
+   $self;
+}
+
+sub format_time($) {
+   my ($time) = @_;
+
+   $time > 60*60
+      ? sprintf "%d:%02d:%02d", $time / (60 * 60), $time / 60 % 60, $time % 60
+      : sprintf      "%d:%02d", $time / 60 % 60, $time % 60;
+}
+
+sub set_rules {
+   my ($self, $timesys, $main, $interval, $count) = @_;
+
+   if ($timesys == TIMESYS_ABSOLUTE) {
+      $self->{set}    = sub { $self->{time} = $_[0] };
+      $self->{format} = sub { format_time $_[0] };
+
+   } elsif ($timesys == TIMESYS_BYO_YOMI) {
+      my $low = $interval * $count;
+
+      $self->{set}    = sub { $self->{time} = $_[0] };
+
+      $self->{format} = sub {
+         if ($_[0] > $low) {
+            format_time $_[0] - $low;
+         } else {
+            sprintf "%s (%d)",
+                    format_time int ($_[0] % $interval) || $interval,
+                    $_[0] / $interval;
+         }
+      };
+
+   } elsif ($timesys == TIMESYS_CANADIAN) {
+      $self->{set}    = sub { $self->{time} = $_[0]; $self->{moves} = $_[1] };
+
+      $self->{format} = sub {
+         if (!$self->{moves}) {
+            format_time $_[0] - $low;
+         } else {
+            my $time = int($_[0] % $interval) || $interval;
+            sprintf "%s/%d (%d)",
+                    format_time $time,
+                    $self->{moves},
+                    int ($time / ($self->{moves} || 1));
+
+         }
+      };
+
+   } else {
+      # none, or unknown
+      $self->{set}    = sub { };
+      $self->{format} = sub { "---" }
+   }
+}
+
+sub refresh {
+   my ($self, $timestamp) = @_;
+   my $timer = $self->{time} + $self->{start} - $timestamp;
+   $self->{widget}->set_text ($self->{format}->($timer));
+
+   $timer - int $timer;
+}
+
+sub set_time {
+   my ($self, $time) = @_;
+
+   # we ignore requests to re-set the time of a running clock.
+   # this is the easiest way to ensure that commentary etc.
+   # doesn't re-set the clock. yes, this is frickle design,
+   # but I think the protoocl is to blame here, which gives
+   # very little time information. (cgoban2 also has had quite
+   # a lot of small time update problems...)
+   unless ($self->{timeout}) {
+      $self->{set}->($time->[0], $time->[1]);
+      $self->refresh ($self->{start});
+   }
+}
+
+sub start {
+   my ($self) = @_;
+
+   return if $self->{timeout};
+
+   # this is correct, since we assume the last message triggered a start
+   $self->{start} = $KGS::Protocol::NOW;
+
+   my $timeout; $timeout = sub {
+      # -100 means we run the timer a bit earlier to avoid 10.99 => 10s roundings.
+      # we "could" cheat by precalculating the time, but I feel uneasy about both
+      # ways to cheat.
+      my $next = int ($self->refresh (Time::HiRes::time) * 1000) - 100;
+      $next += 1000 if $next < 0;
+      $self->{timeout} = add Glib::Timeout $next, $timeout;
+      0;
+   };
+
+   $timeout->();
+}
+
+sub stop {
+   my ($self) = @_;
+
+   remove Glib::Source delete $self->{timeout} if $self->{timeout};
+}
+
+sub destroy {
+   my ($self) = @_;
+   $self->stop;
+   $self->SUPER::destroy;
+}
+
+package game::userpanel;
+
+use base gtk::widget;
+
+sub new {
+   my $class = shift;
+   my $self = $class->SUPER::new(@_);
+
+   $self->{widget} = new Gtk2::HBox;
+
+   $self->{widget}->add (my $vbox = new Gtk2::VBox);
+
+   $vbox->add ($self->{name} = new Gtk2::Label $self->{name});
+   $vbox->add ($self->{info} = new Gtk2::Label "");
+   $vbox->add (($self->{clock} = new game::goclock)->widget);
+
+   $vbox->add ($self->{imagebox} = new Gtk2::VBox);
+
+   $self;
+}
+
+sub set_rules {
+   my ($self, $rules) = @_;
+
+   if ($self->{name}->get_text ne $rules->{player}[$self->{colour}]) {
+      $self->{name}->set_text ($rules->{player}[$self->{colour}]);
+
+      $self->{imagebox}->remove ($_) for $self->{imagebox}->get_children;
+      $self->{imagebox}->add (gtk::image_from_data undef);
+      $self->{imagebox}->show_all;
+
+      # the big picture...
+      appwin::userpic ($rules->{player}[$self->{colour}], sub {
+         return unless $self->{imagebox};
+         if ($_[0]) {
+            $self->{imagebox}->remove ($_) for $self->{imagebox}->get_children;
+            $self->{imagebox}->add (gtk::image_from_data $_[0]);
+            $self->{imagebox}->show_all;
+         }
+      });
+   }
+   
+   $self->{clock}->set_rules (@{$rules->{rules}}{qw(timesys time interval count)});
+}
+
+sub set_state {
+   my ($self, $captures, $timer, $running) = @_;
+
+   $self->{clock}->stop unless $running;
+   $self->{clock}->set_time ($timer);
+   $self->{clock}->start if $running;
+
+   $self->{info}->set_text ("$captures pris.");
+}
+
 package game;
 
 use KGS::Constants;
@@ -8,6 +192,8 @@
 
 use base gtk::widget;
 
+use POSIX qw(ceil);
+
 sub new {
    my $self = shift;
    $self = $self->SUPER::new(@_);
@@ -20,50 +206,53 @@
    gtk::state $self->{window}, "game::window", undef, window_size => [600, 500];
 
    $self->{window}->signal_connect(delete_event => sub {
-      if ($self->{joined}) {
-         $self->part;
-      } else {
-         $self->event_part;
-      }
+      $self->part;
+      $self->destroy;
       1;
    });
 
    $self->{window}->add($self->{hpane} = new Gtk2::HPaned);
    gtk::state $self->{hpane}, "game::hpane", undef, position => 500;
 
+   $self->{hpane}->pack1(($self->{left} = new Gtk2::VBox), 1, 1);
+   
+   $self->{boardbox} = new Gtk2::VBox;
+
    $self->{hpane}->pack1((my $vbox = new Gtk2::VBox), 1, 1);
 
-   $vbox->pack_start((my $frame = new Gtk2::Frame), 0, 1, 0);
+   # challenge
+
+   $self->{challenge} = new challenge channel => $self->{channel};
+   
+   # board box (aspect/canvas)
+   
+   $self->{boardbox}->pack_start((my $frame = new Gtk2::Frame), 0, 1, 0);
 
    {
-      # grrr...
       $frame->add(my $vbox = new Gtk2::VBox);
       $vbox->add($self->{title} = new Gtk2::Label $title);
 
-      $self->{moveadj} = new Gtk2::Adjustment 1, 0, 1, 0.01, 0.1, 0;
+      $self->{moveadj} = new Gtk2::Adjustment 0, 0, 0, 1, 1, 0;
 
       $vbox->add(my $scale = new Gtk2::HScale $self->{moveadj});
       $scale->set_draw_value (0);
+      $scale->set_digits (0);
 
-      $self->{moveadj}->signal_connect (value_changed => sub {
-         return unless $self->{path};
-
-         my $move = int (@{$self->{path}} * $_[0]->get_value);
-
-         $self->{board} = new KGS::Game::Board $self->{size};
-         $self->{board}->interpret_path ([@{$self->{path}}[0 .. $move - 1]]);
+      $self->{moveadj}->signal_connect (value_changed => sub { $self->update_board });
+   }
 
-         $self->redraw ($self->repaint_board);
+   $self->{boardbox}->pack_start((my $aspect_frame = new Gtk2::AspectFrame "", 0.5, 0.5, 1, 0), 1, 1, 0);
+   $aspect_frame->set (border_width => 0, shadow_type => 'none', label_xalign => 0.5);
+   $self->{board_label} = $aspect_frame->get_label_widget;
 
-         $self->{text}->set_text(KGS::Listener::Debug::dumpval([$self->{board}{time},$self->{board}{captures}]). $self->{board}{comment});
-      });
-   }
-   
-   $vbox->pack_start(($self->{canvas} = new Gtk2::DrawingArea), 1, 1, 0);
+   $aspect_frame->add($self->{canvas} = new Gtk2::DrawingArea);
+   $self->{canvas}->double_buffered (0) if $::config->{conserve_memory};
 
    $self->{canvas}->signal_connect(configure_event => \&configure_event, $self);
    $self->{canvas}->signal_connect(expose_event    => \&expose_event,    $self);
 
+   # RIGHT PANE
+
    $self->{hpane}->pack2(($self->{vpane} = new Gtk2::VPaned), 0, 0);
    $self->{hpane}->set(position_set => 1);
    gtk::state $self->{vpane}, "game::vpane", $self->{name}, position => 80;
@@ -71,33 +260,37 @@
    $self->{vpane}->add(my $sw = new Gtk2::ScrolledWindow);
    $sw->set_policy("automatic", "always");
 
-   $sw->add(($self->{userlist} = new gtk::userlist)->widget);
+   $sw->add(($self->{userlist} = new userlist)->widget);
 
    $self->{vpane}->add(my $vbox = new Gtk2::VBox);
-   
-   $vbox->pack_start((my $sw = new Gtk2::ScrolledWindow), 1, 1, 0);
-   $sw->set_policy("automatic", "always");
 
-   $sw->add(($self->{text} = new gtk::text)->widget);
+   $vbox->pack_start((my $hbox = new Gtk2::HBox 1), 0, 1, 0);
+   $hbox->add (($self->{userpanel}[WHITE] = new game::userpanel colour => WHITE)->widget);
+   $hbox->add (($self->{userpanel}[BLACK] = new game::userpanel colour => BLACK)->widget);
+   
+   $vbox->pack_start(($self->{text} = new gtk::text)->widget, 1, 1, 0);
 
    $vbox->pack_start(($self->{entry} = new Gtk2::Entry), 0, 1, 0);
    $self->{entry}->signal_connect(activate => sub {
       my $text = $self->{entry}->get_text;
-      # add message
+      $self->say($text) if $text =~ /\S/;
       $self->{entry}->set_text("");
    });
 
+   $self->event_update_game;
    $self;
 }
 
 sub event_update_users {
-   my ($self) = @_;
+   my ($self, $add, $update, $remove) = @_;
 
-   $self->{userlist}->update($self->{users});
+   $self->{userlist}->update ($add, $update, $remove);
 }
 
 sub join {
    my ($self) = @_;
+   return if $self->{joined};
+
    $self->SUPER::join;
 
    $self->{window}->show_all;
@@ -105,9 +298,9 @@
 
 sub part {
    my ($self) = @_;
-   $self->SUPER::part;
 
-   $self->{window}->hide;
+   $self->SUPER::part;
+   $self->destroy;
 }
 
 sub configure_event {
@@ -126,12 +319,8 @@
    $self->{pixbuf} or return;
 
    my $area = $event->area;
-   my ($ox, $oy, $s) = @{$self->{offsets}};
 
-   $self->redraw (
-             (new Gtk2::Gdk::Rectangle $area->x - $ox, $area->y - $oy, $area->width, $area->height)
-                ->intersect(new Gtk2::Gdk::Rectangle 0, 0, $s, $s)
-          );
+   $self->redraw ($area);
 
    0;
 }
@@ -178,10 +367,11 @@
 
          # zeroeth the shadow
          if ($mark & (MARK_B | MARK_W)) {
-            $::black_img[0]->composite (
-               $base, $shadow, $shadow, $size, $size, $shadow-0.5, $shadow-0.5,
-               $size / $stone->get_width, $size / $stone->get_height,
-               $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 128
+            # the -0.5's are a mystery to me
+            $::shadow_img->composite (
+               $base, $shadow, $shadow, $size, $size, $shadow - 0.5, $shadow - 0.5,
+               $size / $::shadow_img->get_width, $size / $::shadow_img->get_height,
+               $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 192
             );
          }
 
@@ -193,22 +383,22 @@
             my ($mask, $alpha) = @$_;
             if ($mark & $mask) {
                $stone->composite (
-                  $base, 0, 0, $size, $size, -0.5, -0.5,
+                  $base, 0, 0, $size, $size, 0, 0,
                   $size / $stone->get_width, $size / $stone->get_height,
                   $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, $alpha
                );
             }
          }
 
-         # then the samll stones
+         # then the small stones
          for ([MARK_SMALL_B, $::black_img[$rand % @::black_img]],
               [MARK_SMALL_W, $::white_img[$rand % @::white_img]]) {
             my ($mask, $img) = @$_;
             if ($mark & $mask) {
                $img->composite (
-                  $base, ($size / 4) x2, (int ($size / 2 + 0.5)) x2, ($size / 4 - 0.5) x 2,
+                  $base, (int ($size / 4)) x2, (ceil ($size / 2 + 1)) x2, ($size / 4) x2,
                   $size / $img->get_width / 2, $size / $img->get_height / 2,
-                  $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 192
+                  $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 224
                );
             }
          }
@@ -222,9 +412,9 @@
            my ($mask, $img) = @$_;
            if ($mark & $mask) {
               $img->composite (
-                 $base, 0, 0, $size, $size, -0.5, -0.5,
+                 $base, 0, 0, $size, $size, 0, 0,
                  $size / $img->get_width, $size / $img->get_height,
-                 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 255
+                 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 192
               );
            }
          }
@@ -253,8 +443,9 @@
 
       for (@c) {
          my $w = $_->get_width * $s;
+         # +2 == don't fight the rounding
          $_->composite ($pixbuf,
-               $x, $y, $w+0.999, $height+0.999, $x, $y, $s, $s,
+               $x, $y, $w+2, $height+2, $x, $y, $s, $s,
                $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 255);
 
          $x += $w + $spacing;
@@ -278,18 +469,20 @@
    return $expose_area unless $self->{board};
 
    my ($w, $h) = ($canvas->allocation->values)[2,3];
-   
-   my $s = $w > $h ? $h : $w;
 
-   return unless $s > 128;
+   die "FATAL: board aspect ratio != 1" unless $w == $h;
    
-   $self->{offsets} = [int (($w - $s) / 2), int (($h - $s) / 2), $s];
+   my $s = $w;
 
+   return unless $s >= 200;
+   
    my $size = $self->{size};
 
+   # we leave enough space for the shadows.. I like smaller stones, and we
+   # do no need to do the nifty recursive screen updates that goban2 does
    my $border = int ($s / ($size + 3) * 0.5);
    my $s2     = $s - $border * 2;
-   my $edge   = int ($s2 / ($size + 1) * 0.95) - ($::config->{randomize} ? 3 : 0);
+   my $edge   = int ($s2 / ($size + 1) * 0.96) - ($::config->{randomize} ? 3 : 0);
    my $ofs    = int ($edge / 2);
 
    my @k = map int ($s2 * $_ / ($size+1) + $border + 0.5), 0 .. $size;
@@ -317,13 +510,13 @@
          $pixbuf = scale_pixbuf $::board_img, $s, $s, $::config->{speed} ? INTERP_NEAREST : INTERP_TILES;
       }
 
-      my $linew = int ($s / 25 / $size);
+      my $linew = int ($s / 40 / $size);
 
       # ornamental border... we have time to waste :/
       pixbuf_rect $pixbuf, 0xffcc7700, 0, 0,           $s-1, $linew, 255;
       pixbuf_rect $pixbuf, 0xffcc7700, 0, 0,           $linew, $s-1, 255;
-      pixbuf_rect $pixbuf,0xffcc7700, $s-$linew-1, 0, $s-1, $s-1,   255;
-      pixbuf_rect $pixbuf,0xffcc7700, 0, $s-$linew-1, $s-1, $s-1,   255;
+      pixbuf_rect $pixbuf, 0xffcc7700, $s-$linew-1, 0, $s-1, $s-1,   255;
+      pixbuf_rect $pixbuf, 0xffcc7700, 0, $s-$linew-1, $s-1, $s-1,   255;
 
       for my $i (1 .. $size) {
          pixbuf_rect $pixbuf, 0x44111100, $k[$i] - $linew, $k[1] - $linew, $k[$i] + $linew, $k[$size] + $linew, 192;
@@ -342,7 +535,38 @@
          $a++ if $a eq "I"; # not correct, instead of AA AB, we should get HH JJ KK...
       }
 
-      unless ($::config->{conserve_memory}) {
+      # hoshi points
+      my $hoshi = sub {
+         my ($x, $y) = @_;
+         my $hs = int ($edge / 4) | 1;
+         $x = $k[$x] - $hs / 2; $y = $k[$y] - $hs / 2;
+
+         # we use the shadow mask... not perfect, but I want to finish this
+         $::shadow_img->composite ($pixbuf,
+               $x, $y, $hs + 1, $hs + 1, $x, $y,
+               $hs / $::shadow_img->get_width, $hs / $::shadow_img->get_height,
+               $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 255);
+      };
+
+      my $h1 = $size < 10 ? 3 : 4; # corner / edge offset
+      $hoshi->($h1, $h1);
+      $hoshi->($size - $h1 + 1, $h1);
+      $hoshi->($h1, $size - $h1 + 1);
+      $hoshi->($size - $h1 + 1, $size - $h1 + 1);
+
+      if ($size % 2) { # on odd boards, also the remaining 5
+         my $h2 = ($size + 1) / 2;
+         if ($size > 10) {
+            $hoshi->($h1, $h2);
+            $hoshi->($size - $h1 + 1, $h2);
+            $hoshi->($h2, $size - $h1 + 1);
+            $hoshi->($h2, $h1);
+         }
+         # the tengen
+         $hoshi->($h2, $h2);
+      }
+
+      unless ($::config->{conserve_memory} > 1) {
          $self->{background} = $pixbuf;
          $pixbuf = $pixbuf->copy;
       }
@@ -398,13 +622,6 @@
                            $k[$x], $k[$y], $ofs * 0.7,
                            $self->{board}{label}[$x-1][$y-1];
             }
-            
-            # old pixmap&mask-way. that was fast ;(
-            #my ($pm, $bm) = $self->create_stack($gc, $mark, $edge, $x * 17 + $y * 11 );
-
-            #$gc->set_clip_mask ($bm);
-            #$gc->set_clip_origin ($dx, $dy);
-            #$pixmap->draw_pixmap ($gc, $pm, 0, 0, $dx, $dy, $edge, $edge);
          }
       }
    }
@@ -421,28 +638,89 @@
 
    if ($area && $self->{pixbuf}) {
       my ($x, $y, $w, $h) = $area->values;
-      my ($ox, $oy, $s) = @{$self->{offsets}};
 
       $self->{canvas}->window->draw_pixbuf ($self->{canvas}->style->white_gc, $self->{pixbuf},
-            $x, $y, $x + $ox, $y + $oy, $w, $h,
+            $x, $y, $x, $y, $w, $h,
             "normal", 0, 0);
       $self->{canvas}->window->draw_rectangle ($self->{canvas}->style->black_gc, 0,
-                         $x + $ox - 1, $y + $oy - 1, $w + 2, $h + 2) if $::DEBUG_EXPOSE;
+                         $x - 1, $y - 1, $w + 2, $h + 2) if $::DEBUG_EXPOSE;
    }
 }
 
+sub update_board {
+   my ($self) = @_;
+   return unless $self->{path};
+
+   my $move = int $self->{moveadj}->get_value;
+
+   my $running = $move == @{$self->{path}};
+
+   $self->{board_label}->set_text ("Move $move");
+
+   $self->{board} = new KGS::Game::Board $self->{size};
+   $self->{board}->interpret_path ([@{$self->{path}}[0 .. $move - 1]]);
+
+   $self->{userpanel}[WHITE]->set_state ($self->{board}{captures}[WHITE],
+                                         $self->{board}{timer}[WHITE],
+                                         $running && $self->{board}{last} == BLACK);
+   $self->{userpanel}[BLACK]->set_state ($self->{board}{captures}[BLACK],
+                                         $self->{board}{timer}[BLACK],
+                                         $running && $self->{board}{last} == WHITE);
+
+   $self->redraw ($self->repaint_board);
+}
+
 sub event_update_tree {
    my ($self) = @_;
 
    $self->{path} = $self->get_path;
-   $self->{moveadj}->value_changed if $self->{moveadj};
+
+   $self->{userpanel}[WHITE]->set_rules ($self->{path}[0]); # should be onload only
+   $self->{userpanel}[BLACK]->set_rules ($self->{path}[0]); # should be onload only
+
+   if ($self->{moveadj}) {
+      my $upper = $self->{moveadj}->upper;
+      my $pos = $self->{moveadj}->get_value;
+
+      $self->{moveadj}->upper (scalar @{$self->{path}});
+      
+      $self->{moveadj}->changed;
+      if ($pos == $upper) {
+         $self->{moveadj}->set_value (scalar @{$self->{path}});
+      } else {
+         $self->{moveadj}->value_changed;
+      }
+   }
+}
+
+sub event_update_comments {
+   my ($self, $node, $comment, $newnode) = @_;
+   $self->SUPER::event_update_comments($node, $comment, $newnode);
+
+   my $text;
+
+   $text .= "\n<header>Move <move>$node->{move}</move>, Node <node>$node->{id}</node></header>"
+      if $newnode;
+
+   for (split /\n/, $comment) {
+      $text .= "\n";
+      if ($_ =~ s/^([0-9a-zA-Z]+ \[[0-9dkp\?\-]+\])://) {
+         $text .= "<user>" . (util::toxml $1) . "</user>:";
+      }
+      $text .= $_;
+   }
+
+   $self->{text}->append_text ($text);
+}
+
+sub event_join {
+   my ($self) = @_;
+   $self->SUPER::event_join;
 }
 
 sub event_part {
    my ($self) = @_;
    $self->SUPER::event_part;
-   delete $appwin::gamelist->{game}{$self->{channel}};
-   $self->destroy;
 }
 
 sub event_move {
@@ -450,5 +728,34 @@
    sound::play 1, $pass ? "pass" : "move";
 }
 
+sub event_update_game {
+   my ($self) = @_;
+   $self->SUPER::event_update_game;
+   warn "GAME UPDATE ".join (":", %$self);
+   warn "SAVED ".$self->is_saved;
+   warn "SCORED ".$self->is_scored;
+   warn "ADJ ".$self->is_adjourned;
+   warn "VALID ".$self->is_valid;
+   warn "MOVES ".$self->moves;
+   warn "TYPE ".$self->type;
+
+   $self->{left}->remove ($_) for $self->{left}->get_children;
+   if ($self->is_valid) {
+      $self->{left}->add ($self->{boardbox});
+      (delete $self->{challenge})->destroy if $self->{challenge};
+   } else {
+      $self->{left}->add ($self->{challenge}->widget);
+   }
+   $self->{left}->show_all;
+}
+
+sub destroy {
+   my ($self) = @_;
+   (delete $self->{userpanel}[WHITE])->destroy if $self->{userpanel}[WHITE];
+   (delete $self->{userpanel}[BLACK])->destroy if $self->{userpanel}[BLACK];
+   $self->SUPER::destroy;
+   delete $appwin::gamelist->{game}{$self->{channel}};
+}
+
 1;