ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/kgsueme/kgsueme/game.pl
(Generate patch)

Comparing kgsueme/kgsueme/game.pl (file contents):
Revision 1.12 by pcg, Sat May 31 17:27:59 2003 UTC vs.
Revision 1.23 by pcg, Sun Jun 1 10:10:21 2003 UTC

1package game::goclock;
2
3use Time::HiRes ();
4
5use KGS::Constants;
6
7use base gtk::widget;
8
9sub new {
10 my $class = shift;
11 my $self = $class->SUPER::new(@_);
12
13 $self->{widget} = new Gtk2::Label;
14
15 $self->{set} = sub { };
16 $self->{format} = sub { "ERROR" };
17
18 $self;
19}
20
21sub append_text {
22 my ($self, $text) = @_;
23
24 $self->{buffer}->insert ($self->{buffer}->get_end_iter, $text);
25}
26
27sub format_time {
28 my ($time) = @_;
29
30 $time > 60*60
31 ? sprintf "%d:%02d:%02d", $time / (60 * 60), $time / 60 % 60, $time % 60
32 : sprintf "%d:%02d", $time / 60 % 60, $time % 60;
33}
34
35sub set_rules {
36 my ($self, $timesys, $main, $interval, $count) = @_;
37
38 if ($timesys == TIMESYS_ABSOLUTE) {
39 $self->{set} = sub { $self->{time} = $_[0] };
40 $self->{format} = sub { format_time $_[0] };
41
42 } elsif ($timesys == TIMESYS_BYO_YOMI) {
43 my $low = $interval * $count;
44
45 $self->{set} = sub { $self->{time} = $_[0] };
46
47 $self->{format} = sub {
48 if ($_[0] > $low) {
49 format_time $_[0];
50 } else {
51 sprintf "%s (%d)", (format_time int ($_[0] % $interval) || $interval), $_[0] / $interval;
52 }
53 };
54
55 } elsif ($timesys == TIMESYS_CANADIAN) {
56 my $low = $interval;
57
58 $self->{set} = sub { $self->{time} = $_[0]; $self->{moves} = $_[1] };
59
60 $self->{format} = sub {
61 if ($_[0] > $low) {
62 format_time $_[0];
63 } else {
64 sprintf "%s / %d", (format_time int($_[0] % $interval) || $interval), $self->{moves};
65 }
66 };
67
68 } else {
69 # none, or unknown
70 $self->{set} = sub { };
71 $self->{format} = sub { "---" }
72 }
73}
74
75sub refresh {
76 my ($self, $timestamp) = @_;
77 my $timer = $self->{time} + $self->{start} - $timestamp;
78 $self->{widget}->set_text ($self->{format}->($timer));
79
80 warn "Timer $timer\n";
81 $timer - int $timer;
82}
83
84sub set_time {
85 my ($self, $time) = @_;
86
87 $self->{start} = $time->[0];
88 $self->{set}->($time->[1], $time->[2]);
89
90 $self->refresh ($time->[0]);
91}
92
93sub start {
94 my ($self) = @_;
95
96 return if $self->{timeout};
97
98 my $timeout; $timeout = sub {
99 my $next = int ($self->refresh (Time::HiRes::time) * 1000);
100 warn "next $next\n";
101 $self->{timeout} = add Glib::Timeout $next, $timeout;
102 0;
103 };
104
105 $timeout->();
106}
107
108sub stop {
109 my ($self) = @_;
110
111 remove Glib::Source delete $self->{timeout} if $self->{timeout};
112}
113
114package game::userpanel;
115
116use base gtk::widget;
117
118sub new {
119 my $class = shift;
120 my $self = $class->SUPER::new(@_);
121
122 $self->{widget} = new Gtk2::VBox;
123
124 $self->{widget}->add ($self->{name} = new Gtk2::Label $self->{name});
125 $self->{widget}->add ($self->{info} = new Gtk2::Label "");
126 $self->{widget}->add (($self->{clock} = new game::goclock)->widget);
127
128 $self;
129}
130
131sub set_rules {
132 my ($self, $rules) = @_;
133
134 $self->{name}->set_text ($rules->{player}[$self->{colour}]);
135 $self->{clock}->set_rules (@{$rules->{rules}}{qw(timesys time interval count)});
136}
137
138sub set_state {
139 my ($self, $captures, $timer, $running) = @_;
140
141 $self->{clock}->set_time ($timer);
142 $running ? $self->{clock}->start : $self->{clock}->stop;
143 $self->{info}->set_text ("$captures pris.");
144}
145
1package game; 146package game;
2 147
3use KGS::Constants; 148use KGS::Constants;
4use KGS::Game::Board; 149use KGS::Game::Board;
5 150
6use base KGS::Listener::Game; 151use base KGS::Listener::Game;
7use base KGS::Game; 152use base KGS::Game;
8 153
9use base gtk::widget; 154use base gtk::widget;
155
156use POSIX qw(ceil);
10 157
11sub new { 158sub new {
12 my $self = shift; 159 my $self = shift;
13 $self = $self->SUPER::new(@_); 160 $self = $self->SUPER::new(@_);
14 161
… …
18 my $title = $self->{channel} ? $self->owner->as_string." ".$self->opponent_string : "Game Window"; 165 my $title = $self->{channel} ? $self->owner->as_string." ".$self->opponent_string : "Game Window";
19 $self->{window}->set_title("KGS Game $title"); 166 $self->{window}->set_title("KGS Game $title");
20 gtk::state $self->{window}, "game::window", undef, window_size => [600, 500]; 167 gtk::state $self->{window}, "game::window", undef, window_size => [600, 500];
21 168
22 $self->{window}->signal_connect(delete_event => sub { 169 $self->{window}->signal_connect(delete_event => sub {
23 if ($self->{joined}) {
24 $self->part; 170 $self->part;
25 } else {
26 $self->event_part;
27 }
28 1; 171 1;
29 }); 172 });
30 173
31 $self->{window}->add($self->{hpane} = new Gtk2::HPaned); 174 $self->{window}->add($self->{hpane} = new Gtk2::HPaned);
32 gtk::state $self->{hpane}, "game::hpane", undef, position => 500; 175 gtk::state $self->{hpane}, "game::hpane", undef, position => 500;
… …
43 $self->{moveadj} = new Gtk2::Adjustment 1, 0, 1, 0.001, 0.05, 0; 186 $self->{moveadj} = new Gtk2::Adjustment 1, 0, 1, 0.001, 0.05, 0;
44 187
45 $vbox->add(my $scale = new Gtk2::HScale $self->{moveadj}); 188 $vbox->add(my $scale = new Gtk2::HScale $self->{moveadj});
46 $scale->set_draw_value (0); 189 $scale->set_draw_value (0);
47 190
48 $self->{moveadj}->signal_connect (value_changed => sub { 191 $self->{moveadj}->signal_connect (value_changed => sub { $self->update_board });
49 return unless $self->{path};
50
51 my $move = int (@{$self->{path}} * $_[0]->get_value);
52
53 $self->{board} = new KGS::Game::Board $self->{size};
54 $self->{board}->interpret_path ([@{$self->{path}}[0 .. $move - 1]]);
55
56 $self->redraw ($self->repaint_board);
57
58 $self->{text}->set_text(KGS::Listener::Debug::dumpval([$self->{board}{time},$self->{board}{captures}]). $self->{board}{comment});
59 });
60 } 192 }
61 193
62 $vbox->pack_start(($self->{canvas} = new Gtk2::DrawingArea), 1, 1, 0); 194 $vbox->pack_start((my $aspect_frame = new Gtk2::AspectFrame "", 0.5, 0.5, 1, 0), 1, 1, 0);
195 $aspect_frame->set (border_width => 0, shadow_type => 'none', label_xalign => 0.5);
196 $self->{board_label} = $aspect_frame->get_label_widget;
197
198 $aspect_frame->add($self->{canvas} = new Gtk2::DrawingArea);
199 $self->{canvas}->double_buffered (0) if $::config->{conserve_memory};
63 200
64 $self->{canvas}->signal_connect(configure_event => \&configure_event, $self); 201 $self->{canvas}->signal_connect(configure_event => \&configure_event, $self);
65 $self->{canvas}->signal_connect(expose_event => \&expose_event, $self); 202 $self->{canvas}->signal_connect(expose_event => \&expose_event, $self);
203
204 # RIGHT PANE
66 205
67 $self->{hpane}->pack2(($self->{vpane} = new Gtk2::VPaned), 0, 0); 206 $self->{hpane}->pack2(($self->{vpane} = new Gtk2::VPaned), 0, 0);
68 $self->{hpane}->set(position_set => 1); 207 $self->{hpane}->set(position_set => 1);
69 gtk::state $self->{vpane}, "game::vpane", $self->{name}, position => 80; 208 gtk::state $self->{vpane}, "game::vpane", $self->{name}, position => 80;
70 209
71 $self->{vpane}->add(my $sw = new Gtk2::ScrolledWindow); 210 $self->{vpane}->add(my $sw = new Gtk2::ScrolledWindow);
72 $sw->set_policy("automatic", "always"); 211 $sw->set_policy("automatic", "always");
73 212
74 $sw->add(($self->{userlist} = new gtk::userlist)->widget); 213 $sw->add(($self->{userlist} = new userlist)->widget);
75 214
76 $self->{vpane}->add(my $vbox = new Gtk2::VBox); 215 $self->{vpane}->add(my $vbox = new Gtk2::VBox);
216
217 $vbox->pack_start((my $hbox = new Gtk2::HBox 1), 0, 1, 0);
218 $hbox->add (($self->{user0} = new game::userpanel colour => WHITE)->widget);
219 $hbox->add (($self->{user1} = new game::userpanel colour => BLACK)->widget);
77 220
78 $vbox->pack_start((my $sw = new Gtk2::ScrolledWindow), 1, 1, 0); 221 $vbox->pack_start((my $sw = new Gtk2::ScrolledWindow), 1, 1, 0);
79 $sw->set_policy("never", "always"); 222 $sw->set_policy("never", "always");
80 223
81 $sw->add(($self->{text} = new gtk::text)->widget); 224 $sw->add(($self->{text} = new gtk::text)->widget);
… …
89 232
90 $self; 233 $self;
91} 234}
92 235
93sub event_update_users { 236sub event_update_users {
94 my ($self) = @_; 237 my ($self, $add, $update, $remove) = @_;
95 238
96 $self->{userlist}->update($self->{users}); 239 $self->{userlist}->update ($add, $update, $remove);
97} 240}
98 241
99sub join { 242sub join {
100 my ($self) = @_; 243 my ($self) = @_;
244 return if $self->{joined};
245
101 $self->SUPER::join; 246 $self->SUPER::join;
102 247
103 $self->{window}->show_all; 248 $self->{window}->show_all;
104} 249}
105 250
106sub part { 251sub part {
107 my ($self) = @_; 252 my ($self) = @_;
253
108 $self->SUPER::part; 254 $self->SUPER::part;
109 255 $self->destroy;
110 $self->{window}->hide;
111} 256}
112 257
113sub configure_event { 258sub configure_event {
114 my ($widget, $event, $self) = @_; 259 my ($widget, $event, $self) = @_;
115 delete $self->{stack}; 260 delete $self->{stack};
… …
124 my ($widget, $event, $self) = @_; 269 my ($widget, $event, $self) = @_;
125 270
126 $self->{pixbuf} or return; 271 $self->{pixbuf} or return;
127 272
128 my $area = $event->area; 273 my $area = $event->area;
129 my ($ox, $oy, $s) = @{$self->{offsets}};
130 274
131 $self->redraw ( 275 $self->redraw ($area);
132 (new Gtk2::Gdk::Rectangle $area->x - $ox, $area->y - $oy, $area->width, $area->height)
133 ->intersect(new Gtk2::Gdk::Rectangle 0, 0, $s, $s)
134 );
135 276
136 0; 277 0;
137} 278}
138 279
139# something Gtk2 fixed 280# something Gtk2 fixed
… …
176 for my $stone ($mark & (MARK_W | MARK_GRAY_W) ? @::white_img : @::black_img) { 317 for my $stone ($mark & (MARK_W | MARK_GRAY_W) ? @::white_img : @::black_img) {
177 my $base = new_pixbuf $size + $shadow, $size + $shadow, 1, 0x00000000; 318 my $base = new_pixbuf $size + $shadow, $size + $shadow, 1, 0x00000000;
178 319
179 # zeroeth the shadow 320 # zeroeth the shadow
180 if ($mark & (MARK_B | MARK_W)) { 321 if ($mark & (MARK_B | MARK_W)) {
181 $::black_img[0]->composite ( 322 $::shadow_img->composite (
182 $base, $shadow, $shadow, $size, $size, $shadow, $shadow, 323 $base, $shadow, $shadow, $size, $size, $shadow - 0.5, $shadow - 0.5,
183 $size / $stone->get_width, $size / $stone->get_height, 324 $size / $stone->get_width, $size / $stone->get_height,
184 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 192 325 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 192
185 ); 326 );
186 } 327 }
187 328
… …
204 for ([MARK_SMALL_B, $::black_img[$rand % @::black_img]], 345 for ([MARK_SMALL_B, $::black_img[$rand % @::black_img]],
205 [MARK_SMALL_W, $::white_img[$rand % @::white_img]]) { 346 [MARK_SMALL_W, $::white_img[$rand % @::white_img]]) {
206 my ($mask, $img) = @$_; 347 my ($mask, $img) = @$_;
207 if ($mark & $mask) { 348 if ($mark & $mask) {
208 $img->composite ( 349 $img->composite (
209 $base, ($size / 4) x2, (int ($size / 2 + 0.5)) x2, ($size / 4) x 2, 350 $base, (ceil ($size / 4)) x2, (ceil ($size / 2)) x2, (ceil ($size / 4)) x2,
210 $size / $img->get_width / 2, $size / $img->get_height / 2, 351 $size / $img->get_width / 2, $size / $img->get_height / 2,
211 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 192 352 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 224
212 ); 353 );
213 } 354 }
214 } 355 }
215 356
216 # and lastly any markers 357 # and lastly any markers
… …
251 $x -= ($W * $s + $spacing * (@c - 1)) * 0.5; 392 $x -= ($W * $s + $spacing * (@c - 1)) * 0.5;
252 $y -= $height * 0.5; 393 $y -= $height * 0.5;
253 394
254 for (@c) { 395 for (@c) {
255 my $w = $_->get_width * $s; 396 my $w = $_->get_width * $s;
397 # +2 == don't fight the rounding
256 $_->composite ($pixbuf, 398 $_->composite ($pixbuf,
257 $x, $y, $w+1, $height+1, $x, $y, $s, $s, 399 $x, $y, $w+2, $height+2, $x, $y, $s, $s,
258 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 255); 400 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 255);
259 401
260 $x += $w + $spacing; 402 $x += $w + $spacing;
261 } 403 }
262 } 404 }
… …
276 my $expose_area = undef; 418 my $expose_area = undef;
277 419
278 return $expose_area unless $self->{board}; 420 return $expose_area unless $self->{board};
279 421
280 my ($w, $h) = ($canvas->allocation->values)[2,3]; 422 my ($w, $h) = ($canvas->allocation->values)[2,3];
423
424 die "FATAL: board aspect ratio != 1" unless $w == $h;
281 425
282 my $s = $w > $h ? $h : $w; 426 my $s = $w;
283 427
284 return unless $s > 128; 428 return unless $s >= 200;
285 429
286 $self->{offsets} = [int (($w - $s) / 2), int (($h - $s) / 2), $s];
287
288 my $size = $self->{size}; 430 my $size = $self->{size};
289 431
432 # we leave enough space for the shadows.. I like smaller stones, and we
433 # do no need to do the nifty recursive screen updates that goban2 does
290 my $border = int ($s / ($size + 3) * 0.5); 434 my $border = int ($s / ($size + 3) * 0.5);
291 my $s2 = $s - $border * 2; 435 my $s2 = $s - $border * 2;
292 my $edge = int ($s2 / ($size + 1) * 0.96) - ($::config->{randomize} ? 3 : 0); 436 my $edge = int ($s2 / ($size + 1) * 0.96) - ($::config->{randomize} ? 3 : 0);
293 my $ofs = int ($edge / 2); 437 my $ofs = int ($edge / 2);
294 438
… …
340 484
341 $a++; 485 $a++;
342 $a++ if $a eq "I"; # not correct, instead of AA AB, we should get HH JJ KK... 486 $a++ if $a eq "I"; # not correct, instead of AA AB, we should get HH JJ KK...
343 } 487 }
344 488
345 unless ($::config->{conserve_memory}) { 489 unless ($::config->{conserve_memory} > 1) {
346 $self->{background} = $pixbuf; 490 $self->{background} = $pixbuf;
347 $pixbuf = $pixbuf->copy; 491 $pixbuf = $pixbuf->copy;
348 } 492 }
349 } 493 }
350 494
… …
419sub redraw { 563sub redraw {
420 my ($self, $area) = @_; 564 my ($self, $area) = @_;
421 565
422 if ($area && $self->{pixbuf}) { 566 if ($area && $self->{pixbuf}) {
423 my ($x, $y, $w, $h) = $area->values; 567 my ($x, $y, $w, $h) = $area->values;
424 my ($ox, $oy, $s) = @{$self->{offsets}};
425 568
426 $self->{canvas}->window->draw_pixbuf ($self->{canvas}->style->white_gc, $self->{pixbuf}, 569 $self->{canvas}->window->draw_pixbuf ($self->{canvas}->style->white_gc, $self->{pixbuf},
427 $x, $y, $x + $ox, $y + $oy, $w, $h, 570 $x, $y, $x, $y, $w, $h,
428 "normal", 0, 0); 571 "normal", 0, 0);
429 $self->{canvas}->window->draw_rectangle ($self->{canvas}->style->black_gc, 0, 572 $self->{canvas}->window->draw_rectangle ($self->{canvas}->style->black_gc, 0,
430 $x + $ox - 1, $y + $oy - 1, $w + 2, $h + 2) if $::DEBUG_EXPOSE; 573 $x - 1, $y - 1, $w + 2, $h + 2) if $::DEBUG_EXPOSE;
431 } 574 }
432} 575}
433 576
577sub update_board {
578 my ($self) = @_;
579 return unless $self->{path};
580
581 $self->{NOW} = Time::HiRes::time; #d# get from msg(!)
582
583 my $move = int (@{$self->{path}} * $self->{moveadj}->get_value);
584
585 my $running = $move == @{$self->{path}};
586
587 $self->{board_label}->set_text ("Move $move");
588
589 $self->{board} = new KGS::Game::Board $self->{size};
590 $self->{board}->interpret_path ([@{$self->{path}}[0 .. $move - 1]]);
591
592 $self->{user0}->set_state ($self->{board}{captures}[0],
593 $self->{board}{timer}[0],
594 $running && $self->{board}{last} == WHITE);
595 $self->{user1}->set_state ($self->{board}{captures}[1],
596 $self->{board}{timer}[1],
597 $running && $self->{board}{last} == BLACK);
598
599 $self->redraw ($self->repaint_board);
600
601 $self->{text}->set_text(KGS::Listener::Debug::dumpval([$self->{board}{time},$self->{board}{captures}]). $self->{board}{comment});
602}
603
434sub event_update_tree { 604sub event_update_tree {
435 my ($self) = @_; 605 my ($self) = @_;
436 606
437 $self->{path} = $self->get_path; 607 $self->{path} = $self->get_path;
608 $self->{user0}->set_rules ($self->{path}[0]);
609 $self->{user1}->set_rules ($self->{path}[0]);
610
438 $self->{moveadj}->value_changed if $self->{moveadj}; 611 $self->{moveadj}->value_changed if $self->{moveadj};
439} 612}
440 613
441sub event_part { 614sub event_part {
442 my ($self) = @_; 615 my ($self) = @_;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines