13 #include "patternsp.h"
22 bool random_pass
= false;
26 #define profiling_noinline __attribute__((noinline))
28 #define profiling_noinline
31 #define gi_granularity 4
32 #define gi_allocsize(gids) ((1 << gi_granularity) + ((gids) >> gi_granularity) * (1 << gi_granularity))
36 board_setup(struct board
*b
)
38 memset(b
, 0, sizeof(*b
));
40 struct move m
= { pass
, S_NONE
};
41 b
->last_move
= b
->last_move2
= b
->last_ko
= b
->ko
= m
;
47 struct board
*b
= malloc(sizeof(struct board
));
58 board_copy(struct board
*b2
, struct board
*b1
)
60 memcpy(b2
, b1
, sizeof(struct board
));
62 int bsize
= board_size2(b2
) * sizeof(*b2
->b
);
63 int gsize
= board_size2(b2
) * sizeof(*b2
->g
);
64 int fsize
= board_size2(b2
) * sizeof(*b2
->f
);
65 int nsize
= board_size2(b2
) * sizeof(*b2
->n
);
66 int psize
= board_size2(b2
) * sizeof(*b2
->p
);
67 int hsize
= board_size2(b2
) * 2 * sizeof(*b2
->h
);
68 int gisize
= board_size2(b2
) * sizeof(*b2
->gi
);
70 int csize
= board_size2(b2
) * sizeof(*b2
->c
);
75 int ssize
= board_size2(b2
) * sizeof(*b2
->spathash
);
80 int p3size
= board_size2(b2
) * sizeof(*b2
->pat3
);
85 int tsize
= board_size2(b2
) * sizeof(*b2
->t
);
90 int pbsize
= board_size2(b2
) * sizeof(*b2
->prob
[0].items
);
94 void *x
= malloc(bsize
+ gsize
+ fsize
+ psize
+ nsize
+ hsize
+ gisize
+ csize
+ ssize
+ p3size
+ tsize
+ pbsize
* 2);
95 memcpy(x
, b1
->b
, bsize
+ gsize
+ fsize
+ psize
+ nsize
+ hsize
+ gisize
+ csize
+ ssize
+ p3size
+ tsize
+ pbsize
* 2);
96 b2
->b
= x
; x
+= bsize
;
97 b2
->g
= x
; x
+= gsize
;
98 b2
->f
= x
; x
+= fsize
;
99 b2
->p
= x
; x
+= psize
;
100 b2
->n
= x
; x
+= nsize
;
101 b2
->h
= x
; x
+= hsize
;
102 b2
->gi
= x
; x
+= gisize
;
104 b2
->c
= x
; x
+= csize
;
106 #ifdef BOARD_SPATHASH
107 b2
->spathash
= x
; x
+= ssize
;
110 b2
->pat3
= x
; x
+= p3size
;
113 b2
->t
= x
; x
+= tsize
;
116 b2
->prob
[0].items
= x
; x
+= pbsize
;
117 b2
->prob
[1].items
= x
; x
+= pbsize
;
124 board_done_noalloc(struct board
*board
)
126 if (board
->b
) free(board
->b
);
130 board_done(struct board
*board
)
132 board_done_noalloc(board
);
137 board_resize(struct board
*board
, int size
)
140 assert(board_size(board
) == size
+ 2);
142 board_size(board
) = size
+ 2 /* S_OFFBOARD margin */;
143 board_size2(board
) = board_size(board
) * board_size(board
);
148 int bsize
= board_size2(board
) * sizeof(*board
->b
);
149 int gsize
= board_size2(board
) * sizeof(*board
->g
);
150 int fsize
= board_size2(board
) * sizeof(*board
->f
);
151 int nsize
= board_size2(board
) * sizeof(*board
->n
);
152 int psize
= board_size2(board
) * sizeof(*board
->p
);
153 int hsize
= board_size2(board
) * 2 * sizeof(*board
->h
);
154 int gisize
= board_size2(board
) * sizeof(*board
->gi
);
156 int csize
= board_size2(board
) * sizeof(*board
->c
);
160 #ifdef BOARD_SPATHASH
161 int ssize
= board_size2(board
) * sizeof(*board
->spathash
);
166 int p3size
= board_size2(board
) * sizeof(*board
->pat3
);
171 int tsize
= board_size2(board
) * sizeof(*board
->t
);
176 int pbsize
= board_size2(board
) * sizeof(*board
->prob
[0].items
);
180 void *x
= malloc(bsize
+ gsize
+ fsize
+ psize
+ nsize
+ hsize
+ gisize
+ csize
+ ssize
+ p3size
+ tsize
+ pbsize
* 2);
181 memset(x
, 0, bsize
+ gsize
+ fsize
+ psize
+ nsize
+ hsize
+ gisize
+ csize
+ ssize
+ p3size
+ tsize
+ pbsize
* 2);
182 board
->b
= x
; x
+= bsize
;
183 board
->g
= x
; x
+= gsize
;
184 board
->f
= x
; x
+= fsize
;
185 board
->p
= x
; x
+= psize
;
186 board
->n
= x
; x
+= nsize
;
187 board
->h
= x
; x
+= hsize
;
188 board
->gi
= x
; x
+= gisize
;
190 board
->c
= x
; x
+= csize
;
192 #ifdef BOARD_SPATHASH
193 board
->spathash
= x
; x
+= ssize
;
196 board
->pat3
= x
; x
+= p3size
;
199 board
->t
= x
; x
+= tsize
;
202 board
->prob
[0].items
= x
; x
+= pbsize
;
203 board
->prob
[1].items
= x
; x
+= pbsize
;
208 board_clear(struct board
*board
)
210 int size
= board_size(board
);
211 float komi
= board
->komi
;
213 board_done_noalloc(board
);
215 board_resize(board
, size
- 2 /* S_OFFBOARD margin */);
219 /* Setup neighborhood iterators */
220 board
->nei8
[0] = -size
- 1; // (-1,-1)
223 board
->nei8
[3] = size
- 2; // (-1,0)
225 board
->nei8
[5] = size
- 2; // (-1,1)
228 board
->dnei
[0] = -size
- 1;
230 board
->dnei
[2] = size
*2 - 2;
233 /* Setup initial symmetry */
234 board
->symmetry
.d
= 1;
235 board
->symmetry
.x1
= board
->symmetry
.y1
= board_size(board
) / 2;
236 board
->symmetry
.x2
= board
->symmetry
.y2
= board_size(board
) - 1;
237 board
->symmetry
.type
= SYM_FULL
;
239 /* Draw the offboard margin */
240 int top_row
= board_size2(board
) - board_size(board
);
242 for (i
= 0; i
< board_size(board
); i
++)
243 board
->b
[i
] = board
->b
[top_row
+ i
] = S_OFFBOARD
;
244 for (i
= 0; i
<= top_row
; i
+= board_size(board
))
245 board
->b
[i
] = board
->b
[board_size(board
) - 1 + i
] = S_OFFBOARD
;
247 foreach_point(board
) {
249 if (board_at(board
, coord
) == S_OFFBOARD
)
251 foreach_neighbor(board
, c
, {
252 inc_neighbor_count_at(board
, coord
, board_at(board
, c
));
256 /* First, pass is always a free position. */
257 board
->f
[board
->flen
++] = coord_raw(pass
);
258 /* All positions are free! Except the margin. */
259 for (i
= board_size(board
); i
< (board_size(board
) - 1) * board_size(board
); i
++)
260 if (i
% board_size(board
) != 0 && i
% board_size(board
) != board_size(board
) - 1)
261 board
->f
[board
->flen
++] = i
;
263 /* Initialize zobrist hashtable. */
264 foreach_point(board
) {
265 int max
= (sizeof(hash_t
) << history_hash_bits
);
266 /* fast_random() is 16-bit only */
267 board
->h
[coord_raw(c
) * 2] = ((hash_t
) fast_random(max
))
268 | ((hash_t
) fast_random(max
) << 16)
269 | ((hash_t
) fast_random(max
) << 32)
270 | ((hash_t
) fast_random(max
) << 48);
271 if (!board
->h
[coord_raw(c
) * 2])
272 /* Would be kinda "oops". */
273 board
->h
[coord_raw(c
) * 2] = 1;
274 /* And once again for white */
275 board
->h
[coord_raw(c
) * 2 + 1] = ((hash_t
) fast_random(max
))
276 | ((hash_t
) fast_random(max
) << 16)
277 | ((hash_t
) fast_random(max
) << 32)
278 | ((hash_t
) fast_random(max
) << 48);
279 if (!board
->h
[coord_raw(c
) * 2 + 1])
280 board
->h
[coord_raw(c
) * 2 + 1] = 1;
283 #ifdef BOARD_SPATHASH
284 /* Initialize spatial hashes. */
285 foreach_point(board
) {
286 for (int d
= 1; d
<= BOARD_SPATHASH_MAXD
; d
++) {
287 for (int j
= ptind
[d
]; j
< ptind
[d
+ 1]; j
++) {
288 ptcoords_at(x
, y
, c
, board
, j
);
289 board
->spathash
[coord_xy(board
, x
, y
)][d
- 1][0] ^=
290 pthashes
[0][j
][board_at(board
, c
)];
291 board
->spathash
[coord_xy(board
, x
, y
)][d
- 1][1] ^=
292 pthashes
[0][j
][stone_other(board_at(board
, c
))];
298 /* Initialize 3x3 pattern codes. */
299 foreach_point(board
) {
300 if (board_at(board
, c
) == S_NONE
)
301 board
->pat3
[c
] = pattern3_hash(board
, c
);
305 /* Initialize traits. */
306 foreach_point(board
) {
307 trait_at(board
, c
, S_BLACK
).cap
= 0;
308 trait_at(board
, c
, S_BLACK
).safe
= true;
309 trait_at(board
, c
, S_WHITE
).cap
= 0;
310 trait_at(board
, c
, S_WHITE
).safe
= true;
314 board
->prob
[0].n
= board
->prob
[1].n
= board_size2(board
);
315 foreach_point(board
) {
316 probdist_set(&board
->prob
[0], c
, (board_at(board
, c
) == S_NONE
) * 1.0f
);
317 probdist_set(&board
->prob
[1], c
, (board_at(board
, c
) == S_NONE
) * 1.0f
);
324 board_print_top(struct board
*board
, FILE *f
, int c
)
326 for (int i
= 0; i
< c
; i
++) {
327 char asdf
[] = "ABCDEFGHJKLMNOPQRSTUVWXYZ";
329 for (int x
= 1; x
< board_size(board
) - 1; x
++)
330 fprintf(f
, "%c ", asdf
[x
- 1]);
334 for (int i
= 0; i
< c
; i
++) {
336 for (int x
= 1; x
< board_size(board
) - 1; x
++)
344 board_print_bottom(struct board
*board
, FILE *f
, int c
)
346 for (int i
= 0; i
< c
; i
++) {
348 for (int x
= 1; x
< board_size(board
) - 1; x
++)
356 board_print_row(struct board
*board
, int y
, FILE *f
, board_cprint cprint
)
358 fprintf(f
, " %2d | ", y
);
359 for (int x
= 1; x
< board_size(board
) - 1; x
++) {
360 if (coord_x(board
->last_move
.coord
, board
) == x
&& coord_y(board
->last_move
.coord
, board
) == y
)
361 fprintf(f
, "%c)", stone2char(board_atxy(board
, x
, y
)));
363 fprintf(f
, "%c ", stone2char(board_atxy(board
, x
, y
)));
367 fprintf(f
, " %2d | ", y
);
368 for (int x
= 1; x
< board_size(board
) - 1; x
++) {
369 cprint(board
, coord_xy(board
, x
, y
), f
);
377 board_print_custom(struct board
*board
, FILE *f
, board_cprint cprint
)
379 fprintf(f
, "Move: % 3d Komi: %2.1f Handicap: %d Captures B: %d W: %d\n",
380 board
->moves
, board
->komi
, board
->handicap
,
381 board
->captures
[S_BLACK
], board
->captures
[S_WHITE
]);
382 board_print_top(board
, f
, 1 + !!cprint
);
383 for (int y
= board_size(board
) - 2; y
>= 1; y
--)
384 board_print_row(board
, y
, f
, cprint
);
385 board_print_bottom(board
, f
, 1 + !!cprint
);
390 cprint_group(struct board
*board
, coord_t c
, FILE *f
)
392 fprintf(f
, "%d ", group_base(group_at(board
, c
)));
396 board_print(struct board
*board
, FILE *f
)
398 board_print_custom(board
, f
, DEBUGL(6) ? cprint_group
: NULL
);
402 board_gamma_set(struct board
*b
, struct features_gamma
*gamma
)
406 for (int i
= 0; i
< b
->flen
; i
++) {
407 if (is_pass(b
->f
[i
])) continue;
408 board_gamma_update(b
, b
->f
[i
], S_BLACK
);
409 board_gamma_update(b
, b
->f
[i
], S_WHITE
);
415 /* Update the probability distribution we maintain incrementally. */
417 board_gamma_update(struct board
*board
, coord_t coord
, enum stone color
)
423 /* Punch out invalid moves and moves filling our own eyes. */
424 if (board_at(board
, coord
) != S_NONE
425 || (board_is_eyelike(board
, &coord
, stone_other(color
))
426 && !trait_at(board
, coord
, color
).cap
)
427 || (board_is_one_point_eye(board
, &coord
, color
))) {
428 probdist_set(&board
->prob
[color
- 1], coord
, 0);
432 int pat
= board
->pat3
[coord
];
433 if (color
== S_WHITE
) {
434 /* We work with the pattern3s as black-to-play. */
435 pat
= pattern3_reverse(pat
);
438 /* We just quickly replicate the general pattern matcher stuff
439 * here in the most bare-bone way. */
440 float value
= board
->gamma
->gamma
[FEAT_PATTERN3
][pat
];
441 if (trait_at(board
, coord
, color
).cap
)
442 value
*= board
->gamma
->gamma
[FEAT_CAPTURE
][0];
443 if (trait_at(board
, coord
, stone_other(color
)).cap
444 && trait_at(board
, coord
, color
).safe
)
445 value
*= board
->gamma
->gamma
[FEAT_AESCAPE
][0];
446 if (!trait_at(board
, coord
, color
).safe
)
447 value
*= board
->gamma
->gamma
[FEAT_SELFATARI
][0];
448 probdist_set(&board
->prob
[color
- 1], coord
, value
);
452 /* Recompute some of the traits for given point from scratch. Note that
453 * some traits are updated incrementally elsewhere. */
455 board_trait_recompute(struct board
*board
, coord_t coord
)
458 trait_at(board
, coord
, S_BLACK
).safe
= board_safe_to_play(board
, coord
, S_BLACK
);
459 trait_at(board
, coord
, S_WHITE
).safe
= board_safe_to_play(board
, coord
, S_WHITE
);
461 fprintf(stderr
, "traits[%s:%s lib=%d] (black cap=%d safe=%d) (white cap=%d safe=%d)\n",
462 coord2sstr(coord
, board
), stone2str(board_at(board
, coord
)), immediate_liberty_count(board
, coord
),
463 trait_at(board
, coord
, S_BLACK
).cap
, trait_at(board
, coord
, S_BLACK
).safe
,
464 trait_at(board
, coord
, S_WHITE
).cap
, trait_at(board
, coord
, S_WHITE
).safe
);
467 board_gamma_update(board
, coord
, S_BLACK
);
468 board_gamma_update(board
, coord
, S_WHITE
);
471 /* Update board hash with given coordinate. */
472 static void profiling_noinline
473 board_hash_update(struct board
*board
, coord_t coord
, enum stone color
)
475 board
->hash
^= hash_at(board
, coord
, color
);
477 fprintf(stderr
, "board_hash_update(%d,%d,%d) ^ %"PRIhash
" -> %"PRIhash
"\n", color
, coord_x(coord
, board
), coord_y(coord
, board
), hash_at(board
, coord
, color
), board
->hash
);
479 #ifdef BOARD_SPATHASH
480 /* Gridcular metric is reflective, so we update all hashes
481 * of appropriate ditance in OUR circle. */
482 for (int d
= 1; d
<= BOARD_SPATHASH_MAXD
; d
++) {
483 for (int j
= ptind
[d
]; j
< ptind
[d
+ 1]; j
++) {
484 ptcoords_at(x
, y
, coord
, board
, j
);
485 /* We either changed from S_NONE to color
486 * or vice versa; doesn't matter. */
487 board
->spathash
[coord_xy(board
, x
, y
)][d
- 1][0] ^=
488 pthashes
[0][j
][color
] ^ pthashes
[0][j
][S_NONE
];
489 board
->spathash
[coord_xy(board
, x
, y
)][d
- 1][1] ^=
490 pthashes
[0][j
][stone_other(color
)] ^ pthashes
[0][j
][S_NONE
];
495 #if defined(BOARD_PAT3)
496 /* @color is not what we need in case of capture. */
497 enum stone new_color
= board_at(board
, coord
);
498 if (new_color
== S_NONE
)
499 board
->pat3
[coord
] = pattern3_hash(board
, coord
);
500 foreach_8neighbor(board
, coord
) { // internally, the loop uses fn__i=[0..7]
501 if (board_at(board
, c
) != S_NONE
)
503 board
->pat3
[c
] &= ~(3 << (fn__i
*2));
504 board
->pat3
[c
] |= new_color
<< (fn__i
*2);
506 if (board_at(board
, c
) != S_OFFBOARD
&& pattern3_hash(board
, c
) != board
->pat3
[c
]) {
507 board_print(board
, stderr
);
508 fprintf(stderr
, "%s->%s %x != %x (%d-%d:%d)\n", coord2sstr(coord
, board
), coord2sstr(c
, board
), pattern3_hash(board
, c
), board
->pat3
[c
], coord
, c
, fn__i
);
512 board_gamma_update(board
, c
, S_BLACK
);
513 board_gamma_update(board
, c
, S_WHITE
);
514 } foreach_8neighbor_end
;
518 /* Commit current board hash to history. */
519 static void profiling_noinline
520 board_hash_commit(struct board
*board
)
523 fprintf(stderr
, "board_hash_commit %"PRIhash
"\n", board
->hash
);
524 if (likely(board
->history_hash
[board
->hash
& history_hash_mask
]) == 0) {
525 board
->history_hash
[board
->hash
& history_hash_mask
] = board
->hash
;
527 hash_t i
= board
->hash
;
528 while (board
->history_hash
[i
& history_hash_mask
]) {
529 if (board
->history_hash
[i
& history_hash_mask
] == board
->hash
) {
531 fprintf(stderr
, "SUPERKO VIOLATION noted at %d,%d\n",
532 coord_x(board
->last_move
.coord
, board
), coord_y(board
->last_move
.coord
, board
));
533 board
->superko_violation
= true;
536 i
= history_hash_next(i
);
538 board
->history_hash
[i
& history_hash_mask
] = board
->hash
;
544 board_symmetry_update(struct board
*b
, struct board_symmetry
*symmetry
, coord_t c
)
546 if (likely(symmetry
->type
== SYM_NONE
)) {
547 /* Fully degenerated already. We do not support detection
548 * of restoring of symmetry, assuming that this is too rare
549 * a case to handle. */
553 int x
= coord_x(c
, b
), y
= coord_y(c
, b
), t
= board_size(b
) / 2;
554 int dx
= board_size(b
) - 1 - x
; /* for SYM_DOWN */
556 fprintf(stderr
, "SYMMETRY [%d,%d,%d,%d|%d=%d] update for %d,%d\n",
557 symmetry
->x1
, symmetry
->y1
, symmetry
->x2
, symmetry
->y2
,
558 symmetry
->d
, symmetry
->type
, x
, y
);
561 switch (symmetry
->type
) {
563 if (x
== t
&& y
== t
) {
564 /* Tengen keeps full symmetry. */
567 /* New symmetry now? */
569 symmetry
->type
= SYM_DIAG_UP
;
570 symmetry
->x1
= symmetry
->y1
= 1;
571 symmetry
->x2
= symmetry
->y2
= board_size(b
) - 1;
573 } else if (dx
== y
) {
574 symmetry
->type
= SYM_DIAG_DOWN
;
575 symmetry
->x1
= symmetry
->y1
= 1;
576 symmetry
->x2
= symmetry
->y2
= board_size(b
) - 1;
579 symmetry
->type
= SYM_HORIZ
;
581 symmetry
->y2
= board_size(b
) - 1;
584 symmetry
->type
= SYM_VERT
;
586 symmetry
->x2
= board_size(b
) - 1;
590 symmetry
->type
= SYM_NONE
;
591 symmetry
->x1
= symmetry
->y1
= 1;
592 symmetry
->x2
= symmetry
->y2
= board_size(b
) - 1;
618 fprintf(stderr
, "NEW SYMMETRY [%d,%d,%d,%d|%d=%d]\n",
619 symmetry
->x1
, symmetry
->y1
, symmetry
->x2
, symmetry
->y2
,
620 symmetry
->d
, symmetry
->type
);
627 board_handicap_stone(struct board
*board
, int x
, int y
, FILE *f
)
630 m
.color
= S_BLACK
; m
.coord
= coord_xy(board
, x
, y
);
632 board_play(board
, &m
);
633 /* Simulate white passing; otherwise, UCT search can get confused since
634 * tree depth parity won't match the color to move. */
637 char *str
= coord2str(m
.coord
, board
);
639 fprintf(stderr
, "choosing handicap %s (%d,%d)\n", str
, x
, y
);
640 fprintf(f
, "%s ", str
);
645 board_handicap(struct board
*board
, int stones
, FILE *f
)
647 int margin
= 3 + (board_size(board
) >= 13);
649 int mid
= board_size(board
) / 2;
650 int max
= board_size(board
) - 1 - margin
;
651 const int places
[][2] = {
652 { min
, min
}, { max
, max
}, { max
, min
}, { min
, max
},
653 { min
, mid
}, { max
, mid
},
654 { mid
, min
}, { mid
, max
},
658 board
->handicap
= stones
;
660 if (stones
== 5 || stones
== 7) {
661 board_handicap_stone(board
, mid
, mid
, f
);
666 for (i
= 0; i
< stones
; i
++)
667 board_handicap_stone(board
, places
[i
][0], places
[i
][1], f
);
671 static void __attribute__((noinline
))
672 check_libs_consistency(struct board
*board
, group_t g
)
676 struct group
*gi
= &board_group_info(board
, g
);
677 for (int i
= 0; i
< GROUP_KEEP_LIBS
; i
++)
678 if (gi
->lib
[i
] && board_at(board
, gi
->lib
[i
]) != S_NONE
) {
679 fprintf(stderr
, "BOGUS LIBERTY %s of group %d[%s]\n", coord2sstr(gi
->lib
[i
], board
), g
, coord2sstr(group_base(g
), board
));
686 board_capturable_add(struct board
*board
, group_t group
, coord_t lib
)
688 //fprintf(stderr, "group %s cap %s\n", coord2sstr(group, board), coord2sstr(lib, boarD));
690 /* Increase capturable count trait of my last lib. */
691 enum stone capturing_color
= stone_other(board_at(board
, group
));
692 assert(capturing_color
== S_BLACK
|| capturing_color
== S_WHITE
);
693 foreach_neighbor(board
, lib
, {
694 if (DEBUGL(8) && group_at(board
, c
) == group
)
695 fprintf(stderr
, "%s[%d] %s cap bump bc of %s(%d) member %s\n", coord2sstr(lib
, board
), trait_at(board
, lib
, capturing_color
).cap
, stone2str(capturing_color
), coord2sstr(group
, board
), board_group_info(board
, group
).libs
, coord2sstr(c
, board
));
696 trait_at(board
, lib
, capturing_color
).cap
+= (group_at(board
, c
) == group
);
698 board_trait_recompute(board
, lib
);
702 /* Update the list of capturable groups. */
704 assert(board
->clen
< board_size2(board
));
705 board
->c
[board
->clen
++] = group
;
709 board_capturable_rm(struct board
*board
, group_t group
, coord_t lib
)
711 //fprintf(stderr, "group %s nocap %s\n", coord2sstr(group, board), coord2sstr(lib, board));
713 /* Decrease capturable count trait of my previously-last lib. */
714 enum stone capturing_color
= stone_other(board_at(board
, group
));
715 assert(capturing_color
== S_BLACK
|| capturing_color
== S_WHITE
);
716 foreach_neighbor(board
, lib
, {
717 if (DEBUGL(8) && group_at(board
, c
) == group
)
718 fprintf(stderr
, "%s[%d] cap dump bc of %s(%d) member %s\n", coord2sstr(lib
, board
), trait_at(board
, lib
, capturing_color
).cap
, coord2sstr(group
, board
), board_group_info(board
, group
).libs
, coord2sstr(c
, board
));
719 trait_at(board
, lib
, capturing_color
).cap
-= (group_at(board
, c
) == group
);
721 board_trait_recompute(board
, lib
);
725 /* Update the list of capturable groups. */
726 for (int i
= 0; i
< board
->clen
; i
++) {
727 if (unlikely(board
->c
[i
] == group
)) {
728 board
->c
[i
] = board
->c
[--board
->clen
];
732 fprintf(stderr
, "rm of bad group %d\n", group_base(group
));
738 board_group_addlib(struct board
*board
, group_t group
, coord_t coord
)
741 fprintf(stderr
, "Group %d[%s] %d: Adding liberty %s\n",
742 group_base(group
), coord2sstr(group_base(group
), board
),
743 board_group_info(board
, group
).libs
, coord2sstr(coord
, board
));
746 check_libs_consistency(board
, group
);
748 struct group
*gi
= &board_group_info(board
, group
);
749 if (gi
->libs
< GROUP_KEEP_LIBS
) {
750 for (int i
= 0; i
< GROUP_KEEP_LIBS
; i
++) {
752 /* Seems extra branch just slows it down */
756 if (unlikely(gi
->lib
[i
] == coord
))
760 board_capturable_add(board
, group
, coord
);
761 else if (gi
->libs
== 1)
762 board_capturable_rm(board
, group
, gi
->lib
[0]);
763 gi
->lib
[gi
->libs
++] = coord
;
766 check_libs_consistency(board
, group
);
770 board_group_find_extra_libs(struct board
*board
, group_t group
, struct group
*gi
, coord_t avoid
)
772 /* Add extra liberty from the board to our liberty list. */
773 unsigned char watermark
[board_size2(board
) / 8];
774 memset(watermark
, 0, sizeof(watermark
));
775 #define watermark_get(c) (watermark[coord_raw(c) >> 3] & (1 << (coord_raw(c) & 7)))
776 #define watermark_set(c) watermark[coord_raw(c) >> 3] |= (1 << (coord_raw(c) & 7))
778 for (int i
= 0; i
< GROUP_KEEP_LIBS
- 1; i
++)
779 watermark_set(gi
->lib
[i
]);
780 watermark_set(avoid
);
782 foreach_in_group(board
, group
) {
784 foreach_neighbor(board
, coord2
, {
785 if (board_at(board
, c
) + watermark_get(c
) != S_NONE
)
788 gi
->lib
[gi
->libs
++] = c
;
789 if (unlikely(gi
->libs
>= GROUP_KEEP_LIBS
))
792 } foreach_in_group_end
;
798 board_group_rmlib(struct board
*board
, group_t group
, coord_t coord
)
801 fprintf(stderr
, "Group %d[%s] %d: Removing liberty %s\n",
802 group_base(group
), coord2sstr(group_base(group
), board
),
803 board_group_info(board
, group
).libs
, coord2sstr(coord
, board
));
806 struct group
*gi
= &board_group_info(board
, group
);
807 for (int i
= 0; i
< GROUP_KEEP_LIBS
; i
++) {
809 /* Seems extra branch just slows it down */
813 if (likely(gi
->lib
[i
] != coord
))
816 coord_t lib
= gi
->lib
[i
] = gi
->lib
[--gi
->libs
];
817 gi
->lib
[gi
->libs
] = 0;
819 check_libs_consistency(board
, group
);
821 /* Postpone refilling lib[] until we need to. */
822 assert(GROUP_REFILL_LIBS
> 1);
823 if (gi
->libs
> GROUP_REFILL_LIBS
)
825 if (gi
->libs
== GROUP_REFILL_LIBS
)
826 board_group_find_extra_libs(board
, group
, gi
, coord
);
829 board_capturable_add(board
, group
, gi
->lib
[0]);
830 else if (gi
->libs
== 0)
831 board_capturable_rm(board
, group
, lib
);
835 /* This is ok even if gi->libs < GROUP_KEEP_LIBS since we
836 * can call this multiple times per coord. */
837 check_libs_consistency(board
, group
);
842 /* This is a low-level routine that doesn't maintain consistency
843 * of all the board data structures. */
845 board_remove_stone(struct board
*board
, group_t group
, coord_t c
)
847 enum stone color
= board_at(board
, c
);
848 board_at(board
, c
) = S_NONE
;
849 group_at(board
, c
) = 0;
850 board_hash_update(board
, c
, color
);
852 /* We mark as cannot-capture now. If this is a ko/snapback,
853 * we will get incremented later in board_group_addlib(). */
854 trait_at(board
, c
, S_BLACK
).cap
= 0;
855 trait_at(board
, c
, S_WHITE
).cap
= 0;
856 /* However, we do decide safety statically; we might get
857 * over-paranoid, but in that case the neighbor loop for
858 * stones removed next will repair the flag. */
859 /* We must do this update after the loop when our neighbor count is correct. */
860 board_trait_recompute(board
, c
);
863 /* Increase liberties of surrounding groups */
865 foreach_neighbor(board
, coord
, {
866 dec_neighbor_count_at(board
, c
, color
);
867 board_trait_recompute(board
, c
);
868 group_t g
= group_at(board
, c
);
870 board_group_addlib(board
, g
, coord
);
874 fprintf(stderr
, "pushing free move [%d]: %d,%d\n", board
->flen
, coord_x(c
, board
), coord_y(c
, board
));
875 board
->f
[board
->flen
++] = coord_raw(c
);
878 static int profiling_noinline
879 board_group_capture(struct board
*board
, group_t group
)
883 foreach_in_group(board
, group
) {
884 board
->captures
[stone_other(board_at(board
, c
))]++;
885 board_remove_stone(board
, group
, c
);
887 } foreach_in_group_end
;
889 if (board_group_info(board
, group
).libs
== 1)
890 board_capturable_rm(board
, group
, board_group_info(board
, group
).lib
[0]);
891 memset(&board_group_info(board
, group
), 0, sizeof(struct group
));
897 static void profiling_noinline
898 add_to_group(struct board
*board
, group_t group
, coord_t prevstone
, coord_t coord
)
900 group_at(board
, coord
) = group
;
901 groupnext_at(board
, coord
) = groupnext_at(board
, prevstone
);
902 groupnext_at(board
, prevstone
) = coord_raw(coord
);
905 if (board_group_info(board
, group
).libs
== 1) {
906 /* Our group is temporarily in atari; make sure the capturable
907 * counts also correspond to the newly added stone before we
908 * start adding liberties again so bump-dump ops match. */
909 enum stone capturing_color
= stone_other(board_at(board
, group
));
910 assert(capturing_color
== S_BLACK
|| capturing_color
== S_WHITE
);
911 coord_t lib
= board_group_info(board
, group
).lib
[0];
912 if (coord_is_adjecent(lib
, coord
, board
)) {
913 if (DEBUGL(8)) fprintf(stderr
, "add_to_group %s: %s[%d] bump\n", coord2sstr(group
, board
), coord2sstr(lib
, board
), trait_at(board
, lib
, capturing_color
).cap
);
914 trait_at(board
, lib
, capturing_color
).cap
++;
915 board_trait_recompute(board
, lib
);
920 foreach_neighbor(board
, coord
, {
921 if (board_at(board
, c
) == S_NONE
)
922 board_group_addlib(board
, group
, c
);
926 fprintf(stderr
, "add_to_group: added (%d,%d ->) %d,%d (-> %d,%d) to group %d\n",
927 coord_x(prevstone
, board
), coord_y(prevstone
, board
),
928 coord_x(coord
, board
), coord_y(coord
, board
),
929 groupnext_at(board
, coord
) % board_size(board
), groupnext_at(board
, coord
) / board_size(board
),
933 static void profiling_noinline
934 merge_groups(struct board
*board
, group_t group_to
, group_t group_from
)
937 fprintf(stderr
, "board_play_raw: merging groups %d -> %d\n",
938 group_base(group_from
), group_base(group_to
));
939 struct group
*gi_from
= &board_group_info(board
, group_from
);
940 struct group
*gi_to
= &board_group_info(board
, group_to
);
942 /* We do this early before the group info is rewritten. */
943 if (gi_from
->libs
== 1)
944 board_capturable_rm(board
, group_from
, gi_from
->lib
[0]);
947 fprintf(stderr
,"---- (froml %d, tol %d)\n", gi_from
->libs
, gi_to
->libs
);
949 if (gi_to
->libs
< GROUP_KEEP_LIBS
) {
950 for (int i
= 0; i
< gi_from
->libs
; i
++) {
951 for (int j
= 0; j
< gi_to
->libs
; j
++)
952 if (gi_to
->lib
[j
] == gi_from
->lib
[i
])
954 if (gi_to
->libs
== 0)
955 board_capturable_add(board
, group_to
, gi_from
->lib
[i
]);
956 else if (gi_to
->libs
== 1)
957 board_capturable_rm(board
, group_to
, gi_to
->lib
[0]);
958 gi_to
->lib
[gi_to
->libs
++] = gi_from
->lib
[i
];
959 if (gi_to
->libs
>= GROUP_KEEP_LIBS
)
966 if (board_group_info(board
, group_to
).libs
== 1) {
967 /* Our group is currently in atari; make sure we properly
968 * count in even the neighbors from the other group in the
969 * capturable counter. */
970 enum stone capturing_color
= stone_other(board_at(board
, group_to
));
971 assert(capturing_color
== S_BLACK
|| capturing_color
== S_WHITE
);
972 coord_t lib
= board_group_info(board
, group_to
).lib
[0];
973 foreach_neighbor(board
, lib
, {
974 if (DEBUGL(8) && group_at(board
, c
) == group_from
) fprintf(stderr
, "%s[%d] cap bump\n", coord2sstr(lib
, board
), trait_at(board
, lib
, capturing_color
).cap
);
975 trait_at(board
, lib
, capturing_color
).cap
+= (group_at(board
, c
) == group_from
);
977 board_trait_recompute(board
, lib
);
981 coord_t last_in_group
;
982 foreach_in_group(board
, group_from
) {
984 group_at(board
, c
) = group_to
;
985 } foreach_in_group_end
;
986 groupnext_at(board
, last_in_group
) = groupnext_at(board
, group_base(group_to
));
987 groupnext_at(board
, group_base(group_to
)) = group_base(group_from
);
988 memset(gi_from
, 0, sizeof(struct group
));
991 fprintf(stderr
, "board_play_raw: merged group: %d\n",
992 group_base(group_to
));
995 static group_t profiling_noinline
996 new_group(struct board
*board
, coord_t coord
)
998 group_t group
= coord_raw(coord
);
999 struct group
*gi
= &board_group_info(board
, group
);
1000 foreach_neighbor(board
, coord
, {
1001 if (board_at(board
, c
) == S_NONE
)
1002 /* board_group_addlib is ridiculously expensive for us */
1003 #if GROUP_KEEP_LIBS < 4
1004 if (gi
->libs
< GROUP_KEEP_LIBS
)
1006 gi
->lib
[gi
->libs
++] = c
;
1009 group_at(board
, coord
) = group
;
1010 groupnext_at(board
, coord
) = 0;
1013 board_capturable_add(board
, group
, gi
->lib
[0]);
1014 check_libs_consistency(board
, group
);
1017 fprintf(stderr
, "new_group: added %d,%d to group %d\n",
1018 coord_x(coord
, board
), coord_y(coord
, board
),
1024 static inline group_t
1025 play_one_neighbor(struct board
*board
,
1026 coord_t coord
, enum stone color
, enum stone other_color
,
1027 coord_t c
, group_t group
)
1029 enum stone ncolor
= board_at(board
, c
);
1030 group_t ngroup
= group_at(board
, c
);
1032 inc_neighbor_count_at(board
, c
, color
);
1033 /* We can be S_NONE, in that case we need to update the safety
1034 * trait since we might be left with only one liberty. */
1035 board_trait_recompute(board
, c
);
1040 board_group_rmlib(board
, ngroup
, coord
);
1042 fprintf(stderr
, "board_play_raw: reducing libs for group %d (%d:%d,%d)\n",
1043 group_base(ngroup
), ncolor
, color
, other_color
);
1045 if (ncolor
== color
&& ngroup
!= group
) {
1048 add_to_group(board
, group
, c
, coord
);
1050 merge_groups(board
, group
, ngroup
);
1052 } else if (ncolor
== other_color
) {
1054 struct group
*gi
= &board_group_info(board
, ngroup
);
1055 fprintf(stderr
, "testing captured group %d[%s]: ", group_base(ngroup
), coord2sstr(group_base(ngroup
), board
));
1056 for (int i
= 0; i
< GROUP_KEEP_LIBS
; i
++)
1057 fprintf(stderr
, "%s ", coord2sstr(gi
->lib
[i
], board
));
1058 fprintf(stderr
, "\n");
1060 if (unlikely(board_group_captured(board
, ngroup
)))
1061 board_group_capture(board
, ngroup
);
1066 /* We played on a place with at least one liberty. We will become a member of
1067 * some group for sure. */
1068 static group_t profiling_noinline
1069 board_play_outside(struct board
*board
, struct move
*m
, int f
)
1071 coord_t coord
= m
->coord
;
1072 enum stone color
= m
->color
;
1073 enum stone other_color
= stone_other(color
);
1076 board
->f
[f
] = board
->f
[--board
->flen
];
1078 fprintf(stderr
, "popping free move [%d->%d]: %d\n", board
->flen
, f
, board
->f
[f
]);
1080 #if defined(BOARD_TRAITS) && defined(DEBUG)
1081 /* Sanity check that cap matches reality. */
1084 foreach_neighbor(board
, coord
, {
1085 group_t g
= group_at(board
, c
);
1086 a
+= g
&& (board_at(board
, c
) == other_color
&& board_group_info(board
, g
).libs
== 1);
1088 assert(a
== trait_at(board
, coord
, color
).cap
);
1089 assert(board_safe_to_play(board
, coord
, color
) == trait_at(board
, coord
, color
).safe
);
1092 foreach_neighbor(board
, coord
, {
1093 group
= play_one_neighbor(board
, coord
, color
, other_color
, c
, group
);
1096 board_at(board
, coord
) = color
;
1097 if (unlikely(!group
))
1098 group
= new_group(board
, coord
);
1099 board_gamma_update(board
, coord
, S_BLACK
);
1100 board_gamma_update(board
, coord
, S_WHITE
);
1102 board
->last_move2
= board
->last_move
;
1103 board
->last_move
= *m
;
1105 board_hash_update(board
, coord
, color
);
1106 board_symmetry_update(board
, &board
->symmetry
, coord
);
1107 struct move ko
= { pass
, S_NONE
};
1113 /* We played in an eye-like shape. Either we capture at least one of the eye
1114 * sides in the process of playing, or return -1. */
1115 static int profiling_noinline
1116 board_play_in_eye(struct board
*board
, struct move
*m
, int f
)
1118 coord_t coord
= m
->coord
;
1119 enum stone color
= m
->color
;
1120 /* Check ko: Capture at a position of ko capture one move ago */
1121 if (unlikely(color
== board
->ko
.color
&& coord_eq(coord
, board
->ko
.coord
))) {
1123 fprintf(stderr
, "board_check: ko at %d,%d color %d\n", coord_x(coord
, board
), coord_y(coord
, board
), color
);
1125 } else if (DEBUGL(6)) {
1126 fprintf(stderr
, "board_check: no ko at %d,%d,%d - ko is %d,%d,%d\n",
1127 color
, coord_x(coord
, board
), coord_y(coord
, board
),
1128 board
->ko
.color
, coord_x(board
->ko
.coord
, board
), coord_y(board
->ko
.coord
, board
));
1131 struct move ko
= { pass
, S_NONE
};
1133 int captured_groups
= 0;
1135 foreach_neighbor(board
, coord
, {
1136 group_t g
= group_at(board
, c
);
1138 fprintf(stderr
, "board_check: group %d has %d libs\n",
1139 g
, board_group_info(board
, g
).libs
);
1140 captured_groups
+= (board_group_info(board
, g
).libs
== 1);
1143 if (likely(captured_groups
== 0)) {
1146 board_print(board
, stderr
);
1147 fprintf(stderr
, "board_check: one-stone suicide\n");
1153 /* We _will_ for sure capture something. */
1154 assert(trait_at(board
, coord
, color
).cap
> 0);
1155 assert(trait_at(board
, coord
, color
).safe
== board_safe_to_play(board
, coord
, color
));
1158 board
->f
[f
] = board
->f
[--board
->flen
];
1160 fprintf(stderr
, "popping free move [%d->%d]: %d\n", board
->flen
, f
, board
->f
[f
]);
1162 foreach_neighbor(board
, coord
, {
1163 inc_neighbor_count_at(board
, c
, color
);
1164 /* Originally, this could not have changed any trait
1165 * since no neighbors were S_NONE, however by now some
1166 * of them might be removed from the board. */
1167 board_trait_recompute(board
, c
);
1169 group_t group
= group_at(board
, c
);
1173 board_group_rmlib(board
, group
, coord
);
1175 fprintf(stderr
, "board_play_raw: reducing libs for group %d\n",
1178 if (board_group_captured(board
, group
)) {
1179 if (board_group_capture(board
, group
) == 1) {
1180 /* If we captured multiple groups at once,
1181 * we can't be fighting ko so we don't need
1182 * to check for that. */
1183 ko
.color
= stone_other(color
);
1185 board
->last_ko
= ko
;
1186 board
->last_ko_age
= board
->moves
;
1188 fprintf(stderr
, "guarding ko at %d,%s\n", ko
.color
, coord2sstr(ko
.coord
, board
));
1193 board_at(board
, coord
) = color
;
1194 group_t group
= new_group(board
, coord
);
1195 board_gamma_update(board
, coord
, S_BLACK
);
1196 board_gamma_update(board
, coord
, S_WHITE
);
1198 board
->last_move2
= board
->last_move
;
1199 board
->last_move
= *m
;
1201 board_hash_update(board
, coord
, color
);
1202 board_hash_commit(board
);
1203 board_symmetry_update(board
, &board
->symmetry
, coord
);
1209 static int __attribute__((flatten
))
1210 board_play_f(struct board
*board
, struct move
*m
, int f
)
1213 fprintf(stderr
, "board_play(): ---- Playing %d,%d\n", coord_x(m
->coord
, board
), coord_y(m
->coord
, board
));
1215 if (likely(!board_is_eyelike(board
, &m
->coord
, stone_other(m
->color
)))) {
1216 /* NOT playing in an eye. Thus this move has to succeed. (This
1217 * is thanks to New Zealand rules. Otherwise, multi-stone
1218 * suicide might fail.) */
1219 group_t group
= board_play_outside(board
, m
, f
);
1220 if (unlikely(board_group_captured(board
, group
))) {
1221 board_group_capture(board
, group
);
1223 board_hash_commit(board
);
1226 return board_play_in_eye(board
, m
, f
);
1231 board_play(struct board
*board
, struct move
*m
)
1233 if (unlikely(is_pass(m
->coord
) || is_resign(m
->coord
))) {
1234 struct move nomove
= { pass
, S_NONE
};
1236 board
->last_move2
= board
->last_move
;
1237 board
->last_move
= *m
;
1242 for (f
= 0; f
< board
->flen
; f
++)
1243 if (board
->f
[f
] == coord_raw(m
->coord
))
1244 return board_play_f(board
, m
, f
);
1247 fprintf(stderr
, "board_check: stone exists\n");
1253 board_try_random_move(struct board
*b
, enum stone color
, coord_t
*coord
, int f
, ppr_permit permit
, void *permit_data
)
1255 coord_raw(*coord
) = b
->f
[f
];
1256 if (unlikely(is_pass(*coord
)))
1258 struct move m
= { *coord
, color
};
1260 fprintf(stderr
, "trying random move %d: %d,%d\n", f
, coord_x(*coord
, b
), coord_y(*coord
, b
));
1261 return (likely(!board_is_one_point_eye(b
, coord
, color
)) /* bad idea to play into one, usually */
1262 && board_is_valid_move(b
, &m
)
1263 && (!permit
|| permit(permit_data
, b
, &m
))
1264 && likely(board_play_f(b
, &m
, f
) >= 0));
1268 board_play_random(struct board
*b
, enum stone color
, coord_t
*coord
, ppr_permit permit
, void *permit_data
)
1270 int base
= fast_random(b
->flen
);
1271 coord_pos(*coord
, base
, b
);
1272 if (likely(board_try_random_move(b
, color
, coord
, base
, permit
, permit_data
)))
1276 for (f
= base
+ 1; f
< b
->flen
; f
++)
1277 if (board_try_random_move(b
, color
, coord
, f
, permit
, permit_data
))
1279 for (f
= 0; f
< base
; f
++)
1280 if (board_try_random_move(b
, color
, coord
, f
, permit
, permit_data
))
1284 struct move m
= { pass
, color
};
1290 board_is_false_eyelike(struct board
*board
, coord_t
*coord
, enum stone eye_color
)
1292 enum stone color_diag_libs
[S_MAX
] = {0, 0, 0, 0};
1294 /* XXX: We attempt false eye detection but we will yield false
1295 * positives in case of http://senseis.xmp.net/?TwoHeadedDragon :-( */
1297 foreach_diag_neighbor(board
, *coord
) {
1298 color_diag_libs
[(enum stone
) board_at(board
, c
)]++;
1299 } foreach_diag_neighbor_end
;
1300 /* For false eye, we need two enemy stones diagonally in the
1301 * middle of the board, or just one enemy stone at the edge
1302 * or in the corner. */
1303 color_diag_libs
[stone_other(eye_color
)] += !!color_diag_libs
[S_OFFBOARD
];
1304 return color_diag_libs
[stone_other(eye_color
)] >= 2;
1308 board_is_one_point_eye(struct board
*board
, coord_t
*coord
, enum stone eye_color
)
1310 return board_is_eyelike(board
, coord
, eye_color
)
1311 && !board_is_false_eyelike(board
, coord
, eye_color
);
1315 board_get_one_point_eye(struct board
*board
, coord_t
*coord
)
1317 if (board_is_one_point_eye(board
, coord
, S_WHITE
))
1319 else if (board_is_one_point_eye(board
, coord
, S_BLACK
))
1327 board_fast_score(struct board
*board
)
1330 memset(scores
, 0, sizeof(scores
));
1332 foreach_point(board
) {
1333 enum stone color
= board_at(board
, c
);
1334 if (color
== S_NONE
)
1335 color
= board_get_one_point_eye(board
, &c
);
1337 // fprintf(stderr, "%d, %d ++%d = %d\n", coord_x(c, board), coord_y(c, board), color, scores[color]);
1338 } foreach_point_end
;
1340 return board
->komi
+ board
->handicap
+ scores
[S_WHITE
] - scores
[S_BLACK
];
1343 /* Owner map: 0: undecided; 1: black; 2: white; 3: dame */
1345 /* One flood-fill iteration; returns true if next iteration
1348 board_tromp_taylor_iter(struct board
*board
, int *ownermap
)
1350 bool needs_update
= false;
1351 foreach_point(board
) {
1352 /* Ignore occupied and already-dame positions. */
1353 if (board_at(board
, c
) != S_NONE
|| ownermap
[c
] == 3)
1355 /* Count neighbors. */
1357 foreach_neighbor(board
, c
, {
1360 /* If we have neighbors of both colors, or dame,
1361 * we are dame too. */
1362 if ((nei
[1] && nei
[2]) || nei
[3]) {
1364 /* Speed up the propagation. */
1365 foreach_neighbor(board
, c
, {
1366 if (board_at(board
, c
) == S_NONE
)
1369 needs_update
= true;
1372 /* If we have neighbors of one color, we are owned
1373 * by that color, too. */
1374 if (!ownermap
[c
] && (nei
[1] || nei
[2])) {
1375 int newowner
= nei
[1] ? 1 : 2;
1376 ownermap
[c
] = newowner
;
1377 /* Speed up the propagation. */
1378 foreach_neighbor(board
, c
, {
1379 if (board_at(board
, c
) == S_NONE
&& !ownermap
[c
])
1380 ownermap
[c
] = newowner
;
1382 needs_update
= true;
1385 } foreach_point_end
;
1386 return needs_update
;
1389 /* Tromp-Taylor Counting */
1391 board_official_score(struct board
*board
, struct move_queue
*q
)
1394 /* A point P, not colored C, is said to reach C, if there is a path of
1395 * (vertically or horizontally) adjacent points of P's color from P to
1396 * a point of color C.
1398 * A player's score is the number of points of her color, plus the
1399 * number of empty points that reach only her color. */
1401 int ownermap
[board_size2(board
)];
1403 const int o
[4] = {0, 1, 2, 0};
1404 foreach_point(board
) {
1405 ownermap
[c
] = o
[board_at(board
, c
)];
1406 s
[board_at(board
, c
)]++;
1407 } foreach_point_end
;
1410 /* Process dead groups. */
1411 for (int i
= 0; i
< q
->moves
; i
++) {
1412 foreach_in_group(board
, q
->move
[i
]) {
1413 enum stone color
= board_at(board
, c
);
1414 ownermap
[c
] = o
[stone_other(color
)];
1415 s
[color
]--; s
[stone_other(color
)]++;
1416 } foreach_in_group_end
;
1420 /* We need to special-case empty board. */
1421 if (!s
[S_BLACK
] && !s
[S_WHITE
])
1422 return board
->komi
+ board
->handicap
;
1424 while (board_tromp_taylor_iter(board
, ownermap
))
1425 /* Flood-fill... */;
1428 memset(scores
, 0, sizeof(scores
));
1430 foreach_point(board
) {
1431 assert(board_at(board
, c
) == S_OFFBOARD
|| ownermap
[c
] != 0);
1432 if (ownermap
[c
] == 3)
1434 scores
[ownermap
[c
]]++;
1435 } foreach_point_end
;
1437 return board
->komi
+ board
->handicap
+ scores
[S_WHITE
] - scores
[S_BLACK
];