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.26 by pcg, Sun Jun 1 13:09:47 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 $timer - int $timer;
81}
82
83sub set_time {
84 my ($self, $time) = @_;
85
86 $self->{start} = $time->[0];
87 $self->{set}->($time->[1], $time->[2]);
88
89 $self->refresh ($time->[0]);
90}
91
92sub start {
93 my ($self) = @_;
94
95 return if $self->{timeout};
96
97 my $timeout; $timeout = sub {
98 my $next = int ($self->refresh (Time::HiRes::time) * 1000);
99 $self->{timeout} = add Glib::Timeout $next, $timeout;
100 0;
101 };
102
103 $timeout->();
104}
105
106sub stop {
107 my ($self) = @_;
108
109 remove Glib::Source delete $self->{timeout} if $self->{timeout};
110}
111
112sub destroy {
113 my ($self) = @_;
114 $self->stop;
115 $self->SUPER::destroy;
116}
117
118package game::userpanel;
119
120use base gtk::widget;
121
122sub new {
123 my $class = shift;
124 my $self = $class->SUPER::new(@_);
125
126 $self->{widget} = new Gtk2::HBox;
127
128 $self->{widget}->add (my $vbox = new Gtk2::VBox);
129
130 $vbox->add ($self->{name} = new Gtk2::Label $self->{name});
131 $vbox->add ($self->{info} = new Gtk2::Label "");
132 $vbox->add (($self->{clock} = new game::goclock)->widget);
133
134 $self;
135}
136
137sub set_rules {
138 my ($self, $rules) = @_;
139
140 if ($self->{name}->get_text ne $rules->{player}[$self->{colour}]) {
141 $self->{name}->set_text ($rules->{player}[$self->{colour}]);
142
143 # the big picture...
144 appwin::userpic ($rules->{player}[$self->{colour}], sub {
145 $self->{widget}->add (gtk::image_from_data $_[0]) if $_[0];
146 $self->{widget}->show_all;
147 # undef => show sth. funny
148 });
149 }
150
151 $self->{clock}->set_rules (@{$rules->{rules}}{qw(timesys time interval count)});
152}
153
154sub set_state {
155 my ($self, $captures, $timer, $running) = @_;
156
157 $self->{clock}->set_time ($timer);
158 $running ? $self->{clock}->start : $self->{clock}->stop;
159 $self->{info}->set_text ("$captures pris.");
160}
161
1package game; 162package game;
2 163
3use KGS::Constants; 164use KGS::Constants;
4use KGS::Game::Board; 165use KGS::Game::Board;
5 166
6use base KGS::Listener::Game; 167use base KGS::Listener::Game;
7use base KGS::Game; 168use base KGS::Game;
8 169
9use base gtk::widget; 170use base gtk::widget;
171
172use POSIX qw(ceil);
10 173
11sub new { 174sub new {
12 my $self = shift; 175 my $self = shift;
13 $self = $self->SUPER::new(@_); 176 $self = $self->SUPER::new(@_);
14 177
… …
18 my $title = $self->{channel} ? $self->owner->as_string." ".$self->opponent_string : "Game Window"; 181 my $title = $self->{channel} ? $self->owner->as_string." ".$self->opponent_string : "Game Window";
19 $self->{window}->set_title("KGS Game $title"); 182 $self->{window}->set_title("KGS Game $title");
20 gtk::state $self->{window}, "game::window", undef, window_size => [600, 500]; 183 gtk::state $self->{window}, "game::window", undef, window_size => [600, 500];
21 184
22 $self->{window}->signal_connect(delete_event => sub { 185 $self->{window}->signal_connect(delete_event => sub {
23 if ($self->{joined}) {
24 $self->part; 186 $self->part;
25 } else { 187 $self->destroy;
26 $self->event_part;
27 }
28 1; 188 1;
29 }); 189 });
30 190
31 $self->{window}->add($self->{hpane} = new Gtk2::HPaned); 191 $self->{window}->add($self->{hpane} = new Gtk2::HPaned);
32 gtk::state $self->{hpane}, "game::hpane", undef, position => 500; 192 gtk::state $self->{hpane}, "game::hpane", undef, position => 500;
… …
43 $self->{moveadj} = new Gtk2::Adjustment 1, 0, 1, 0.001, 0.05, 0; 203 $self->{moveadj} = new Gtk2::Adjustment 1, 0, 1, 0.001, 0.05, 0;
44 204
45 $vbox->add(my $scale = new Gtk2::HScale $self->{moveadj}); 205 $vbox->add(my $scale = new Gtk2::HScale $self->{moveadj});
46 $scale->set_draw_value (0); 206 $scale->set_draw_value (0);
47 207
48 $self->{moveadj}->signal_connect (value_changed => sub { 208 $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 } 209 }
61 210
62 $vbox->pack_start(($self->{canvas} = new Gtk2::DrawingArea), 1, 1, 0); 211 $vbox->pack_start((my $aspect_frame = new Gtk2::AspectFrame "", 0.5, 0.5, 1, 0), 1, 1, 0);
212 $aspect_frame->set (border_width => 0, shadow_type => 'none', label_xalign => 0.5);
213 $self->{board_label} = $aspect_frame->get_label_widget;
214
215 $aspect_frame->add($self->{canvas} = new Gtk2::DrawingArea);
216 $self->{canvas}->double_buffered (0) if $::config->{conserve_memory};
63 217
64 $self->{canvas}->signal_connect(configure_event => \&configure_event, $self); 218 $self->{canvas}->signal_connect(configure_event => \&configure_event, $self);
65 $self->{canvas}->signal_connect(expose_event => \&expose_event, $self); 219 $self->{canvas}->signal_connect(expose_event => \&expose_event, $self);
220
221 # RIGHT PANE
66 222
67 $self->{hpane}->pack2(($self->{vpane} = new Gtk2::VPaned), 0, 0); 223 $self->{hpane}->pack2(($self->{vpane} = new Gtk2::VPaned), 0, 0);
68 $self->{hpane}->set(position_set => 1); 224 $self->{hpane}->set(position_set => 1);
69 gtk::state $self->{vpane}, "game::vpane", $self->{name}, position => 80; 225 gtk::state $self->{vpane}, "game::vpane", $self->{name}, position => 80;
70 226
71 $self->{vpane}->add(my $sw = new Gtk2::ScrolledWindow); 227 $self->{vpane}->add(my $sw = new Gtk2::ScrolledWindow);
72 $sw->set_policy("automatic", "always"); 228 $sw->set_policy("automatic", "always");
73 229
74 $sw->add(($self->{userlist} = new gtk::userlist)->widget); 230 $sw->add(($self->{userlist} = new userlist)->widget);
75 231
76 $self->{vpane}->add(my $vbox = new Gtk2::VBox); 232 $self->{vpane}->add(my $vbox = new Gtk2::VBox);
233
234 $vbox->pack_start((my $hbox = new Gtk2::HBox 1), 0, 1, 0);
235 $hbox->add (($self->{userpanel}[WHITE] = new game::userpanel colour => WHITE)->widget);
236 $hbox->add (($self->{userpanel}[BLACK] = new game::userpanel colour => BLACK)->widget);
77 237
78 $vbox->pack_start((my $sw = new Gtk2::ScrolledWindow), 1, 1, 0); 238 $vbox->pack_start((my $sw = new Gtk2::ScrolledWindow), 1, 1, 0);
79 $sw->set_policy("never", "always"); 239 $sw->set_policy("never", "always");
80 240
81 $sw->add(($self->{text} = new gtk::text)->widget); 241 $sw->add(($self->{text} = new gtk::text)->widget);
… …
89 249
90 $self; 250 $self;
91} 251}
92 252
93sub event_update_users { 253sub event_update_users {
94 my ($self) = @_; 254 my ($self, $add, $update, $remove) = @_;
95 255
96 $self->{userlist}->update($self->{users}); 256 $self->{userlist}->update ($add, $update, $remove);
97} 257}
98 258
99sub join { 259sub join {
100 my ($self) = @_; 260 my ($self) = @_;
261 return if $self->{joined};
262
101 $self->SUPER::join; 263 $self->SUPER::join;
102 264
103 $self->{window}->show_all; 265 $self->{window}->show_all;
104} 266}
105 267
106sub part { 268sub part {
107 my ($self) = @_; 269 my ($self) = @_;
270
108 $self->SUPER::part; 271 $self->SUPER::part;
109 272 $self->destroy;
110 $self->{window}->hide;
111} 273}
112 274
113sub configure_event { 275sub configure_event {
114 my ($widget, $event, $self) = @_; 276 my ($widget, $event, $self) = @_;
115 delete $self->{stack}; 277 delete $self->{stack};
… …
124 my ($widget, $event, $self) = @_; 286 my ($widget, $event, $self) = @_;
125 287
126 $self->{pixbuf} or return; 288 $self->{pixbuf} or return;
127 289
128 my $area = $event->area; 290 my $area = $event->area;
129 my ($ox, $oy, $s) = @{$self->{offsets}};
130 291
131 $self->redraw ( 292 $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 293
136 0; 294 0;
137} 295}
138 296
139# something Gtk2 fixed 297# something Gtk2 fixed
… …
176 for my $stone ($mark & (MARK_W | MARK_GRAY_W) ? @::white_img : @::black_img) { 334 for my $stone ($mark & (MARK_W | MARK_GRAY_W) ? @::white_img : @::black_img) {
177 my $base = new_pixbuf $size + $shadow, $size + $shadow, 1, 0x00000000; 335 my $base = new_pixbuf $size + $shadow, $size + $shadow, 1, 0x00000000;
178 336
179 # zeroeth the shadow 337 # zeroeth the shadow
180 if ($mark & (MARK_B | MARK_W)) { 338 if ($mark & (MARK_B | MARK_W)) {
181 $::black_img[0]->composite ( 339 $::shadow_img->composite (
182 $base, $shadow, $shadow, $size, $size, $shadow, $shadow, 340 $base, $shadow, $shadow, $size, $size, $shadow - 0.5, $shadow - 0.5,
183 $size / $stone->get_width, $size / $stone->get_height, 341 $size / $stone->get_width, $size / $stone->get_height,
184 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 192 342 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 192
185 ); 343 );
186 } 344 }
187 345
… …
204 for ([MARK_SMALL_B, $::black_img[$rand % @::black_img]], 362 for ([MARK_SMALL_B, $::black_img[$rand % @::black_img]],
205 [MARK_SMALL_W, $::white_img[$rand % @::white_img]]) { 363 [MARK_SMALL_W, $::white_img[$rand % @::white_img]]) {
206 my ($mask, $img) = @$_; 364 my ($mask, $img) = @$_;
207 if ($mark & $mask) { 365 if ($mark & $mask) {
208 $img->composite ( 366 $img->composite (
209 $base, ($size / 4) x2, (int ($size / 2 + 0.5)) x2, ($size / 4) x 2, 367 $base, (ceil ($size / 4)) x2, (ceil ($size / 2)) x2, (ceil ($size / 4)) x2,
210 $size / $img->get_width / 2, $size / $img->get_height / 2, 368 $size / $img->get_width / 2, $size / $img->get_height / 2,
211 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 192 369 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 224
212 ); 370 );
213 } 371 }
214 } 372 }
215 373
216 # and lastly any markers 374 # and lastly any markers
… …
251 $x -= ($W * $s + $spacing * (@c - 1)) * 0.5; 409 $x -= ($W * $s + $spacing * (@c - 1)) * 0.5;
252 $y -= $height * 0.5; 410 $y -= $height * 0.5;
253 411
254 for (@c) { 412 for (@c) {
255 my $w = $_->get_width * $s; 413 my $w = $_->get_width * $s;
414 # +2 == don't fight the rounding
256 $_->composite ($pixbuf, 415 $_->composite ($pixbuf,
257 $x, $y, $w+1, $height+1, $x, $y, $s, $s, 416 $x, $y, $w+2, $height+2, $x, $y, $s, $s,
258 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 255); 417 $::config->{speed} ? INTERP_NEAREST : INTERP_BILINEAR, 255);
259 418
260 $x += $w + $spacing; 419 $x += $w + $spacing;
261 } 420 }
262 } 421 }
… …
276 my $expose_area = undef; 435 my $expose_area = undef;
277 436
278 return $expose_area unless $self->{board}; 437 return $expose_area unless $self->{board};
279 438
280 my ($w, $h) = ($canvas->allocation->values)[2,3]; 439 my ($w, $h) = ($canvas->allocation->values)[2,3];
440
441 die "FATAL: board aspect ratio != 1" unless $w == $h;
281 442
282 my $s = $w > $h ? $h : $w; 443 my $s = $w;
283 444
284 return unless $s > 128; 445 return unless $s >= 200;
285 446
286 $self->{offsets} = [int (($w - $s) / 2), int (($h - $s) / 2), $s];
287
288 my $size = $self->{size}; 447 my $size = $self->{size};
289 448
449 # we leave enough space for the shadows.. I like smaller stones, and we
450 # do no need to do the nifty recursive screen updates that goban2 does
290 my $border = int ($s / ($size + 3) * 0.5); 451 my $border = int ($s / ($size + 3) * 0.5);
291 my $s2 = $s - $border * 2; 452 my $s2 = $s - $border * 2;
292 my $edge = int ($s2 / ($size + 1) * 0.96) - ($::config->{randomize} ? 3 : 0); 453 my $edge = int ($s2 / ($size + 1) * 0.96) - ($::config->{randomize} ? 3 : 0);
293 my $ofs = int ($edge / 2); 454 my $ofs = int ($edge / 2);
294 455
… …
340 501
341 $a++; 502 $a++;
342 $a++ if $a eq "I"; # not correct, instead of AA AB, we should get HH JJ KK... 503 $a++ if $a eq "I"; # not correct, instead of AA AB, we should get HH JJ KK...
343 } 504 }
344 505
345 unless ($::config->{conserve_memory}) { 506 unless ($::config->{conserve_memory} > 1) {
346 $self->{background} = $pixbuf; 507 $self->{background} = $pixbuf;
347 $pixbuf = $pixbuf->copy; 508 $pixbuf = $pixbuf->copy;
348 } 509 }
349 } 510 }
350 511
… …
419sub redraw { 580sub redraw {
420 my ($self, $area) = @_; 581 my ($self, $area) = @_;
421 582
422 if ($area && $self->{pixbuf}) { 583 if ($area && $self->{pixbuf}) {
423 my ($x, $y, $w, $h) = $area->values; 584 my ($x, $y, $w, $h) = $area->values;
424 my ($ox, $oy, $s) = @{$self->{offsets}};
425 585
426 $self->{canvas}->window->draw_pixbuf ($self->{canvas}->style->white_gc, $self->{pixbuf}, 586 $self->{canvas}->window->draw_pixbuf ($self->{canvas}->style->white_gc, $self->{pixbuf},
427 $x, $y, $x + $ox, $y + $oy, $w, $h, 587 $x, $y, $x, $y, $w, $h,
428 "normal", 0, 0); 588 "normal", 0, 0);
429 $self->{canvas}->window->draw_rectangle ($self->{canvas}->style->black_gc, 0, 589 $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; 590 $x - 1, $y - 1, $w + 2, $h + 2) if $::DEBUG_EXPOSE;
431 } 591 }
592}
593
594sub update_board {
595 my ($self) = @_;
596 return unless $self->{path};
597
598 $self->{NOW} = Time::HiRes::time; #d# get from msg(!)
599
600 my $move = int (@{$self->{path}} * $self->{moveadj}->get_value);
601
602 my $running = $move == @{$self->{path}};
603
604 $self->{board_label}->set_text ("Move $move");
605
606 $self->{board} = new KGS::Game::Board $self->{size};
607 $self->{board}->interpret_path ([@{$self->{path}}[0 .. $move - 1]]);
608
609 $self->{userpanel}[WHITE]->set_state ($self->{board}{captures}[WHITE],
610 $self->{board}{timer}[WHITE],
611 $running && $self->{board}{last} == BLACK);
612 $self->{userpanel}[BLACK]->set_state ($self->{board}{captures}[BLACK],
613 $self->{board}{timer}[BLACK],
614 $running && $self->{board}{last} == WHITE);
615
616 $self->redraw ($self->repaint_board);
617
618 $self->{text}->set_text ($self->{board}{comment});
432} 619}
433 620
434sub event_update_tree { 621sub event_update_tree {
435 my ($self) = @_; 622 my ($self) = @_;
436 623
437 $self->{path} = $self->get_path; 624 $self->{path} = $self->get_path;
625 $self->{userpanel}[WHITE]->set_rules ($self->{path}[0]); # should be onload only
626 $self->{userpanel}[BLACK]->set_rules ($self->{path}[0]); # should be onload only
627
438 $self->{moveadj}->value_changed if $self->{moveadj}; 628 $self->{moveadj}->value_changed if $self->{moveadj};
439} 629}
440 630
441sub event_part { 631sub event_part {
442 my ($self) = @_; 632 my ($self) = @_;
443 $self->SUPER::event_part; 633 $self->SUPER::event_part;
444 delete $appwin::gamelist->{game}{$self->{channel}};
445 $self->destroy;
446} 634}
447 635
448sub event_move { 636sub event_move {
449 my ($self, $pass) = @_; 637 my ($self, $pass) = @_;
450 sound::play 1, $pass ? "pass" : "move"; 638 sound::play 1, $pass ? "pass" : "move";
451} 639}
452 640
641sub event_update_game {
642 my ($self) = @_;
643 $self->SUPER::event_update_game;
644 warn "UPDATE GAME";#d#
645}
646
647sub destroy {
648 my ($self) = @_;
649 (delete $self->{userpanel}[WHITE])->destroy if $self->{userpanel}[WHITE];
650 (delete $self->{userpanel}[BLACK])->destroy if $self->{userpanel}[BLACK];
651 $self->SUPER::destroy;
652 delete $appwin::gamelist->{game}{$self->{channel}};
653}
654
4531; 6551;
454 656

Diff Legend

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