annabunches/pygo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
8b772255a1
pygo/gnugo/engine/value_moves.c

4044 lines
118 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* This is GNU Go, a Go program. Contact gnugo@gnu.org, or see *
* http://www.gnu.org/software/gnugo/ for more information. *
* *
* Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, *
* 2008 and 2009 by the Free Software Foundation. *
* *
* This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as *
* published by the Free Software Foundation - version 3 or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License in file COPYING for more details. *
* *
* You should have received a copy of the GNU General Public *
* License along with this program; if not, write to the Free *
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor, *
* Boston, MA 02111, USA. *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "gnugo.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "liberty.h"
#include "gg_utils.h"
#include "move_reasons.h"
/* Count how many distinct strings are (solidly) connected by the move
* at (pos). Add a bonus for strings with few liberties. Also add
* bonus for opponent strings put in atari or removed and for own
* strings in atari adjacent to removed opponent strings.
*
* The parameter to_move should be set when color is the color to
* move. (This function is called for both colors.)
*/
static int
move_connects_strings(int pos, int color, int to_move)
{
int ss[4];
int strings = 0;
int own_strings = 0;
int k, l;
int fewlibs = 0;
for (k = 0; k < 4; k++) {
int ii = pos + delta[k];
int origin;
if (!ON_BOARD(ii) || board[ii] == EMPTY)
continue;
origin = find_origin(ii);
for (l = 0; l < strings; l++)
if (ss[l] == origin)
break;
if (l == strings) {
ss[strings] = origin;
strings++;
}
}
for (k = 0; k < strings; k++) {
if (worm[ss[k]].invincible)
continue;
if (board[ss[k]] == color) {
int newlibs = approxlib(pos, color, MAXLIBS, NULL);
own_strings++;
if (newlibs >= countlib(ss[k])) {
if (countlib(ss[k]) <= 4)
fewlibs++;
if (countlib(ss[k]) <= 2)
fewlibs++;
}
}
else {
if (countlib(ss[k]) <= 2)
fewlibs++;
if (countlib(ss[k]) <= 1 && to_move) {
int dummy[MAXCHAIN];
fewlibs++;
fewlibs += chainlinks2(ss[k], dummy, 1);
}
}
}
/* Do some thresholding. */
if (fewlibs > 4)
fewlibs = 4;
if (to_move && is_ko(pos, color, NULL) && fewlibs > 1)
fewlibs = 1;
if (fewlibs == 0 && own_strings == 1)
own_strings = 0;
return own_strings + fewlibs;
}
/* Find saved dragons and worms, then call blunder_size(). */
static float
value_moves_get_blunder_size(int move, int color)
{
signed char saved_dragons[BOARDMAX];
signed char saved_worms[BOARDMAX];
signed char safe_stones[BOARDMAX];
get_saved_dragons(move, saved_dragons);
get_saved_worms(move, saved_worms);
mark_safe_stones(color, move, saved_dragons, saved_worms, safe_stones);
return blunder_size(move, color, NULL, safe_stones);
}
static int
value_moves_confirm_safety(int move, int color)
{
return (value_moves_get_blunder_size(move, color) == 0.0);
}
/* Test all moves which defend, attack, connect or cut to see if they
* also attack or defend some other worm.
*
* FIXME: We would like to see whether an arbitrary move works to cut
* or connect something else too.
*/
static void
find_more_attack_and_defense_moves(int color)
{
int unstable_worms[MAX_WORMS];
int N = 0; /* number of unstable worms */
int ii;
int k;
int other = OTHER_COLOR(color);
int cursor_at_start_of_line;
TRACE("\nLooking for additional attack and defense moves. Trying moves ...\n");
/* Identify the unstable worms and store them in a list. */
for (ii = BOARDMIN; ii < BOARDMAX; ii++) {
if (IS_STONE(board[ii])
&& worm[ii].origin == ii
&& worm[ii].attack_codes[0] != 0
&& worm[ii].defense_codes[0] != 0) {
unstable_worms[N] = ii;
N++;
}
}
/* To avoid horizon effects, we temporarily increase the depth values. */
increase_depth_values();
for (ii = BOARDMIN; ii < BOARDMAX; ii++) {
if (board[ii] != EMPTY)
continue;
/* Don't consider send-two-return-one moves here. */
if (send_two_return_one(ii, color))
continue;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[ii].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == ATTACK_MOVE
|| move_reasons[r].type == ATTACK_MOVE_GOOD_KO
|| move_reasons[r].type == ATTACK_MOVE_BAD_KO
|| move_reasons[r].type == DEFEND_MOVE
|| move_reasons[r].type == DEFEND_MOVE_GOOD_KO
|| move_reasons[r].type == DEFEND_MOVE_BAD_KO
|| move_reasons[r].type == CONNECT_MOVE
|| move_reasons[r].type == CUT_MOVE)
break;
/* FIXME: Add code for EITHER_MOVE and ALL_MOVE here. */
}
if (k == MAX_REASONS || move[ii].reason[k] == -1)
continue;
/* Try the move at (ii) and see what happens. */
cursor_at_start_of_line = 0;
TRACE("%1m ", ii);
if (trymove(ii, color, "find_more_attack_and_defense_moves", NO_MOVE)) {
for (k = 0; k < N; k++) {
int aa = unstable_worms[k];
/* string of our color, see if there still is an attack,
* unless we already know the move works as defense move.
*/
if (board[aa] == color
&& !defense_move_reason_known(ii, unstable_worms[k])) {
int acode = attack(aa, NULL);
if (acode < worm[aa].attack_codes[0]) {
/* Maybe attack() doesn't find the attack. Try to
* attack with the stored attack move.
*/
int defense_works = 1;
if (trymove(worm[aa].attack_points[0], other,
"find_more_attack_and_defense_moves", 0)) {
if (!board[aa])
defense_works = 0;
else {
int this_acode = REVERSE_RESULT(find_defense(aa, NULL));
if (this_acode > acode) {
acode = this_acode;
if (acode >= worm[aa].attack_codes[0])
defense_works = 0;
}
}
popgo();
}
if (defense_works) {
if (!cursor_at_start_of_line)
TRACE("\n");
TRACE("%ofound extra point of defense of %1m at %1m code %d\n",
aa, ii, REVERSE_RESULT(acode));
cursor_at_start_of_line = 1;
add_defense_move(ii, aa, REVERSE_RESULT(acode));
}
}
}
/* string of opponent color, see if there still is a defense,
* unless we already know the move works as attack move.
*/
if (board[aa] == other
&& !attack_move_reason_known(ii, unstable_worms[k])) {
int dcode = find_defense(aa, NULL);
if (dcode < worm[aa].defense_codes[0]) {
/* Maybe find_defense() doesn't find the defense. Try to
* defend with the stored defense move.
*
* Another option is maybe there is no attack anymore
* (e.g. we pushed the worm into seki), find_defense()
* could easily fail in that case.
*/
int attack_works = 1;
if (attack(aa, NULL) >= worm[aa].attack_codes[0]) {
if (trymove(worm[aa].defense_points[0], other,
"find_more_attack_and_defense_moves", 0)) {
int this_dcode = REVERSE_RESULT(attack(aa, NULL));
if (this_dcode > dcode) {
dcode = this_dcode;
if (dcode >= worm[aa].defense_codes[0])
attack_works = 0;
}
popgo();
}
}
else
attack_works = 0;
if (attack_works) {
if (!cursor_at_start_of_line)
TRACE("\n");
TRACE("%ofound extra point of attack of %1m at %1m code %d\n",
aa, ii, REVERSE_RESULT(dcode));
cursor_at_start_of_line = 1;
add_attack_move(ii, aa, REVERSE_RESULT(dcode));
}
}
}
}
popgo();
}
}
TRACE("\n");
decrease_depth_values();
}
/* Do the real job of find_more_owl_attack_and_defense_moves() with given
* move reason at given position and for given target (`what'). This
* function is used from induce_secondary_move_reasons() for upgrading
* one specific move reason only.
*/
static void
do_find_more_owl_attack_and_defense_moves(int color, int pos,
int move_reason_type, int what)
{
int k;
int dd1 = NO_MOVE;
int dd2 = NO_MOVE;
int save_verbose;
gg_assert(stackp == 0);
/* Never consider moves of the send-two-return-one type here. */
if (send_two_return_one(pos, color))
return;
/* Never consider moves playing into snapback here. */
if (playing_into_snapback(pos, color))
return;
save_verbose = verbose;
if (verbose > 0)
verbose --;
if (move_reason_type == STRATEGIC_ATTACK_MOVE
|| move_reason_type == STRATEGIC_DEFEND_MOVE)
dd1 = what;
else if (move_reason_type == ATTACK_MOVE
|| move_reason_type == ATTACK_MOVE_GOOD_KO
|| move_reason_type == ATTACK_MOVE_BAD_KO
|| move_reason_type == DEFEND_MOVE
|| move_reason_type == DEFEND_MOVE_GOOD_KO
|| move_reason_type == DEFEND_MOVE_BAD_KO
|| move_reason_type == VITAL_EYE_MOVE)
dd1 = what;
else if (move_reason_type == CONNECT_MOVE) {
int worm1 = conn_worm1[what];
int worm2 = conn_worm2[what];
dd1 = dragon[worm1].origin;
dd2 = dragon[worm2].origin;
if (dd1 == dd2)
dd2 = NO_MOVE;
}
else {
verbose = save_verbose;
return;
}
for (k = 0; k < 2; k++) {
int dd = (k == 0 ? dd1 : dd2);
if (dd == NO_MOVE)
continue;
/* Don't care about inessential dragons. */
if (DRAGON2(dd).safety == INESSENTIAL)
continue;
if (DRAGON2(dd).owl_status != CRITICAL)
continue;
if ((move_reason_type == STRATEGIC_ATTACK_MOVE
|| move_reason_type == ATTACK_MOVE
|| move_reason_type == ATTACK_MOVE_GOOD_KO
|| move_reason_type == ATTACK_MOVE_BAD_KO
|| (move_reason_type == VITAL_EYE_MOVE
&& board[dd] == OTHER_COLOR(color)))
&& !owl_attack_move_reason_known(pos, dd)) {
int kworm = NO_MOVE;
int acode = owl_does_attack(pos, dd, &kworm);
if (acode >= DRAGON2(dd).owl_attack_code) {
add_owl_attack_move(pos, dd, kworm, acode);
if (save_verbose)
gprintf("Move at %1m upgraded to owl attack on %1m (%s).\n",
pos, dd, result_to_string(acode));
}
}
if ((move_reason_type == STRATEGIC_DEFEND_MOVE
|| move_reason_type == CONNECT_MOVE
|| move_reason_type == DEFEND_MOVE
|| move_reason_type == DEFEND_MOVE_GOOD_KO
|| move_reason_type == DEFEND_MOVE_BAD_KO
|| (move_reason_type == VITAL_EYE_MOVE
&& board[dd] == color))
&& !owl_defense_move_reason_known(pos, dd)) {
int kworm = NO_MOVE;
/* FIXME: Better use owl_connection_defend() for CONNECT_MOVE ? */
int dcode = owl_does_defend(pos, dd, &kworm);
if (dcode >= DRAGON2(dd).owl_defense_code) {
if (dcode == LOSS)
add_loss_move(pos, dd, kworm);
else
add_owl_defense_move(pos, dd, dcode);
if (save_verbose)
gprintf("Move at %1m upgraded to owl defense for %1m (%s).\n",
pos, dd, result_to_string(dcode));
}
}
}
verbose = save_verbose;
}
/* Try whether the move at (pos) for (color) is also an owl attack on
* (target). (dist) is the distance to the dragon, and is used for a
* safety heuristic: distant moves are only accepted if they kill within
* few owl nodes.
*/
static void
try_large_scale_owl_attack(int pos, int color, int target, int dist)
{
int owl_nodes_before;
int owl_nodes_used;
int kworm = NO_MOVE;
int acode;
int save_verbose = verbose;
int save_owl_node_limit = owl_node_limit;
ASSERT1(board[target] == OTHER_COLOR(color), pos);
ASSERT1(!owl_attack_move_reason_known(pos, target), pos);
DEBUG(DEBUG_LARGE_SCALE, "Trying large scale move %1m on %1m\n", pos, target);
/* To avoid horizon effects, we temporarily increase
* the depth values to find the large scale attacks.
*/
increase_depth_values();
/* To reduce the amount of aji allowed for large scale
* attacks, we reduce the owl limit to 350 nodes for
* attacks at distance <= 1, and 150 nodes for attacks at
* distance >= 2.
*/
if (dist <= 1)
owl_node_limit *= 0.35;
else
owl_node_limit *= 0.15;
if (DRAGON2(target).owl_attack_node_count < owl_node_limit) {
if (verbose > 0)
verbose--;
owl_nodes_before = get_owl_node_counter();
acode = owl_does_attack(pos, target, &kworm);
owl_nodes_used = get_owl_node_counter() - owl_nodes_before;
if (acode >= DRAGON2(target).owl_attack_code
&& acode == WIN) {
add_owl_attack_move(pos, target, kworm, acode);
DEBUG(DEBUG_LARGE_SCALE | DEBUG_MOVE_REASONS,
"Move at %1m owl-attacks %1m on a large scale(%s).\n",
pos, target, result_to_string(acode));
}
else
DEBUG(DEBUG_LARGE_SCALE,
"Move at %1m isn't a clean large scale attack on %1m (%s).\n",
pos, target, result_to_string(acode));
DEBUG(DEBUG_LARGE_SCALE, " owl nodes used = %d, dist = %d\n",
owl_nodes_used, dist);
/* Restore settings. */
verbose = save_verbose;
}
decrease_depth_values();
owl_node_limit = save_owl_node_limit;
}
#define MAXIMUM_LARGE_SCALE_DIST 3
/* Test all the moves to see whether they can owl-attack a specific
* dragon on a large scale . Tested moves are
* 1. Moves that already have a move reason.
* 2. Are not too far away.
* The distance used is the Manhattan distance, and the maximum
* distance is MAXIMUM_LARGE_SCALE_DIST.
*/
static void
find_large_scale_owl_attacks_on_dragon(int color, int target)
{
int x, y;
int x_min = board_size;
int x_max = 0;
int y_min = board_size;
int y_max = 0;
int dist;
ASSERT1(board[target] == OTHER_COLOR(color), target);
/* Find the physical extension of the dragon. */
for (x = 0; x < board_size; x++)
for (y = 0; y < board_size; y++) {
if (is_same_dragon(target, POS(x, y))) {
if (x < x_min)
x_min = x;
if (x > x_max)
x_max = x;
if (y < y_min)
y_min = y;
if (y > y_max)
y_max = y;
}
}
ASSERT1(x_min <= x_max && y_min <= y_max, target);
/* Try to find large scale attacks.
* We do this by first trying to find attacks at dist = 0, then
* dist = 1, etc., up to MAXIMUM_LARGE_SCALE_DIST.
*/
for (dist = 0; dist <= MAXIMUM_LARGE_SCALE_DIST; dist++)
for (x = gg_max(x_min - dist, 0);
x <= gg_min(x_max + dist, board_size - 1); x++)
for (y = gg_max(y_min - dist, 0);
y <= gg_min(y_max + dist, board_size - 1); y++) {
int pos = POS(x, y);
ASSERT1(ON_BOARD2(x, y), pos);
if (board[pos] == EMPTY) {
int a, b, dx, dy;
a = abs(x - x_min);
b = abs(x - x_max);
dx = gg_min(a, b);
a = abs(y - y_min);
b = abs(y - y_max);
dy = gg_min(a, b);
if (gg_max(dx, dy) == dist
&& move[pos].reason[0] >= 0
&& !owl_attack_move_reason_known(pos, target))
/* Maximum Manhatan distance, move reason known but no owl
* attack yet.
*/
try_large_scale_owl_attack(pos, color, target, dist);
}
}
}
/* Try large scale owl attacks against all enemy dragons that are
* small (size <= 6) and critical.
*/
static void
find_large_scale_owl_attack_moves(int color)
{
int d;
DEBUG(DEBUG_LARGE_SCALE, "\nTrying to find large scale attack moves.\n");
for (d = 0; d < number_of_dragons; d++) {
int target = dragon2[d].origin;
if (dragon[target].color == OTHER_COLOR(color)
&& dragon[target].size <= 6
&& dragon[target].status == CRITICAL
&& dragon2[d].owl_status == CRITICAL) {
DEBUG(DEBUG_LARGE_SCALE, "Small critical dragon found at %1m\n", target);
find_large_scale_owl_attacks_on_dragon(color, target);
}
}
}
/* Test certain moves to see whether they (too) can owl-attack or
* defend an owl critical dragon. Tested moves are
* 1. Strategical attacks or defenses for the dragon.
* 2. Vital eye points for the dragon.
* 3. Tactical attacks or defenses for a part of the dragon.
* 4. Moves connecting the dragon to something else.
*/
static void
find_more_owl_attack_and_defense_moves(int color)
{
int pos, pos2;
int k;
int dd = NO_MOVE;
int worth_trying;
int save_verbose;
struct eye_data *our_eyes;
struct eye_data *your_eyes;
struct vital_eye_points *our_vital_points;
struct vital_eye_points *your_vital_points;
if (verbose)
gprintf("\nTrying to upgrade strategical attack and defense moves.\n");
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
if (!ON_BOARD(pos))
continue;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
do_find_more_owl_attack_and_defense_moves(color, pos,
move_reasons[r].type,
move_reasons[r].what);
}
}
if (verbose)
gprintf("\nTrying vital eye moves as owl attacks.\n");
if (color == WHITE) {
our_eyes = white_eye;
your_eyes = black_eye;
our_vital_points = white_vital_points;
your_vital_points = black_vital_points;
}
else {
our_eyes = black_eye;
your_eyes = white_eye;
our_vital_points = black_vital_points;
your_vital_points = white_vital_points;
}
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
if (!ON_BOARD(pos))
continue;
if (our_eyes[pos].origin == pos
&& our_vital_points[pos].defense_points[0] != NO_MOVE) {
int k, dr;
find_eye_dragons(pos, our_eyes, color, &dr, 1);
for (k = 0; k < MAX_EYE_ATTACKS; k++) {
int move = our_vital_points[pos].defense_points[k];
if (move == NO_MOVE)
break;
do_find_more_owl_attack_and_defense_moves(color, move,
VITAL_EYE_MOVE, dr);
}
}
if (your_eyes[pos].origin == pos
&& your_vital_points[pos].attack_points[0] != NO_MOVE) {
int k, dr;
find_eye_dragons(pos, your_eyes, OTHER_COLOR(color), &dr, 1);
for (k = 0; k < MAX_EYE_ATTACKS; k++) {
int move = your_vital_points[pos].attack_points[k];
if (move == NO_MOVE)
break;
do_find_more_owl_attack_and_defense_moves(color, move,
VITAL_EYE_MOVE, dr);
}
}
}
save_verbose = verbose;
if (verbose > 0)
verbose--;
/* If two critical dragons are adjacent, test whether a move to owl
* attack or defend one also is effective on the other.
*/
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
if (IS_STONE(board[pos])
&& dragon[pos].origin == pos
&& DRAGON2(pos).owl_status == CRITICAL) {
for (pos2 = BOARDMIN; pos2 < BOARDMAX; pos2++) {
if (board[pos2] != EMPTY)
continue;
worth_trying = 0;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos2].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == OWL_ATTACK_MOVE
|| move_reasons[r].type == OWL_ATTACK_MOVE_GOOD_KO
|| move_reasons[r].type == OWL_ATTACK_MOVE_BAD_KO
|| move_reasons[r].type == OWL_DEFEND_MOVE
|| move_reasons[r].type == OWL_DEFEND_MOVE_GOOD_KO
|| move_reasons[r].type == OWL_DEFEND_MOVE_BAD_KO) {
dd = move_reasons[r].what;
if (are_neighbor_dragons(dd, pos)) {
worth_trying = 1;
break;
}
}
/* else ...
FIXME: what about the new OWL_ATTACK_MOVE_GAIN codes ?
*/
}
if (worth_trying) {
if (board[pos] == color
&& !owl_defense_move_reason_known(pos2, pos)) {
int kworm = NO_MOVE;
int dcode = owl_does_defend(pos2, pos, &kworm);
if (dcode >= DRAGON2(pos).owl_defense_code) {
if (dcode == LOSS)
add_loss_move(pos2, pos, kworm);
else
add_owl_defense_move(pos2, pos, dcode);
if (save_verbose)
gprintf("Move at %1m also owl defends %1m (%s).\n",
pos2, pos, result_to_string(dcode));
}
}
else if (board[pos] != color
&& !owl_attack_move_reason_known(pos2, pos)) {
int kworm = NO_MOVE;
int acode = owl_does_attack(pos2, pos, &kworm);
if (acode >= DRAGON2(pos).owl_attack_code) {
add_owl_attack_move(pos2, pos, kworm, acode);
if (save_verbose)
gprintf("Move at %1m also owl attacks %1m (%s).\n",
pos2, pos, result_to_string(acode));
}
}
}
}
}
}
verbose = save_verbose;
}
/* Tests whether the potential semeai move at (pos) with details given via
* (*reason) works, and adds a semeai move if applicable.
*/
static void
try_potential_semeai_move(int pos, int color, struct move_reason *reason)
{
int dr1 = semeai_target1[reason->what];
int dr2 = semeai_target2[reason->what];
int resulta, resultb, certain, old_certain;
ASSERT1(IS_STONE(board[dr1]), pos);
switch (reason->type) {
case POTENTIAL_SEMEAI_ATTACK:
owl_analyze_semeai_after_move(pos, color, dr1, dr2,
&resulta, &resultb, NULL,
1, &certain, 0);
old_certain = DRAGON2(dr1).semeai_attack_certain;
break;
case POTENTIAL_SEMEAI_DEFENSE:
old_certain = DRAGON2(dr1).semeai_defense_certain;
/* In this case other dragon gets to move first after forced move. */
owl_analyze_semeai_after_move(pos, color, dr2, dr1,
&resulta, &resultb, NULL,
1, &certain, 0);
break;
default:
ASSERT1(0, pos);
}
if (resulta == 0 && resultb == 0
&& (certain || !old_certain)) {
add_semeai_move(pos, dr1);
DEBUG(DEBUG_SEMEAI,
"Potential semeai move at %1m for dragon at %1m is real\n",
pos, dr1);
}
else
DEBUG(DEBUG_MOVE_REASONS, "Potential semeai move at %1m for %1m discarded\n",
pos, dr1);
}
/* This functions tests all potential semeai attack moves whether they work,
* provided that there is at least one other move reasons stored for the
* relevant position.
*/
static void
find_more_semeai_moves(int color)
{
int pos;
int save_verbose = verbose;
if (verbose > 0)
verbose--;
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
int k, r;
int potential_semeai_move_found = 0;
int other_move_reason_found = 0;
if (!ON_BOARD1(pos))
continue;
for (k = 0; k < MAX_REASONS; k++) {
r = move[pos].reason[k];
if (r < 0)
break;
switch (move_reasons[r].type) {
case POTENTIAL_SEMEAI_ATTACK:
case POTENTIAL_SEMEAI_DEFENSE:
potential_semeai_move_found = 1;
break;
default:
other_move_reason_found = 1;
}
}
if ((r < 0 || k == MAX_REASONS)
&& !other_move_reason_found)
continue;
if (!potential_semeai_move_found)
continue;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == POTENTIAL_SEMEAI_ATTACK
|| move_reasons[r].type == POTENTIAL_SEMEAI_DEFENSE)
try_potential_semeai_move(pos, color, &(move_reasons[r]));
}
}
verbose = save_verbose;
}
/*
* Any move that captures or defends a worm also potentially connects
* or cuts the surrounding strings. Find these secondary move reasons
* and verify them by connection reading.
*
* We also let an owl attack count as a strategical defense of our
* neighbors of the owl attacked dragon. We only do this for
* tactically safe dragons, however, because otherwise the effects of
* capturing have already been taken into account elsewhere.
*
* Also, connecting moves played on inhibited points possibly remove
* nearby connection inhibitions like in following example :
*
* .OX. The * move connects _all_ O stones together, not only
* O... the 2 lower ones.
* XO*O
* X.X.
*
*/
static void
induce_secondary_move_reasons(int color)
{
int pos;
int k;
int i, j;
int aa;
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
if (!ON_BOARD(pos))
continue;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == ATTACK_MOVE
|| move_reasons[r].type == DEFEND_MOVE) {
int attack_move;
int color_to_move;
int num_adj, adjs[MAXCHAIN];
aa = move_reasons[r].what;
if (move_reasons[r].type == ATTACK_MOVE) {
attack_move = 1;
color_to_move = OTHER_COLOR(board[aa]);
}
else {
attack_move = 0;
color_to_move = board[aa];
}
if (worm[aa].defense_codes[0] == 0)
continue; /* No defense. */
/* Don't care about inessential dragons. */
if (DRAGON2(aa).safety == INESSENTIAL)
continue;
/*
* If this is a defense move and the defense is futile for
* strategical reasons, we shouldn't induce a cutting move
* reason.
*
* FIXME: We may want to revise this policy.
*/
if (!attack_move && !move[pos].move_safety)
continue;
num_adj = extended_chainlinks(aa, adjs, 1);
for (i = 0; i < num_adj; i++) {
for (j = i+1; j < num_adj; j++) {
int adj1 = adjs[i];
int adj2 = adjs[j];
if (board[adj1] != board[adj2])
continue;
if (attack_move
&& board[adj1] != board[aa]
&& !disconnect(adj1, adj2, NULL))
continue;
if (!attack_move
&& board[adj1] != board[aa]
&& !string_connect(adj1, adj2, NULL))
continue;
if (attack_move
&& board[adj1] == board[aa])
continue;
if (!attack_move
&& board[adj1] == board[aa]
&& !disconnect(adj1, adj2, NULL))
continue;
if (trymove(pos, color_to_move, "induce_secondary_move_reasons",
aa)) {
if (attack_move
&& board[adj1] != board[aa]
&& !disconnect(adj1, adj2, NULL)) {
popgo();
DEBUG(DEBUG_MOVE_REASONS,
"Connection move at %1m induced for %1m/%1m due to attack of %1m\n",
pos, adj1, adj2, aa);
add_connection_move(pos, adj1, adj2);
do_find_more_owl_attack_and_defense_moves(color, pos, CONNECT_MOVE,
find_connection(adj1, adj2));
}
else if (!attack_move
&& board[adj1] != board[aa]
&& !string_connect(adj1, adj2, NULL)) {
popgo();
DEBUG(DEBUG_MOVE_REASONS,
"Cut move at %1m induced for %1m/%1m due to defense of %1m\n",
pos, adj1, adj2, aa);
add_cut_move(pos, adj1, adj2);
}
else if (!attack_move
&& board[adj1] == board[aa]
&& !disconnect(adj1, adj2, NULL)) {
popgo();
DEBUG(DEBUG_MOVE_REASONS,
"Connection move at %1m induced for %1m/%1m due to defense of %1m\n",
pos, adj1, adj2, aa);
add_connection_move(pos, adj1, adj2);
do_find_more_owl_attack_and_defense_moves(color, pos, CONNECT_MOVE,
find_connection(adj1, adj2));
}
else
popgo();
}
}
}
/* Strategical attack move reason is induced for moves that
* defend neighbor strings of weak opponent dragons a. We
* only count strings that are large (more than three stones)
* or adjoin at least two non-dead non-single-stone opponent
* dragons.
*/
if (!attack_move) {
int strategically_valuable = (worm[aa].size > 3);
signed char neighbor_dragons[BOARDMAX];
memset(neighbor_dragons, 0, sizeof(neighbor_dragons));
if (!strategically_valuable) {
int num_dragons = 0;
for (i = 0; i < num_adj; i++) {
int origin = dragon[adjs[i]].origin;
if (board[origin] != color_to_move
&& neighbor_dragons[origin] != 1
&& dragon[origin].size > 1
&& dragon[origin].status != DEAD) {
if (++num_dragons == 2) {
strategically_valuable = 1;
break;
}
neighbor_dragons[origin] = 1;
}
}
}
if (strategically_valuable) {
for (i = 0; i < num_adj; i++) {
int origin = dragon[adjs[i]].origin;
if (board[origin] != color_to_move
&& neighbor_dragons[origin] != 2
&& dragon[origin].status != DEAD
&& dragon_weak(origin)) {
DEBUG(DEBUG_MOVE_REASONS,
"Strategical attack move at %1m induced for %1m due to defense of %1m\n",
pos, origin, aa);
add_strategical_attack_move(pos, origin);
do_find_more_owl_attack_and_defense_moves(color, pos,
STRATEGIC_ATTACK_MOVE,
origin);
neighbor_dragons[origin] = 2;
}
}
}
}
}
else if (move_reasons[r].type == OWL_ATTACK_MOVE) {
aa = move_reasons[r].what;
for (i = 0; i < DRAGON2(aa).neighbors; i++) {
int bb = dragon2[DRAGON2(aa).adjacent[i]].origin;
if (dragon[bb].color == color && worm[bb].attack_codes[0] == 0
&& !DRAGON2(bb).semeais) {
add_strategical_defense_move(pos, bb);
do_find_more_owl_attack_and_defense_moves(color, pos,
STRATEGIC_DEFEND_MOVE,
bb);
DEBUG(DEBUG_MOVE_REASONS, "Strategic defense at %1m induced for %1m due to owl attack on %1m\n",
pos, bb, aa);
}
}
}
else if (move_reasons[r].type == CONNECT_MOVE
&& cut_possible(pos, OTHER_COLOR(color))) {
int worm1 = conn_worm1[move_reasons[r].what];
int worm2 = conn_worm2[move_reasons[r].what];
int pos2;
for (pos2 = BOARDMIN; pos2 < BOARDMAX; pos2++) {
if (ON_BOARD(pos2) && board[pos2] == EMPTY
&& cut_possible(pos2, OTHER_COLOR(color))
&& square_dist(pos, pos2) <= 5) {
for (j = 0; j < 8; j++) {
int pos3 = pos2 + delta[j];
if (ON_BOARD(pos3) && board[pos3] == color
&& !is_same_worm(pos3, worm1)
&& !is_same_worm(pos3, worm2)) {
if (trymove(pos, color, "induce_secondary_move_reasons-B",
worm1)) {
int break1 = disconnect(pos3, worm1, NULL);
int break2 = disconnect(pos3, worm2, NULL);
popgo();
if (!break1) {
add_connection_move(pos, pos3, worm1);
do_find_more_owl_attack_and_defense_moves(color, pos, CONNECT_MOVE,
find_connection(pos3, worm1));
DEBUG(DEBUG_MOVE_REASONS, "Connection at %1m induced for %1m/%1m due to connection at %1m/%1m\n",
pos, worm1, worm2, pos3, worm1);
}
if (!break2) {
add_connection_move(pos, pos3, worm2);
do_find_more_owl_attack_and_defense_moves(color, pos, CONNECT_MOVE,
find_connection(pos3, worm2));
DEBUG(DEBUG_MOVE_REASONS, "Connection at %1m induced for %1m/%1m due to connection at %1m/%1m\n",
pos, worm1, worm2, pos3, worm2);
}
}
}
}
}
}
}
}
}
}
/* Examine the strategical and tactical safety of the moves. This is
* used to decide whether or not the stone should generate influence
* when the move is evaluated. The idea is to avoid overestimating the
* value of strategically unsafe defense moves and connections of dead
* dragons. This sets the move.move_safety field.
*/
static void
examine_move_safety(int color)
{
int pos;
int k;
start_timer(3);
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
int safety = 0;
int tactical_safety = 0;
if (!ON_BOARD(pos))
continue;
tactical_safety = is_known_safe_move(pos);
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
int type;
int what;
if (r == -1)
break;
type = move_reasons[r].type;
what = move_reasons[r].what;
switch (type) {
case CUT_MOVE:
/* We don't trust cut moves, unless some other move reason
* indicates they are safe.
*/
break;
case OWL_DEFEND_MOVE:
case OWL_DEFEND_MOVE_GOOD_KO:
case OWL_DEFEND_MOVE_BAD_KO:
case OWL_DEFEND_MOVE_LOSS:
{
int ii;
for (ii = first_worm_in_dragon(what); ii != NO_MOVE;
ii = next_worm_in_dragon(ii)) {
if (!play_connect_n(color, 0, 1, pos, ii, pos))
break;
}
if (ii != NO_MOVE) {
tactical_safety = 1;
safety = 1;
}
break;
}
case SEMEAI_MOVE:
case MY_ATARI_ATARI_MOVE:
case YOUR_ATARI_ATARI_MOVE:
case EITHER_MOVE: /* FIXME: More advanced handling? */
tactical_safety = 1;
safety = 1;
break;
case ALL_MOVE:
/* We don't trust these, unless some other move reason
* indicates safety.
*/
break;
case EXPAND_TERRITORY_MOVE:
case EXPAND_MOYO_MOVE:
case INVASION_MOVE: /* A real invasion should be safe.
A sacrifice is something else.*/
safety = 1;
break;
case ATTACK_MOVE:
case ATTACK_MOVE_GOOD_KO:
case ATTACK_MOVE_BAD_KO:
case OWL_ATTACK_MOVE:
case OWL_ATTACK_MOVE_GOOD_KO:
case OWL_ATTACK_MOVE_BAD_KO:
case OWL_ATTACK_MOVE_GAIN:
{
int aa = NO_MOVE;
int bb = NO_MOVE;
int size;
int m;
int our_color_neighbors;
if (type == ATTACK_MOVE
|| type == ATTACK_MOVE_GOOD_KO
|| type == ATTACK_MOVE_BAD_KO) {
aa = what;
size = worm[aa].effective_size;
}
else if (type == OWL_ATTACK_MOVE_GAIN) {
aa = either_data[what].what2;
size = worm[aa].effective_size;
}
else {
aa = what;
size = dragon[aa].effective_size;
}
/* No worries if we catch something big. */
if (size >= 8) {
tactical_safety = 1;
safety = 1;
break;
}
/* If the victim has multiple neighbor dragons of our
* color, we leave it to the connection move reason to
* determine safety.
*
* The exception is an owl_attack where we only require
* one neighbor to be alive.
*/
our_color_neighbors = 0;
if (type == ATTACK_MOVE
|| type == ATTACK_MOVE_GOOD_KO
|| type == ATTACK_MOVE_BAD_KO) {
/* We could use the same code as for OWL_ATTACK_MOVE
* below if we were certain that the capturable string
* had not been amalgamated with a living dragon.
*/
int num_adj, adjs[MAXCHAIN];
num_adj = chainlinks(aa, adjs);
for (m = 0; m < num_adj; m++) {
int adj = adjs[m];
if (board[adj] == color) {
/* Check whether this string is part of the same
* dragon as an earlier string. We only want to
* count distinct neighbor dragons.
*/
int n;
for (n = 0; n < m; n++)
if (dragon[adjs[n]].id == dragon[adj].id)
break;
if (n == m) {
/* New dragon. */
our_color_neighbors++;
bb = adj;
}
}
}
}
else {
for (m = 0; m < DRAGON2(aa).neighbors; m++)
if (DRAGON(DRAGON2(aa).adjacent[m]).color == color) {
our_color_neighbors++;
bb = dragon2[DRAGON2(aa).adjacent[m]].origin;
if (dragon[bb].status == ALIVE) {
tactical_safety = 1;
safety = 1;
}
}
}
if (our_color_neighbors > 1)
break;
/* It may happen in certain positions that no neighbor of
* our color is found. The working hypothesis is that
* the move is safe then. One example is a position like
*
* ----+
* OX.X|
* OOX.|
* OOX|
* OO|
*
* where the top right stone only has friendly neighbors
* but can be attacked.
*
* As a further improvement, we also look for a friendly
* dragon adjacent to the considered move.
*/
for (m = 0; m < 4; m++) {
int d = delta[m];
if (board[pos+d] == color) {
bb = pos + d;
break;
}
}
if (bb == NO_MOVE) {
tactical_safety = 1;
safety = 1;
break;
}
/* If the attacker is thought to be alive, we trust that
* sentiment.
*/
if (dragon[bb].status == ALIVE) {
tactical_safety = 1;
safety = 1;
break;
}
/* It remains the possibility that what we have captured
* is just a nakade shape. Ask the owl code whether this
* move saves our attacking dragon.
*
* FIXME: Might need to involve semeai code too here.
*/
if (owl_does_defend(pos, bb, NULL)) {
tactical_safety = 1;
safety = 1;
}
break;
}
case DEFEND_MOVE:
case DEFEND_MOVE_GOOD_KO:
case DEFEND_MOVE_BAD_KO:
{
int aa = what;
if (dragon[aa].status == ALIVE)
/* It would be better if this never happened, but it does
* sometimes. The owl reading can be very slow then.
*/
safety = 1;
else if (!play_connect_n(color, 0, 1, pos, aa, pos)
&& owl_does_defend(pos, aa, NULL))
safety = 1;
break;
}
case ATTACK_THREAT:
case DEFEND_THREAT:
break;
case CONNECT_MOVE:
{
int worm1 = conn_worm1[move_reasons[r].what];
int worm2 = conn_worm2[move_reasons[r].what];
int aa = dragon[worm1].origin;
int bb = dragon[worm2].origin;
if (aa == bb)
continue;
if (DRAGON2(aa).owl_status == ALIVE
|| DRAGON2(bb).owl_status == ALIVE) {
tactical_safety = 1;
safety = 1;
}
else if ((DRAGON2(aa).owl_status == UNCHECKED
&& dragon[aa].crude_status == ALIVE)
|| (DRAGON2(bb).owl_status == UNCHECKED
&& dragon[bb].crude_status == ALIVE)) {
tactical_safety = 1;
safety = 1;
}
else if (owl_connection_defends(pos, aa, bb)) {
tactical_safety = 1;
safety = 1;
}
break;
}
}
if (safety == 1 && (tactical_safety == 1 || safe_move(pos, color)))
break;
}
if (safety == 1 && (tactical_safety || safe_move(pos, color)))
move[pos].move_safety = 1;
else
move[pos].move_safety = 0;
time_report(3, " examine_move_safety: ", pos, 1.0);
}
}
/*
* Returns the pre-computed weakness of a dragon, with corrections
* according to ignore_dead_dragons.
*
* FIXME: Important to test more exactly how effective a strategical
* attack or defense of a weak dragon is. This can be done by
* measuring escape factor and moyo size after the move and
* compare with the old values. Also necessary to test whether
* an attack or defense of a critical dragon is effective.
* Notice that this wouldn't exactly go into this function but
* rather where it's called.
*/
float
dragon_weakness(int dr, int ignore_dead_dragons)
{
int dragon_safety = DRAGON2(dr).safety;
/* Kludge: If a dragon is dead, we return 1.0 in order not
* to try to run away.
*/
if (ignore_dead_dragons
&& (dragon_safety == DEAD
|| dragon_safety == INESSENTIAL
|| dragon_safety == TACTICALLY_DEAD))
return 0.0;
/* When scoring, we don't want to reinforce ALIVE dragons. */
if (doing_scoring && dragon_safety == ALIVE)
return 0.0;
return DRAGON2(dr).weakness;
}
/*
* Strategical value of connecting (or cutting) the dragon at (dragona)
* to the dragon at (dragonb). Notice that this function is asymmetric.
* This is because connection_value(a, b) is intended to measure the
* strategical value on the a dragon from a connection to the b dragon.
*
* Consider the following position:
* +---------+
* |XXO.O.OXX|
* |.XOOOOOX.|
* |XXXX.XXXX|
* |.XOOXOOX.|
* |XXO.X.O.X|
* |OOOXXXOOO|
* |..OOOOO..|
* |.........|
* +---------+
*
* X has three dragons, one invincible to the left (A), one critical to
* the right (B), and one dead in the center (C). The move at the cutting
* point has three move reasons:
* connect A and B
* connect A and C
* connect B and C
*
* The strategical value on A of either connection is of course zero,
* since it's very unconditionally alive. The strategical value on B is
* high when it's connected to A but small (at least should be) from the
* connection to C. Similarly for dragon C. In effect the total
* strategical value of this move is computed as:
*
* max(connection_value(A, B), connection_value(A, C))
* + max(connection_value(B, A), connection_value(B, C))
* + max(connection_value(C, A), connection_value(C, B))
*
* The parameter 'margin' is the margin by which we are ahead.
* If this exceeds 20 points we value connections more. This is because
* we can afford to waste a move making sure of safety.
*/
static float
connection_value(int dragona, int dragonb, int tt, float margin)
{
struct dragon_data2 *da = &DRAGON2(dragona);
struct dragon_data2 *db = &DRAGON2(dragonb);
float sizea = da->strategic_size;
float sizeb = db->strategic_size;
int safetya = da->safety;
int safetyb = db->safety;
float crude_weakness_a
= crude_dragon_weakness(da->safety, &da->genus, da->lunch != NO_MOVE,
da->moyo_territorial_value,
(float) da->escape_route);
float crude_weakness_sum;
struct eyevalue genus_sum;
float terr_val = move[tt].territorial_value;
float return_value;
if (margin > 20.0)
margin = 20.0;
/* When scoring, we want to be restrictive with reinforcement moves.
* Thus if both dragons are alive, strongly alive, or invincible, no
* bonus is awarded.
*
* FIXME: Shouldn't it be sufficient to check this for dragon a?
*/
if (doing_scoring) {
if ((safetya == ALIVE
|| safetya == STRONGLY_ALIVE
|| safetya == INVINCIBLE)
&& (safetyb == ALIVE
|| safetyb == STRONGLY_ALIVE
|| safetyb == INVINCIBLE))
return 0.0;
}
if (safetyb == INESSENTIAL)
return 0.0;
if (crude_weakness_a == 0.0
|| dragon[dragona].status == DEAD)
return 0.0;
if (terr_val < 0.0)
terr_val = 0.0;
add_eyevalues(&da->genus, &db->genus, &genus_sum);
/* FIXME: There is currently no sane way to take the escape values
* into account. Hence we simply pretend they do not change.
*
* FIXME: terr_val is a very crude approximation to the expected
* increase in moyo size. It's especially way off if the move at (tt)
* (owl) defends some stones.
*/
crude_weakness_sum
= crude_dragon_weakness(safetyb, &genus_sum,
(da->lunch != NO_MOVE || db->lunch != NO_MOVE),
da->moyo_territorial_value
+ db->moyo_territorial_value
+ terr_val,
(float) da->escape_route);
/* Kludge: For a CRITICAL dragon, we use the usual effective
* size and give a strategic effect bigger than 2.0 * effective size.
* This is to match the "strategic bonus computation" in
* estimate_strategical_value(). This prefers connection moves that
* owl defend a dragon to other owl defense move.
*/
if (dragon[dragona].status == CRITICAL) {
float bonus = (0.4 - 0.3 * crude_weakness_sum) * sizea;
if (bonus < 0.0)
bonus = 0.0;
/* If ahead, give extra bonus to connections. */
if (margin > 0.0 && bonus > 0.0)
bonus *= 1.0 + 0.05 * margin;
return_value = 2.0 * sizea + bonus;
}
else {
float old_burden = 2.0 * crude_weakness_a * soft_cap(sizea, 15.0);
/* The new burden is the burden of defending new joint dragon; but
* we share this burden proportionally with the other dragon.
*/
float new_burden = 2.0 * crude_weakness_sum * soft_cap(sizea + sizeb, 15.0)
* sizea / (sizea + sizeb);
return_value = 1.05 * (old_burden - new_burden);
/* If ahead, give extra bonus to connections. */
if (margin > 0.0)
return_value *= 1.0 + 0.02 * margin;
}
if (return_value < 0.0)
return_value = 0.0;
return return_value;
}
/*
* This function computes the shape factor, which multiplies
* the score of a move. We take the largest positive contribution
* to shape and add 1 for each additional positive contribution found.
* Then we take the largest negative contribution to shape, and
* add 1 for each additional negative contribution. The resulting
* number is raised to the power 1.05.
*
* The rationale behind this complicated scheme is that every
* shape point is very significant. If two shape contributions
* with values (say) 5 and 3 are found, the second contribution
* should be devalued to 1. Otherwise the engine is too difficult to
* tune since finding multiple contributions to shape can cause
* significant overvaluing of a move.
*/
static float
compute_shape_factor(int pos)
{
float exponent = move[pos].maxpos_shape - move[pos].maxneg_shape;
ASSERT_ON_BOARD1(pos);
if (move[pos].numpos_shape > 1)
exponent += move[pos].numpos_shape - 1;
if (move[pos].numneg_shape > 1)
exponent -= move[pos].numneg_shape - 1;
return pow(1.05, exponent);
}
/*
* Usually the value of attacking a worm is twice its effective size,
* but when evaluating certain move reasons we need to adjust this to
* take effects on neighbors into account, e.g. for an attack_either
* move reason. This does not apply to the attack and defense move
* reasons, however, because then the neighbors already have separate
* attack or defense move reasons (if such apply).
*
* If the worm has an adjacent (friendly) dead dragon we add its
* value. At least one of the surrounding dragons must be alive.
* If not, the worm must produce an eye of sufficient size, and that
* should't be accounted for here. As a guess, we suppose that
* a critical dragon is alive for our purpose here.
*
* On the other hand if it has an adjacent critical worm, and
* if (pos) does not defend that worm, we subtract the value of the
* worm, since (pos) may be defended by attacking that worm. We make at
* most one adjustment of each type.
*/
static float
adjusted_worm_attack_value(int pos, int ww)
{
int num_adj;
int adjs[MAXCHAIN];
int has_live_neighbor = 0;
float adjusted_value = 2 * worm[ww].effective_size;
float adjustment_up = 0.0;
float adjustment_down = 0.0;
int s;
num_adj = chainlinks(ww, adjs);
for (s = 0; s < num_adj; s++) {
int adj = adjs[s];
if (dragon[adj].status != DEAD)
has_live_neighbor = 1;
if (dragon[adj].status == DEAD
&& 2*dragon[adj].effective_size > adjustment_up)
adjustment_up = 2*dragon[adj].effective_size;
if (worm[adj].attack_codes[0] != 0
&& !does_defend(pos, adj)
&& 2*worm[adj].effective_size > adjustment_down)
adjustment_down = 2*worm[adj].effective_size;
}
if (has_live_neighbor)
adjusted_value += adjustment_up;
adjusted_value -= adjustment_down;
/* It can happen that the adjustment down was larger than the effective
* size we started with. In this case we simply return 0.0. (This means
* we ignore the respective EITHER_MOVE reason.)
*/
if (adjusted_value > 0.0)
return adjusted_value;
else
return 0.0;
}
/* The new (3.2) territorial evaluation overvalues moves creating a new
* group in the opponent's sphere of influence. The influence module cannot
* see that the opponent will gain by attacking the new (probably weak)
* group.
* This function uses some heuristics to estimate the strategic penalty
* of invasion moves, and moves that try to run away with a group of size
* 1 in front of opponent's strength.
*/
static float
strategic_penalty(int pos, int color)
{
int k;
float ret_val;
/* We try to detect support from an alive friendly stone by checking
* whether all neighboring intersections belong to the opponent's moyo.
*/
for (k = 0; k < 4; k++)
if (board[pos + delta[k]] == EMPTY
&& whose_area(OPPOSITE_INFLUENCE(color), pos + delta[k])
!= OTHER_COLOR(color))
return 0.0;
if (whose_area(OPPOSITE_INFLUENCE(color), pos) != OTHER_COLOR(color))
return 0.0;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
/* We assume that invasion moves can only have the move reasons listed
* below.
*
* FIXME: EXPAND_TERRITORY should always be connected to our own
* stones. Remove later when that change is done.
*/
switch (move_reasons[r].type) {
#if 0
case EXPAND_TERRITORY_MOVE:
#endif
case EXPAND_MOYO_MOVE:
case STRATEGIC_ATTACK_MOVE:
case INVASION_MOVE:
continue;
/* If we find a tactical defense move, we just test whether it concerns
* a single-stone-dragon; if not, we stop, if yes, we let the necessary
* tests be made in the OWL_DEFEND_MOVE case.
*/
case DEFEND_MOVE:
{
int target = move_reasons[r].what;
if (dragon[target].size > 1)
return 0.0;
continue;
}
/* An owl defense of a single stone might be a stupid attempt to run
* away with an unimportant (kikashi like) stone. We assume this is the
* case if this single stone has a strong hostile direct neighbor.
*/
case OWL_DEFEND_MOVE:
{
int target = move_reasons[r].what;
int has_strong_neighbor = 0;
int has_weak_neighbor = 0;
int i;
/* We award no penalty for running away with a cutting stone. */
if (dragon[target].size > 1
|| worm[target].cutstone > 0
|| worm[target].cutstone2 > 0)
return 0.0;
/* Third line moves (or lower) are ok -- they try to live, not run
* away.
*/
if (edge_distance(pos) < 3)
return 0.0;
for (i = 0; i < 4; i++)
if (board[target + delta[i]] == OTHER_COLOR(color)) {
if (dragon[target + delta[i]].size == 1) {
has_weak_neighbor = 1;
break;
}
switch (DRAGON2(target + delta[i]).safety) {
case INVINCIBLE:
case STRONGLY_ALIVE:
has_strong_neighbor = 1;
break;
case ALIVE:
if (DRAGON2(target + delta[i]).weakness > 0.4)
has_weak_neighbor = 1;
break;
default:
has_weak_neighbor = 1;
}
}
if (has_weak_neighbor || (!has_strong_neighbor))
return 0.0;
else
continue;
}
default:
return 0.0;
}
}
/* We have to make a guess how much the point where we want to play
* is dominated by the opponent. The territorial valuation is a
* good try here.
*/
ret_val = influence_territory(INITIAL_INFLUENCE(OTHER_COLOR(color)),
pos, OTHER_COLOR(color));
ret_val *= 12.0;
ret_val = gg_max(0.0, ret_val);
return ret_val;
}
/* True if pos is adjacent to a nondead stone of the given color. This
* function can be called when stackp>0 but the result is given for
* the position when stackp==0. It also checks for nondead stones two
* steps away from pos if a move by color at pos cannot be cut off
* from that stone.
*
* FIXME: Move this somewhere more generally accessible, probably
* utils.c
*/
int
adjacent_to_nondead_stone(int pos, int color)
{
int k;
int stack[MAXSTACK];
int move_color[MAXSTACK];
int saved_stackp = stackp;
int result = 0;
while (stackp > 0) {
get_move_from_stack(stackp - 1, &stack[stackp - 1],
&move_color[stackp - 1]);
popgo();
}
if (trymove(pos, color, NULL, EMPTY)) {
for (k = 0; k < 12; k++) {
int pos2;
if (k < 8)
pos2 = pos + delta[k];
else if (ON_BOARD(pos + delta[k - 8]))
pos2 = pos + 2 * delta[k - 8];
else
continue;
if (ON_BOARD(pos2)
&& worm[pos2].color == color
&& dragon[pos2].status != DEAD
&& !disconnect(pos, pos2, NULL)) {
result = 1;
break;
}
}
popgo();
}
while (stackp < saved_stackp)
tryko(stack[stackp], move_color[stackp], NULL);
return result;
}
static int
max_lunch_eye_value(int pos)
{
int min;
int probable;
int max;
estimate_lunch_eye_value(pos, &min, &probable, &max, 0);
return max;
}
/*
* Estimate the direct territorial value of a move at (pos) by (color).
*/
static void
estimate_territorial_value(int pos, int color, float our_score,
int disable_delta_territory_cache)
{
int other = OTHER_COLOR(color);
int k;
int aa = NO_MOVE;
int bb = NO_MOVE;
float this_value = 0.0;
float tot_value = 0.0;
float secondary_value = 0.0;
int does_block = 0;
signed char safe_stones[BOARDMAX];
float strength[BOARDMAX];
set_strength_data(OTHER_COLOR(color), safe_stones, strength);
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].status & TERRITORY_REDUNDANT)
continue;
this_value = 0.0;
switch (move_reasons[r].type) {
case ATTACK_MOVE:
case ATTACK_MOVE_GOOD_KO:
case ATTACK_MOVE_BAD_KO:
aa = move_reasons[r].what;
ASSERT1(board[aa] != color, aa);
/* Defenseless stone. */
if (worm[aa].defense_codes[0] == 0) {
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f (secondary) - attack on %1m (defenseless)\n",
pos, worm[aa].effective_size, aa);
secondary_value += worm[aa].effective_size;
does_block = 1;
break;
}
this_value = 2 * worm[aa].effective_size;
/* If the stones are dead, there is only a secondary value in
* capturing them tactically as well.
*/
if (dragon[aa].status == DEAD) {
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f (secondary) - attack on %1m (dead)\n",
pos, 0.2 * this_value, aa);
secondary_value += 0.2 * this_value;
does_block = 1;
break;
}
/* Mark the string as captured, for evaluation in the influence code. */
mark_changed_string(aa, safe_stones, strength, 0);
TRACE(" %1m: attack on worm %1m\n", pos, aa);
/* FIXME: How much should we reduce the value for ko attacks? */
if (move_reasons[r].type == ATTACK_MOVE)
this_value = 0.0;
else if (move_reasons[r].type == ATTACK_MOVE_GOOD_KO) {
this_value *= 0.3;
TRACE(" %1m: -%f - attack on worm %1m only with good ko\n",
pos, this_value, aa);
}
else if (move_reasons[r].type == ATTACK_MOVE_BAD_KO) {
this_value *= 0.5;
TRACE(" %1m: -%f - attack on worm %1m only with bad ko\n",
pos, this_value, aa);
}
tot_value -= this_value;
does_block = 1;
break;
case DEFEND_MOVE:
case DEFEND_MOVE_GOOD_KO:
case DEFEND_MOVE_BAD_KO:
aa = move_reasons[r].what;
ASSERT1(board[aa] == color, aa);
/*
* Estimate value
*/
this_value = 2 * worm[aa].effective_size;
/* If the stones are dead, we use the convention that
* defending them has a strategical value rather than
* territorial. Admittedly this make more sense for attacks on
* dead stones.
*/
if (dragon[aa].status == DEAD) {
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f (secondary) - defense of %1m (dead)\n",
pos, 0.2 * this_value, aa);
secondary_value += 0.2 * this_value;
break;
}
if (DRAGON2(aa).owl_status == CRITICAL
&& (owl_defense_move_reason_known(pos, aa)
< defense_move_reason_known(pos, aa))
&& !semeai_move_reason_known(pos, aa)) {
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f (secondary) - ineffective defense of %1m (critical)\n",
pos, 0.2 * this_value, aa);
secondary_value += 0.2 * this_value;
break;
}
/* Mark the string as saved, for evaluation in the influence code. */
mark_changed_string(aa, safe_stones, strength, INFLUENCE_SAVED_STONE);
TRACE(" %1m: defense of worm %1m\n", pos, aa);
/* FIXME: How much should we reduce the value for ko defenses? */
if (move_reasons[r].type == DEFEND_MOVE)
this_value = 0.0;
else if (move_reasons[r].type == DEFEND_MOVE_GOOD_KO) {
this_value *= 0.3;
TRACE(" %1m: -%f - defense of worm %1m with good ko\n",
pos, this_value, aa);
}
else if (move_reasons[r].type == DEFEND_MOVE_BAD_KO) {
this_value *= 0.5;
TRACE(" %1m: -%f - defense of worm %1m with bad ko\n",
pos, this_value, aa);
}
tot_value -= this_value;
/* If a move tactically defends an owl critical string, but
* this move is not listed as an owl defense, it probably is
* ineffective. The 0.45 factor is chosen so that even in
* combination with bad ko it still has a positive net impact.
*/
if (DRAGON2(aa).owl_status == CRITICAL
&& (owl_defense_move_reason_known(pos, aa)
< defense_move_reason_known(pos, aa))) {
this_value = 0.45 * (2 * worm[aa].effective_size);
TRACE(" %1m: -%f - suspected ineffective defense of worm %1m\n",
pos, this_value, aa);
tot_value -= this_value;
}
does_block = 1;
break;
case ATTACK_THREAT:
aa = move_reasons[r].what;
/* Make sure this is a threat to attack opponent stones. */
ASSERT1(board[aa] == other, aa);
if (dragon[aa].status == DEAD) {
DEBUG(DEBUG_MOVE_REASONS,
" %1m: 0.0 - threatens to capture %1m (dead)\n", pos, aa);
break;
}
/* The followup value of a move threatening to attack (aa)
* is twice its effective size, with adjustments. If the
* worm has an adjacent (friendly) dead dragon we add its
* value. On the other hand if it has an adjacent critical
* worm, and if (pos) does not defend that worm, we subtract
* the value of the worm, since (aa) may be defended by
* attacking that worm. We make at most one adjustment
* of each type.
*
* No followup value is awarded if the defense move is a threat
* back on our move because we're likely to end in gote then,
* unless the move is unsafe anyway and played as a ko threat.
*
* FIXME: It might be possible that parts of the dragon
* can be cut in the process of capturing the (aa)
* worm. In that case, not the entire size of the
* adjacent dead dragon should be counted as a positive
* adjustment. However, it seems difficult to do this
* analysis, and in most cases it won't apply, so we
* leave it as it is for now.
*
* FIXME: The same analysis should be applied to
* DEFEND_THREAT,
* ATTACK_EITHER_MOVE, DEFEND_BOTH_MOVE. It should be
* broken out as separate functions and dealt with in
* a structured manner.
*/
if (trymove(pos, color, "estimate_territorial_value-A", NO_MOVE)) {
int adjs[MAXCHAIN];
float adjusted_value = 2 * worm[aa].effective_size;
float adjustment_up = 0.0;
float adjustment_down = 0.0;
int s;
int num_adj;
int defense_move;
/* In rare cases it may happen that the trymove() above
* actually removed the string at aa.
*/
if (board[aa] == EMPTY)
num_adj = 0;
else
num_adj = chainlinks(aa, adjs);
/* No followup value if string can be defended with threat
* against our move. An exception to this is when our move
* isn't safe anyway and we play this only for the followup
* value, typically as a ko threat. Though, "suspicious" owl
* defenses (move_safety != 1) are still tested for possible
* backfires.
*
* This rule may be overwritten with patterns. See pattern
* Sente22 and related test trevord:950 for an example.
*
* FIXME: This is somewhat halfhearted since only one defense
* move is tested.
*/
if (!is_known_good_attack_threat(pos, aa)
&& board[aa] != EMPTY
&& (move[pos].move_safety == 1
|| adjacent_to_nondead_stone(pos, color)
|| owl_defense_move_reason_known(pos, -1))
&& find_defense(aa, &defense_move) == WIN
&& defense_move != NO_MOVE) {
int bad_followup;
int attack_move;
if (attack(pos, &attack_move) != WIN) {
int i;
if (trymove(defense_move, other,
"estimate_territorial_value-b", NO_MOVE)) {
if (board[pos] == EMPTY || attack(pos, NULL) != 0) {
popgo();
popgo();
break;
}
/* Now check all `ATTACK_MOVE' reasons for this same
* move. If the defense against current threat makes a
* string attacked by this move defendable, we reduce
* the followup.
*
* Adjustments done later are concerned with current
* dragon states. Here we actually try to check if
* opponent's reply to our move will have a followup in
* turn.
*/
for (i = 0; i < MAX_REASONS; i++) {
int reason = move[pos].reason[i];
int attacked_string;
if (reason < 0)
break;
attacked_string = move_reasons[reason].what;
if (move_reasons[reason].type == ATTACK_MOVE
&& board[attacked_string] == other) {
int defense_code = find_defense(attacked_string, NULL);
double down_coefficient = 0.0;
switch (defense_code) {
case WIN:
down_coefficient = 2.0;
break;
case KO_A:
down_coefficient = 2.0 * 0.5;
break;
case KO_B:
down_coefficient = 2.0 * 0.7;
break;
}
if (adjustment_down
< (worm[attacked_string].effective_size
* down_coefficient)) {
adjustment_down = (worm[attacked_string].effective_size
* down_coefficient);
}
}
}
popgo();
}
}
else {
/* Our move is attackable to begin with. However, maybe
* the attack is not sufficient to defend opponent's
* string?
*/
if (trymove(attack_move, other,
"estimate_territorial_value-c", NO_MOVE)) {
if (attack(aa, NULL) == 0) {
/* It is sufficient, no followup. */
popgo();
popgo();
break;
}
popgo();
}
/* Heuristically reduce the followup, since our string
* will be still attackable if opponent defends his
* string.
*/
adjustment_down = 2 * countstones(pos);
}
bad_followup = 0;
for (s = 0; s < num_adj; s++) {
int lib;
if (countlib(adjs[s]) == 1) {
findlib(adjs[s], 1, &lib);
if (trymove(lib, other,
"estimate_territorial_value-d", NO_MOVE)) {
if (!attack(aa, NULL)
&& (board[pos] == EMPTY || attack(pos, NULL) != 0)) {
popgo();
bad_followup = 1;
break;
}
popgo();
}
}
}
if (bad_followup) {
popgo();
break;
}
}
for (s = 0; s < num_adj; s++) {
int adj = adjs[s];
if (same_string(pos, adj))
continue;
if (dragon[adj].color == color
&& dragon[adj].status == DEAD
&& 2*dragon[adj].effective_size > adjustment_up)
adjustment_up = 2*dragon[adj].effective_size;
if (dragon[adj].color == color
&& attack(adj, NULL)
&& 2*worm[adj].effective_size > adjustment_down)
adjustment_down = 2*worm[adj].effective_size;
}
popgo();
/* No followup if the string is not substantial. */
{
int save_verbose = verbose;
if (verbose > 0)
verbose --;
if (move[pos].move_safety == 0
&& !owl_substantial(aa)) {
verbose = save_verbose;
break;
}
verbose = save_verbose;
}
adjusted_value += adjustment_up;
adjusted_value -= adjustment_down;
if (adjusted_value > 0.0) {
add_followup_value(pos, adjusted_value);
TRACE(" %1m: %f (followup) - threatens to capture %1m\n",
pos, adjusted_value, aa);
}
}
break;
case DEFEND_THREAT:
aa = move_reasons[r].what;
/* Make sure this is a threat to defend our stones. */
ASSERT1(board[aa] == color, aa);
/* We don't trust tactical defense threats as ko threats, unless
* the move is safe.
*/
if (move[pos].move_safety == 0)
break;
/* No followup value if string can be attacked with threat
* against our move. An exception to this is when our move
* isn't safe anyway and we play this only for the followup
* value, typically as a ko threat.
*
* FIXME: This is somewhat halfhearted since only one attack
* move is tested.
*/
if (trymove(pos, color, "estimate_territorial_value-A", NO_MOVE)) {
int attack_move;
if (move[pos].move_safety == 1
&& attack(aa, &attack_move) == WIN
&& attack_move != NO_MOVE) {
if (trymove(attack_move, other,
"estimate_territorial_value-b", NO_MOVE)) {
if (board[pos] == EMPTY || attack(pos, NULL) != 0) {
popgo();
popgo();
break;
}
popgo();
}
}
popgo();
}
add_followup_value(pos, 2 * worm[aa].effective_size);
TRACE(" %1m: %f (followup) - threatens to defend %1m\n",
pos, 2 * worm[aa].effective_size, aa);
break;
case UNCERTAIN_OWL_DEFENSE:
/* This move reason is valued as a strategical value. */
break;
case CUT_MOVE:
case EXPAND_MOYO_MOVE:
case EXPAND_TERRITORY_MOVE:
case INVASION_MOVE:
does_block = 1;
break;
case CONNECT_MOVE:
/* This used to always set does_block=1, but there is no
* guarantee that a connection move is strategically safe. See
* for example gunnar:72.
*/
if (move[pos].move_safety)
does_block = 1;
break;
case STRATEGIC_ATTACK_MOVE:
case STRATEGIC_DEFEND_MOVE:
/* Do not trust these when we are scoring. Maybe we shouldn't
* trust them otherwise either but require them to be
* accompanied by e.g. an EXPAND move reason.
*/
if (!doing_scoring)
does_block = 1;
break;
case SEMEAI_THREAT:
aa = move_reasons[r].what;
/* threaten to win the semeai as a ko threat */
add_followup_value(pos, 2 * dragon[aa].effective_size);
TRACE(" %1m: %f (followup) - threatens to win semeai for %1m\n",
pos, 2 * dragon[aa].effective_size, aa);
break;
case SEMEAI_MOVE:
case OWL_ATTACK_MOVE:
case OWL_ATTACK_MOVE_GOOD_KO:
case OWL_ATTACK_MOVE_BAD_KO:
case OWL_ATTACK_MOVE_GAIN:
case OWL_DEFEND_MOVE:
case OWL_DEFEND_MOVE_GOOD_KO:
case OWL_DEFEND_MOVE_BAD_KO:
case OWL_DEFEND_MOVE_LOSS:
if (move_reasons[r].type == OWL_ATTACK_MOVE_GAIN
|| move_reasons[r].type == OWL_DEFEND_MOVE_LOSS) {
aa = either_data[move_reasons[r].what].what1;
bb = either_data[move_reasons[r].what].what2;
}
else {
aa = move_reasons[r].what;
bb = NO_MOVE;
}
/* If the dragon is a single ko stone, the owl code currently
* won't detect that the owl attack is conditional. As a
* workaround we deduct 0.5 points for the move here, but only
* if the move is a liberty of the string.
*/
if (dragon[aa].size == 1
&& is_ko_point(aa)
&& liberty_of_string(pos, aa)) {
TRACE(" %1m: -0.5 - penalty for ko stone %1m (workaround)\n",
pos, aa);
tot_value -= 0.5;
}
/* Mark the affected dragon for use in the territory analysis. */
mark_changed_dragon(pos, color, aa, bb, move_reasons[r].type,
safe_stones, strength, &this_value);
this_value *= 2.0;
TRACE(" %1m: owl attack/defend for %1m\n", pos, aa);
/* FIXME: How much should we reduce the value for ko attacks? */
if (move_reasons[r].type == OWL_ATTACK_MOVE
|| move_reasons[r].type == OWL_DEFEND_MOVE
|| move_reasons[r].type == SEMEAI_MOVE)
this_value = 0.0;
else if (move_reasons[r].type == OWL_ATTACK_MOVE_GOOD_KO
|| move_reasons[r].type == OWL_DEFEND_MOVE_GOOD_KO) {
this_value *= 0.3;
TRACE(" %1m: -%f - owl attack/defense of %1m only with good ko\n",
pos, this_value, aa);
}
else if (move_reasons[r].type == OWL_ATTACK_MOVE_BAD_KO
|| move_reasons[r].type == OWL_DEFEND_MOVE_BAD_KO) {
this_value *= 0.5;
TRACE(" %1m: -%f - owl attack/defense of %1m only with bad ko\n",
pos, this_value, aa);
}
else if (move_reasons[r].type == OWL_ATTACK_MOVE_GAIN
|| move_reasons[r].type == OWL_DEFEND_MOVE_LOSS) {
this_value = 0.0;
}
tot_value -= this_value;
/* If the dragon is a single string which can be tactically
* attacked, but this owl attack does not attack tactically, it
* can be suspected to leave some unnecessary aji or even be an
* owl misread. Therefore we give it a small penalty to favor
* the moves which do attack tactically as well.
*
* One example is manyfaces:2 where the single stone S15 can be
* tactically attacked at S16 but where 3.3.2 finds additional
* owl attacks at R14 (clearly ineffective) and T15 (might work,
* but leaves huge amounts of aji).
*/
if ((move_reasons[r].type == OWL_ATTACK_MOVE
|| move_reasons[r].type == OWL_ATTACK_MOVE_GOOD_KO
|| move_reasons[r].type == OWL_ATTACK_MOVE_BAD_KO)
&& dragon[aa].size == worm[aa].size
&& worm[aa].attack_codes[0] == WIN
&& worm[aa].defense_codes[0] != 0
&& attack_move_reason_known(pos, aa) != WIN) {
if (large_scale)
this_value = (2.0 + 0.05 * (2 * worm[aa].effective_size));
else
this_value = 0.05 * (2 * worm[aa].effective_size);
TRACE(" %1m: -%f - suspected ineffective owl attack of worm %1m\n",
pos, this_value, aa);
tot_value -= this_value;
}
does_block = 1;
break;
case OWL_ATTACK_THREAT:
aa = move_reasons[r].what;
if (dragon[aa].status == DEAD) {
DEBUG(DEBUG_MOVE_REASONS,
" %1m: 0.0 - threatens to owl attack %1m (dead)\n", pos, aa);
break;
}
/* The followup value of a move threatening to attack (aa) is
* twice its effective size, unless it has an adjacent
* (friendly) critical dragon. In that case it's probably a
* mistake to make the threat since it can defend itself with
* profit.
*
* FIXME: We probably need to verify that the critical dragon is
* substantial enough that capturing it saves the threatened
* dragon.
*/
{
float value = 2 * dragon[aa].effective_size;
int s;
for (s = 0; s < DRAGON2(aa).neighbors; s++) {
int d = DRAGON2(aa).adjacent[s];
int adj = dragon2[d].origin;
if (dragon[adj].color == color
&& dragon[adj].status == CRITICAL
&& dragon2[d].safety != INESSENTIAL
&& !owl_defense_move_reason_known(pos, adj))
value = 0.0;
}
if (value > 0.0) {
add_followup_value(pos, value);
TRACE(" %1m: %f (followup) - threatens to owl attack %1m\n",
pos, value, aa);
}
}
break;
case OWL_DEFEND_THREAT:
aa = move_reasons[r].what;
add_followup_value(pos, 2 * dragon[aa].effective_size);
TRACE(" %1m: %f (followup) - threatens to owl defend %1m\n",
pos, 2 * dragon[aa].effective_size, aa);
break;
case OWL_PREVENT_THREAT:
/* A move attacking a dragon whose defense can be threatened.
*/
aa = move_reasons[r].what;
if (dragon[aa].status != DEAD) {
DEBUG(DEBUG_MOVE_REASONS,
" %1m: 0.0 - prevent defense threat (dragon is not dead)\n",
pos);
break;
}
/* If the opponent just added a stone to a dead dragon, then
* attack it. If we are ahead, add a safety move here, at most
* half the margin of victory.
*
* This does not apply if we are doing scoring.
*/
if (!doing_scoring
&& is_same_dragon(get_last_opponent_move(color), aa)) {
this_value = 1.5 * dragon[aa].effective_size;
TRACE(" %1m: %f - attack last move played, although it seems dead\n",
pos, this_value);
tot_value += this_value * attack_dragon_weight;
}
else if (!doing_scoring && our_score > 0.0) {
/* tm - devalued this bonus (3.1.17) */
this_value = gg_min(0.9 * dragon[aa].effective_size,
our_score/2.0 - board_size/2.0 - 1.0);
this_value = gg_max(this_value, 0);
TRACE(" %1m: %f - attack %1m, although it seems dead, as we are ahead\n",
pos, this_value, aa);
tot_value += this_value * attack_dragon_weight;
}
else {
add_reverse_followup_value(pos, 2 * dragon[aa].effective_size);
if (board[aa] == color)
TRACE(" %1m: %f (reverse followup) - prevent threat to attack %1m\n",
pos, 2 * dragon[aa].effective_size, aa);
else
TRACE(" %1m: %f (reverse followup) - prevent threat to defend %1m\n",
pos, 2 * dragon[aa].effective_size, aa);
}
break;
case MY_ATARI_ATARI_MOVE:
/* Add 1.0 to compensate for -1.0 penalty because the move is
* thought to be a sacrifice.
*/
this_value = move_reasons[r].what + 1.0;
tot_value += this_value;
TRACE(" %1m: %f - combination attack kills one of several worms\n",
pos, this_value);
break;
case YOUR_ATARI_ATARI_MOVE:
/* Set does_block to force territorial valuation of the move.
* That way we can prefer defenses against combination attacks
* on dame points instead of inside territory.
*/
does_block = 1;
this_value = move_reasons[r].what;
tot_value += this_value;
TRACE(" %1m: %f - defends against combination attack on several worms\n",
pos, this_value);
break;
}
}
/* Currently no difference in the valuation between blocking and
* expanding moves.
*/
this_value = 0.0;
mark_inessential_stones(OTHER_COLOR(color), safe_stones);
if (move[pos].move_safety == 1
&& (is_known_safe_move(pos) || safe_move(pos, color) != 0)) {
safe_stones[pos] = INFLUENCE_SAVED_STONE;
strength[pos] = DEFAULT_STRENGTH;
if (0)
TRACE(" %1m: is a safe move\n", pos);
}
else {
TRACE(" %1m: not a safe move\n", pos);
safe_stones[pos] = 0;
strength[pos] = 0.0;
}
/* We don't check for move safety here. This enables a territorial
* evaluation for sacrifice moves that enable a break-through (or
* an owl defense).
*/
if (does_block
&& tryko(pos, color, "estimate_territorial_value")) {
Hash_data safety_hash = goal_to_hashvalue(safe_stones);
if (disable_delta_territory_cache
|| !retrieve_delta_territory_cache(pos, color, &this_value,
&move[pos].influence_followup_value,
OPPOSITE_INFLUENCE(color),
safety_hash)) {
compute_influence(OTHER_COLOR(color), safe_stones, strength,
&move_influence, pos, "after move");
increase_depth_values();
break_territories(OTHER_COLOR(color), &move_influence, 0, pos);
decrease_depth_values();
this_value = influence_delta_territory(OPPOSITE_INFLUENCE(color),
&move_influence, color, pos);
compute_followup_influence(&move_influence, &followup_influence,
pos, "followup");
if (this_value != 0.0)
TRACE("%1m: %f - change in territory\n", pos, this_value);
else
DEBUG(DEBUG_MOVE_REASONS, "%1m: 0.00 - change in territory\n", pos);
move[pos].influence_followup_value
= influence_delta_territory(&move_influence, &followup_influence,
color, pos);
store_delta_territory_cache(pos, color, this_value,
move[pos].influence_followup_value,
OPPOSITE_INFLUENCE(color), safety_hash);
}
else {
if (this_value != 0.0)
TRACE("%1m: %f - change in territory (cached)\n", pos, this_value);
else
DEBUG(DEBUG_MOVE_REASONS,
"%1m: 0.00 - change in territory (cached)\n", pos);
}
popgo();
}
tot_value += this_value;
/* Test if min_territory or max_territory values constrain the
* delta_territory value.
*/
if (tot_value < move[pos].min_territory
&& move[pos].min_territory > 0) {
tot_value = move[pos].min_territory;
TRACE(" %1m: %f - revised to meet minimum territory value\n",
pos, tot_value);
}
if (tot_value > move[pos].max_territory) {
tot_value = move[pos].max_territory;
TRACE(" %1m: %f - revised to meet maximum territory value\n",
pos, tot_value);
}
move[pos].territorial_value = tot_value;
move[pos].secondary_value += secondary_value;
}
/*
* Estimate the strategical value of a move at (pos).
*/
static void
estimate_strategical_value(int pos, int color, float our_score,
int use_thrashing_dragon_heuristics)
{
int k;
int l;
int aa = NO_MOVE;
int bb = NO_MOVE;
float aa_value = 0.0;
float bb_value = 0.0;
float this_value = 0.0;
float tot_value = 0.0;
/* Strategical value of connecting or cutting dragons. */
float dragon_value[BOARDMAX];
for (aa = BOARDMIN; aa < BOARDMAX; aa++)
dragon_value[aa] = 0.0;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].status & STRATEGICALLY_REDUNDANT)
continue;
this_value = 0.0;
switch (move_reasons[r].type) {
case ATTACK_MOVE:
case ATTACK_MOVE_GOOD_KO:
case ATTACK_MOVE_BAD_KO:
case DEFEND_MOVE:
case DEFEND_MOVE_GOOD_KO:
case DEFEND_MOVE_BAD_KO:
aa = move_reasons[r].what;
/* Defenseless stone */
if (worm[aa].defense_codes[0] == 0)
break;
if (doing_scoring && dragon[aa].status == DEAD)
break;
/* FIXME: This is totally ad hoc, just guessing the value of
* potential cutting points.
* FIXME: When worm[aa].cutstone2 == 1 we should probably add
* a followup value.
*/
if (worm[aa].cutstone2 > 1 && !worm[aa].inessential) {
double ko_factor = 1;
if (move_reasons[r].type == ATTACK_MOVE_GOOD_KO
|| move_reasons[r].type == DEFEND_MOVE_GOOD_KO) {
ko_factor = 0.6;
}
else if (move_reasons[r].type == ATTACK_MOVE_BAD_KO
|| move_reasons[r].type == DEFEND_MOVE_BAD_KO) {
ko_factor = 0.4;
}
this_value = 10.0 * (worm[aa].cutstone2 - 1) * ko_factor;
TRACE(" %1m: %f - %1m cutstone\n", pos, this_value, aa);
}
tot_value += this_value;
/* If the string is a lunch for a weak dragon, the attack or
* defense has a strategical value. This can be valued along
* the same lines as strategic_attack/strategic_defend.
*
* No points are awarded if the lunch is an inessential dragon
* or worm.
*/
if (DRAGON2(aa).safety == INESSENTIAL
|| worm[aa].inessential)
break;
/* If the lunch has no potential to create eyes, no points. */
if (max_lunch_eye_value(aa) == 0)
break;
/* Can't use k in this loop too. */
for (l = 0; l < next_lunch; l++)
if (lunch_worm[l] == aa) {
bb = lunch_dragon[l];
/* FIXME: This value cannot be computed without some measurement
* of how the actual move affects the dragon. The dragon safety
* alone is not enough. The question is whether the dragon is
* threatened or defended by the move or not.
*/
this_value = 1.8 * soft_cap(DRAGON2(bb).strategic_size, 15.0)
* dragon_weakness(bb, 0);
/* If this dragon consists of only one worm and that worm
* can be tactically captured or defended by this move, we
* have already counted the points as territorial value,
* unless it's assumed to be dead.
*/
if (dragon[bb].status != DEAD
&& dragon[bb].size == worm[bb].size
&& (attack_move_reason_known(pos, bb)
|| defense_move_reason_known(pos, bb)))
this_value = 0.0;
/* If this dragon can be tactically attacked and the move
* does not defend or attack, no points.
*/
if (worm[bb].attack_codes[0] != 0
&& ((color == board[bb] && !does_defend(pos, bb))
|| (color == OTHER_COLOR(board[bb])
&& !does_attack(pos, bb))))
this_value = 0.0;
/* If we are doing scoring, are alive, and the move loses
* territory, no points.
*/
if (doing_scoring
&& move[pos].territorial_value < 0.0
&& (DRAGON2(bb).safety == ALIVE
|| DRAGON2(bb).safety == STRONGLY_ALIVE
|| DRAGON2(bb).safety == INVINCIBLE))
this_value = 0.0;
if (this_value > dragon_value[bb]) {
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f - %1m attacked/defended\n",
pos, this_value, bb);
dragon_value[bb] = this_value;
}
}
break;
case ATTACK_THREAT:
case DEFEND_THREAT:
break;
case EITHER_MOVE:
/* FIXME: Generalize this to more types of threats. */
/* FIXME: We need a policy if a move has several EITHER_MOVE
* reasons. Most likely not all of them can be achieved.
*/
aa = either_data[move_reasons[r].what].what1;
bb = either_data[move_reasons[r].what].what2;
/* If both worms are dead, this move reason has no value. */
if (dragon[aa].status == DEAD
&& dragon[bb].status == DEAD)
break;
/* Also if there is a combination attack, we assume it covers
* the same thing.
* FIXME: This is only applicable as long as the only moves
* handled by EITHER_MOVE are attacks.
*/
if (move_reason_known(pos, MY_ATARI_ATARI_MOVE, -1))
break;
aa_value = adjusted_worm_attack_value(pos, aa);
bb_value = adjusted_worm_attack_value(pos, bb);
this_value = gg_min(aa_value, bb_value);
TRACE(" %1m: %f - either attacks %1m (%f) or attacks %1m (%f)\n",
pos, this_value, aa, aa_value, bb, bb_value);
tot_value += this_value;
break;
case ALL_MOVE:
/* FIXME: Generalize this to more types of threats. */
aa = all_data[move_reasons[r].what].what1;
bb = all_data[move_reasons[r].what].what2;
/* If both worms are dead, this move reason has no value. */
if (dragon[aa].status == DEAD
&& dragon[bb].status == DEAD)
break;
/* Also if there is a combination attack, we assume it covers
* the same thing.
*/
if (move_reason_known(pos, YOUR_ATARI_ATARI_MOVE, -1))
break;
aa_value = worm[aa].effective_size;
bb_value = worm[bb].effective_size;
this_value = 2 * gg_min(aa_value, bb_value);
TRACE(" %1m: %f - both defends %1m (%f) and defends %1m (%f)\n",
pos, this_value, aa, aa_value, bb, bb_value);
tot_value += this_value;
break;
case CONNECT_MOVE:
/* If the opponent just added a stone to a dead dragon, which is
* adjacent to both dragons being connected, then the connection
* is probably a good way to make sure the thrashing dragon
* stays dead. If we are ahead, add a safety move here, at most
* half the margin of victory.
*
* This does only apply if we decided earlier we want to use
* thrashing dragon heuristics.
*/
if (use_thrashing_dragon_heuristics) {
int cc;
aa = dragon[conn_worm1[move_reasons[r].what]].origin;
bb = dragon[conn_worm2[move_reasons[r].what]].origin;
cc = get_last_opponent_move(color);
if (cc != NO_MOVE
&& thrashing_stone[cc]
&& are_neighbor_dragons(aa, cc)
&& are_neighbor_dragons(bb, cc)) {
if (aa == bb)
this_value = 1.6 * DRAGON2(cc).strategic_size;
else if (DRAGON2(aa).safety == INESSENTIAL
|| DRAGON2(bb).safety == INESSENTIAL) {
if ((DRAGON2(aa).safety == INESSENTIAL
&& max_lunch_eye_value(aa) == 0)
|| (DRAGON2(bb).safety == INESSENTIAL
&& max_lunch_eye_value(bb) == 0))
this_value = 0.0;
else
this_value = 0.8 * DRAGON2(cc).strategic_size;
}
else
this_value = 1.7 * DRAGON2(cc).strategic_size;
if (this_value > dragon_value[dragon[cc].origin]) {
dragon_value[dragon[cc].origin] = this_value;
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f - connect %1m and %1m to attack thrashing dragon %1m\n",
pos, this_value, aa, bb, cc);
}
}
}
if (!move[pos].move_safety)
break;
/* Otherwise fall through. */
case CUT_MOVE:
if (doing_scoring && !move[pos].move_safety)
break;
aa = dragon[conn_worm1[move_reasons[r].what]].origin;
bb = dragon[conn_worm2[move_reasons[r].what]].origin;
if (aa == bb)
continue;
/* If we are ahead by more than 20, value connections more strongly */
if (our_score > 20.0)
this_value = connection_value(aa, bb, pos, our_score);
else
this_value = connection_value(aa, bb, pos, 0);
if (this_value > dragon_value[aa]) {
dragon_value[aa] = this_value;
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f - %1m cut/connect strategic value\n",
pos, this_value, aa);
}
if (our_score > 20.0)
this_value = connection_value(bb, aa, pos, our_score);
else
this_value = connection_value(bb, aa, pos, 0);
if (this_value > dragon_value[bb]) {
dragon_value[bb] = this_value;
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f - %1m cut/connect strategic value\n",
pos, this_value, bb);
}
break;
case SEMEAI_MOVE:
/*
* The strategical value of winning a semeai is
* own dragons (usually) becomes fully secure, while adjoining
* enemy dragons do not.
*
* FIXME: Valuation not implemented at all yet.
*/
break;
case STRATEGIC_ATTACK_MOVE:
case STRATEGIC_DEFEND_MOVE:
/* The right way to do this is to estimate the safety of the
* dragon before and after the move. Unfortunately we are
* missing good ways to do this currently.
*
* Temporary solution is to only look at an ad hoc measure of
* the dragon safety and ignoring the effectiveness of the
* move.
*
* FIXME: Improve the implementation.
*/
aa = move_reasons[r].what;
/* FIXME: This value cannot be computed without some
* measurement of how the actual move affects the dragon. The
* dragon safety alone is not enough. The question is whether
* the dragon is threatened by the move or not.
*/
if (use_thrashing_dragon_heuristics
&& thrashing_stone[aa])
this_value = 1.7 * DRAGON2(aa).strategic_size;
else
this_value = 1.8 * soft_cap(DRAGON2(aa).strategic_size, 15.0)
* dragon_weakness(aa, 1);
/* No strategical attack value is awarded if the dragon at (aa)
* has an adjacent (friendly) critical dragon, which is not
* defended by this move. In that case it's probably a mistake
* to make the strategical attack since the dragon can defend
* itself with profit.
*
* FIXME: We probably need to verify that the critical dragon is
* substantial enough that capturing it saves the strategically
* attacked dragon.
*/
if (move_reasons[r].type == STRATEGIC_ATTACK_MOVE) {
int s;
for (s = 0; s < DRAGON2(aa).neighbors; s++) {
int d = DRAGON2(aa).adjacent[s];
int adj = dragon2[d].origin;
if (dragon[adj].color == color
&& dragon[adj].status == CRITICAL
&& dragon2[d].safety != INESSENTIAL
&& !owl_defense_move_reason_known(pos, adj))
this_value = 0.0;
}
}
/* Multiply by attack_dragon_weight to try to find a best fit */
this_value = this_value * attack_dragon_weight;
if (this_value > dragon_value[aa]) {
dragon_value[aa] = this_value;
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f - %1m strategic attack/defend\n",
pos, this_value, aa);
}
break;
case UNCERTAIN_OWL_DEFENSE:
aa = move_reasons[r].what;
/* If there is an adjacent dragon which is critical we should
* skip this type of move reason, since attacking or defending
* the critical dragon is more urgent.
*/
{
int d;
int found_one = 0;
for (d = 0; d < DRAGON2(aa).neighbors; d++)
if (DRAGON(DRAGON2(aa).adjacent[d]).status == CRITICAL)
found_one = 1;
if (found_one)
break;
}
/* If we are behind, we should skip this type of move reason.
* If we are ahead, we should value it more.
*/
if (our_score < 0.0)
this_value = 0.0;
else
this_value = gg_min(2*DRAGON2(aa).strategic_size, 0.65*our_score);
if (this_value > dragon_value[aa]) {
dragon_value[aa] = this_value;
DEBUG(DEBUG_MOVE_REASONS,
" %1m: %f - %1m uncertain owl defense bonus\n",
pos, this_value, aa);
}
break;
}
}
for (aa = BOARDMIN; aa < BOARDMAX; aa++) {
if (dragon_value[aa] == 0.0)
continue;
ASSERT1(dragon[aa].origin == aa, aa);
/* If this dragon is critical but not attacked/defended by this
* move, we ignore the strategic effect.
*/
if (dragon[aa].status == CRITICAL
&& !owl_move_reason_known(pos, aa)) {
DEBUG(DEBUG_MOVE_REASONS, " %1m: 0.0 - disregarding strategic effect on %1m (critical dragon)\n",
pos, aa);
continue;
}
/* If this dragon consists of only one worm and that worm can
* be tactically captured or defended by this move, we have
* already counted the points as territorial value, unless
* it's assumed to be dead.
* However, we still allow strategical excess value (see below)
* in case the effective_size is substantially bigger (by 2.0)
* than the actualy size.
*/
if (dragon[aa].status != DEAD
&& dragon[aa].size == worm[aa].size
&& worm[aa].effective_size < worm[aa].size + 2.0
&& (attack_move_reason_known(pos, aa)
|| defense_move_reason_known(pos, aa))) {
TRACE(" %1m: %f - %1m strategic value already counted - A.\n",
pos, dragon_value[aa], aa);
continue;
}
/* If the dragon has been owl captured, owl defended, or involved
* in a semeai, we have likewise already counted the points as
* territorial value.
*/
if (attack_move_reason_known(pos, aa)
|| defense_move_reason_known(pos, aa)
|| (owl_move_reason_known(pos, aa)
&& dragon[aa].status == CRITICAL)
|| move_reason_known(pos, SEMEAI_MOVE, aa)) {
/* But if the strategical value was larger than the territorial
* value (e.g. because connecting to strong dragon) we award the
* excess value as a bonus.
*/
float excess_value = (dragon_value[aa] -
2 * DRAGON2(aa).strategic_size);
if (excess_value > 0.0) {
TRACE(" %1m: %f - strategic bonus for %1m\n", pos, excess_value, aa);
tot_value += excess_value;
}
else {
TRACE(" %1m: %f - %1m strategic value already counted - B.\n",
pos, dragon_value[aa], aa);
}
continue;
}
TRACE(" %1m: %f - strategic effect on %1m\n",
pos, dragon_value[aa], aa);
tot_value += dragon_value[aa];
}
/* Finally, subtract penalty for invasion type moves. */
this_value = strategic_penalty(pos, color);
/* Multiply by invasion_malus_weight to allow us to fit the weight */
this_value = this_value * invasion_malus_weight;
if (this_value > 0.0) {
TRACE(" %1m: %f - strategic penalty, considered as invasion.\n",
pos, -this_value);
tot_value -= this_value;
}
move[pos].strategical_value = tot_value;
}
/* Compare two move reasons, used for sorting before presentation. */
static int
compare_move_reasons(const void *p1, const void *p2)
{
const int mr1 = *(const int *) p1;
const int mr2 = *(const int *) p2;
if (move_reasons[mr1].type != move_reasons[mr2].type)
return move_reasons[mr2].type - move_reasons[mr1].type;
else
return move_reasons[mr2].what - move_reasons[mr1].what;
}
/*
* Combine the reasons for a move at (pos) into a simple numerical value.
* These heuristics are now somewhat less ad hoc than before but probably
* still need a lot of improvement.
*/
static float
value_move_reasons(int pos, int color, float pure_threat_value,
float our_score, int use_thrashing_dragon_heuristics)
{
float tot_value;
float shape_factor;
gg_assert(stackp == 0);
/* Is it an antisuji? */
if (is_antisuji_move(pos))
return 0.0; /* This move must not be played. End of story. */
/* Never play on a vertex which is unconditional territory for
* either player. There is absolutely nothing to gain.
*/
if (worm[pos].unconditional_status != UNKNOWN)
return 0.0;
/* If this move has no reason at all, we can skip some steps. */
if (move[pos].reason[0] >= 0
|| move[pos].min_territory > 0.0) {
int num_reasons;
/* Sort the move reasons. This makes it easier to visually compare
* the reasons for different moves in the trace outputs.
*/
num_reasons = 0;
while (move[pos].reason[num_reasons] >= 0 && num_reasons < MAX_REASONS)
num_reasons++;
gg_sort(move[pos].reason, num_reasons, sizeof(move[pos].reason[0]),
compare_move_reasons);
/* Discard move reasons that only duplicate another. */
discard_redundant_move_reasons(pos);
/* Estimate the value of various aspects of the move. The order
* is significant. Territorial value must be computed before
* strategical value. See connection_value().
*/
estimate_territorial_value(pos, color, our_score, 0);
estimate_strategical_value(pos, color, our_score,
use_thrashing_dragon_heuristics);
}
/* Introduction of strategical_weight and territorial_weight,
* for automatic fitting. (3.5.1)
*/
tot_value = territorial_weight * move[pos].territorial_value +
strategical_weight * move[pos].strategical_value;
shape_factor = compute_shape_factor(pos);
if (tot_value > 0.0) {
int c;
float followup_value;
/* Negative territorial followup doesn't make make sense. */
if (move[pos].influence_followup_value < 0.0)
move[pos].influence_followup_value = 0.0;
followup_value = move[pos].followup_value
+ move[pos].influence_followup_value;
TRACE(" %1m: %f - total followup value, added %f as territorial followup\n",
pos, followup_value, move[pos].influence_followup_value);
/* In the endgame, there are a few situations where the value can
* be 0 points + followup. But we want to take the intersections first
* were we actually get some points. 0.5 points is a 1 point ko which
* is the smallest value that is actually worth something.
*/
if (tot_value >= 0.5) {
float old_tot_value = tot_value;
float contribution;
/* We adjust the value according to followup and reverse followup
* values.
*/
contribution = gg_min(gg_min(0.5 * followup_value
+ 0.5 * move[pos].reverse_followup_value,
1.0 * tot_value
+ followup_value),
1.1 * tot_value
+ move[pos].reverse_followup_value);
tot_value += contribution * followup_weight;
/* The first case applies to gote vs gote situation, the
* second to reverse sente, and the third to sente situations.
* The usual rule is that a sente move should count at double
* value. But if we have a 1 point move with big followup (i.e.
* sente) we want to play that before a 2 point gote move. Hence
* the factor 1.1 above.
*/
if (contribution != 0.0) {
TRACE(" %1m: %f - added due to followup (%f) and reverse followup values (%f)\n",
pos, contribution, followup_value,
move[pos].reverse_followup_value);
}
/* If a ko fight is going on, we should use the full followup
* and reverse followup values in the total value. We save the
* additional contribution for later access.
*/
move[pos].additional_ko_value =
followup_value
+ move[pos].reverse_followup_value
- (tot_value - old_tot_value);
/* Not sure whether this could happen, but check for safety. */
if (move[pos].additional_ko_value < 0.0)
move[pos].additional_ko_value = 0.0;
}
else {
move[pos].additional_ko_value =
shape_factor * (move[pos].followup_value
+ move[pos].reverse_followup_value);
}
tot_value += soft_cap(0.05 * move[pos].secondary_value, 0.4);
if (move[pos].secondary_value != 0.0)
TRACE(" %1m: %f - secondary\n", pos,
soft_cap(0.05 * move[pos].secondary_value, 0.4));
if (move[pos].numpos_shape + move[pos].numneg_shape > 0) {
/* shape_factor has already been computed. */
float old_value = tot_value;
/* Maximum 15 points of the territorial value will be weighted by shape_factor */
if (move[pos].territorial_value < 15)
tot_value *= shape_factor;
else {
float non_shape_val = move[pos].territorial_value - 15;
tot_value = (tot_value - non_shape_val) * shape_factor + non_shape_val;
}
if (verbose) {
/* Should all have been TRACE, except we want field sizes. */
gprintf(" %1m: %f - shape ", pos, tot_value - old_value);
fprintf(stderr,
"(shape values +%4.2f(%d) -%4.2f(%d), shape factor %5.3f)\n",
move[pos].maxpos_shape, move[pos].numpos_shape,
move[pos].maxneg_shape, move[pos].numneg_shape,
shape_factor);
}
}
/* Add a special shape bonus for moves which connect own strings
* or cut opponent strings.
*/
c = (move_connects_strings(pos, color, 1)
+ move_connects_strings(pos, OTHER_COLOR(color), 0));
if (c > 0) {
float shape_factor2 = pow(1.02, (float) c) - 1;
float base_value = gg_max(gg_min(tot_value, 5.0), 1.0);
if (verbose) {
/* Should all have been TRACE, except we want field sizes. */
gprintf(" %1m: %f - connects strings ", pos,
base_value * shape_factor2);
fprintf(stderr, "(connect value %d, shape factor %5.3f)\n", c,
shape_factor2);
}
tot_value += base_value * shape_factor2;
}
/* Dame points which have a cut or connect move reason get a small
* extra bonus because these have a tendency to actually be worth
* a point.
*/
if (tot_value < 0.3
&& (move_reason_known(pos, CONNECT_MOVE, -1)
|| move_reason_known(pos, CUT_MOVE, -1))) {
float old_tot_value = tot_value;
tot_value = gg_min(0.3, tot_value + 0.1);
TRACE(" %1m: %f - cut/connect dame bonus\n", pos,
tot_value - old_tot_value);
}
}
else {
move[pos].additional_ko_value =
shape_factor * (move[pos].followup_value +
gg_min(move[pos].followup_value,
move[pos].reverse_followup_value));
}
/* If the move is valued 0 or small, but has followup values and is
* flagged as a worthwhile threat, add up to pure_threat_value to
* the move.
*
* FIXME: We shouldn't have to call confirm_safety() here. It's
* potentially too expensive.
*/
if (pure_threat_value > 0.0
&& move[pos].worthwhile_threat
&& tot_value <= pure_threat_value
&& board[pos] == EMPTY
&& move[pos].additional_ko_value > 0.0
&& is_legal(pos, color)
&& value_moves_confirm_safety(pos, color)) {
float new_tot_value = gg_min(pure_threat_value,
tot_value
+ 0.25 * move[pos].additional_ko_value);
/* Make sure that moves with independent value are preferred over
* those without.
*/
new_tot_value *= (1.0 - 0.1 * (pure_threat_value - tot_value)
/ pure_threat_value);
if (new_tot_value > tot_value) {
TRACE(" %1m: %f - carry out threat or defend against threat\n",
pos, new_tot_value - tot_value);
tot_value = new_tot_value;
}
}
/* min_value is now subject to reduction with a fitted weight (3.5.1) */
move[pos].min_value = move[pos].min_value * minimum_value_weight;
move[pos].max_value = move[pos].max_value * maximum_value_weight;
/* Test if min_value or max_value values constrain the total value.
* First avoid contradictions between min_value and max_value,
* assuming that min_value is right.
*/
if (move[pos].min_value > move[pos].max_value)
move[pos].max_value = move[pos].min_value;
/* If several moves have an identical minimum value, then GNU Go uses the
* following secondary criterion (unless min_value and max_value agree, and
* unless min_value is bigger than 25, in which case it probably comes from
* a J or U pattern):
*/
if (move[pos].min_value < 25)
move[pos].min_value += tot_value / 200;
if (tot_value < move[pos].min_value
&& move[pos].min_value > 0) {
tot_value = move[pos].min_value;
TRACE(" %1m: %f - minimum accepted value\n", pos, tot_value);
}
if (tot_value > move[pos].max_value) {
tot_value = move[pos].max_value;
TRACE(" %1m: %f - maximum accepted value\n",
pos, tot_value);
}
if (tot_value > 0
|| move[pos].territorial_value > 0
|| move[pos].strategical_value > 0) {
TRACE("Move generation values %1m to %f\n", pos, tot_value);
move_considered(pos, tot_value);
}
return tot_value;
}
/*
* Loop over all possible moves and value the move reasons for each.
*/
static void
value_moves(int color, float pure_threat_value, float our_score,
int use_thrashing_dragon_heuristics)
{
int m, n;
int pos;
TRACE("\nMove valuation:\n");
/* Visit the moves in the standard lexicographical order */
for (n = 0; n < board_size; n++)
for (m = board_size-1; m >= 0; m--) {
pos = POS(m, n);
move[pos].value = value_move_reasons(pos, color,
pure_threat_value, our_score,
use_thrashing_dragon_heuristics);
if (move[pos].value == 0.0)
continue;
/* Maybe this test should be performed elsewhere. This is just
* to get some extra safety. We don't filter out illegal ko
* captures here though, because if that is the best move, we
* should reevaluate ko threats.
*/
if (is_legal(pos, color) || is_illegal_ko_capture(pos, color)) {
/* Add a random number between 0 and 0.01 to use in comparisons. */
move[pos].value +=
0.01 * move[pos].random_number * move[pos].randomness_scaling;
}
else {
move[pos].value = 0.0;
TRACE("Move at %1m wasn't legal.\n", pos);
}
}
}
/* Print the values of all moves with values bigger than zero. */
void
print_all_move_values(FILE *output)
{
int pos;
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
if (!ON_BOARD(pos) || move[pos].final_value <= 0.0)
continue;
gfprintf(output, "%1M %f\n", pos, move[pos].final_value);
}
}
/* Search through all board positions for the 10 highest valued
* moves and print them.
*/
static void
print_top_moves(void)
{
int k;
int pos;
float tval;
for (k = 0; k < 10; k++) {
best_moves[k] = NO_MOVE;
best_move_values[k] = 0.0;
}
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
if (!ON_BOARD(pos) || move[pos].final_value <= 0.0)
continue;
tval = move[pos].final_value;
record_top_move(pos, tval);
}
if (verbose > 0 || (debug & DEBUG_TOP_MOVES)) {
gprintf("\nTop moves:\n");
for (k = 0; k < 10 && best_move_values[k] > 0.0; k++)
gprintf("%d. %1M %f\n", k+1, best_moves[k], best_move_values[k]);
}
}
/* Add a move to the list of top moves (if it is among the top ten) */
void
record_top_move(int pos, float val)
{
int k;
for (k = 9; k >= 0; k--)
if (val > best_move_values[k]) {
if (k < 9) {
best_move_values[k+1] = best_move_values[k];
best_moves[k+1] = best_moves[k];
}
best_move_values[k] = val;
best_moves[k] = pos;
}
move[pos].final_value = val;
}
/* remove a rejected move from the list of top moves */
void
remove_top_move(int move)
{
int k;
for (k = 0; k < 10; k++) {
if (best_moves[k] == move) {
int l;
for (l = k; l < 9; l++) {
best_moves[l] = best_moves[l+1];
best_move_values[l] = best_move_values[l+1];
}
best_moves[9] = NO_MOVE;
best_move_values[9] = 0.0;
}
}
}
/* This function is called if the biggest move on board was an illegal
* ko capture.
*/
static void
reevaluate_ko_threats(int ko_move, int color, float ko_value)
{
int ko_stone = NO_MOVE;
int opp_ko_move;
int pos;
int k;
int type, what;
int threat_does_work = 0;
int ko_move_target;
int num_good_threats = 0;
int good_threats[BOARDMAX];
int best_threat_quality = -1;
float threat_size;
ko_move_target = get_biggest_owl_target(ko_move);
/* If the move is a simple ko recapture, find the ko stone. (If
* it's not a simple ko recapture, then the move must be a superko
* violation.)
*/
if (is_illegal_ko_capture(ko_move, color)) {
for (k = 0; k <= 3; k++) {
ko_stone = ko_move + delta[k];
if (ON_BOARD(ko_stone) && countlib(ko_stone) == 1)
break;
}
ASSERT_ON_BOARD1(ko_stone);
}
TRACE("Reevaluating ko threats.\n");
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
int threat_quality = 0;
if (!ON_BOARD(pos) || pos == ko_move)
continue;
if (move[pos].additional_ko_value <= 0.0)
continue;
/* Otherwise we look for the biggest threat, and then check whether
* it still works after ko has been resolved.
*/
/* `additional_ko_value' includes reverse followup. While it is good to
* play ko threats which eliminate other threats in turn, we should
* always prefer threats that are larger than the value of the ko.
*/
if (move[pos].followup_value < ko_value)
threat_quality = -1;
threat_size = 0.0;
type = -1;
what = -1;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (!(move_reasons[r].type & THREAT_BIT))
continue;
switch (move_reasons[r].type) {
case ATTACK_THREAT:
case DEFEND_THREAT:
if (worm[move_reasons[r].what].effective_size
> threat_size) {
threat_size = worm[move_reasons[r].what].effective_size;
type = move_reasons[r].type;
what = move_reasons[r].what;
}
break;
case OWL_ATTACK_THREAT:
case OWL_DEFEND_THREAT:
case SEMEAI_THREAT:
if (dragon[move_reasons[r].what].effective_size
> threat_size) {
threat_size = dragon[move_reasons[r].what]\
.effective_size;
type = move_reasons[r].type;
what = move_reasons[r].what;
}
break;
default:
/* This means probably someone has introduced a new threat type
* without adding the corresponding case above.
*/
gg_assert(0);
break;
}
}
/* If there is no threat recorded, the followup value is probably
* contributed by a pattern. We can do nothing but accept this value.
* (although this does cause problems).
*
* FIXME: In the case of superko violation we have no ko_stone.
* Presumably some of the tests below should be applicable anyway.
* Currently we just say that any threat is ok.
*/
if (type == -1 || ko_stone == NO_MOVE)
threat_does_work = 1;
else {
if (trymove(pos, color, "reevaluate_ko_threats", ko_move)) {
ASSERT_ON_BOARD1(ko_stone);
if (!find_defense(ko_stone, &opp_ko_move))
threat_does_work = 1;
else {
int threat_wastes_point = 0;
if (whose_area(OPPOSITE_INFLUENCE(color), pos) != EMPTY)
threat_wastes_point = 1;
if (trymove(opp_ko_move, OTHER_COLOR(color),
"reevaluate_ko_threats", ko_move)) {
switch (type) {
case ATTACK_THREAT:
/* In case the attack threat was a snapback move, there
* is no stone on the board to attack now and we check
* for a defense of the threatening move instead.
*/
if (board[what] != EMPTY)
threat_does_work = attack(what, NULL);
else
threat_does_work = find_defense(pos, NULL);
break;
case DEFEND_THREAT:
threat_does_work = (board[what] != EMPTY
&& find_defense(what, NULL));
break;
case OWL_ATTACK_THREAT:
case OWL_DEFEND_THREAT:
/* Should we call do_owl_attack/defense here?
* Maybe too expensive? For the moment we just assume
* that the attack does not work if it concerns the
* same dragon as ko_move. (Can this really happen?)
*/
threat_does_work = (ko_move_target != what);
}
popgo();
/* Is this a losing ko threat? */
if (threat_does_work && type == ATTACK_THREAT) {
int apos;
if (attack(pos, &apos)
&& does_defend(apos, what)
&& (forced_backfilling_moves[apos]
|| (!is_proper_eye_space(apos)
&& !false_eye_territory[apos]))) {
threat_does_work = 0;
}
}
/* If we are fighting a tiny ko (1 - 2 points only), we pay
* extra attention to select threats that don't waste points.
* In particular, we don't play threats inside of opponent
* territory if they can be averted on a dame intersection.
*/
if (ko_value < 1.0
&& threat_does_work
&& threat_quality >= 0
&& (type == ATTACK_THREAT || type == DEFEND_THREAT)) {
int averting_pos;
if (type == ATTACK_THREAT)
find_defense(what, &averting_pos);
else
attack(what, &averting_pos);
/* `averting_pos' can be NO_MOVE sometimes, at least when
* when the the threat is a threat to attack. It is not
* clear what to do in such cases.
*/
if (averting_pos != NO_MOVE) {
int averting_wastes_point = 0;
if (whose_territory(OPPOSITE_INFLUENCE(color), averting_pos)
!= EMPTY)
averting_wastes_point = 1;
threat_quality = averting_wastes_point - threat_wastes_point;
if (threat_quality < 0)
threat_does_work = 0;
}
}
}
}
popgo();
}
}
if (threat_does_work) {
if (threat_quality == best_threat_quality)
good_threats[num_good_threats++] = pos;
else if (threat_quality > best_threat_quality) {
best_threat_quality = threat_quality;
num_good_threats = 0;
good_threats[num_good_threats++] = pos;
}
else
DEBUG(DEBUG_MOVE_REASONS,
"%1m: no additional ko value (threat does not work as ko threat)\n", pos);
}
}
for (k = 0; k < num_good_threats; k++) {
pos = good_threats[k];
/* If the move previously had no value, we need to add in the
* randomness contribution now.
*
* FIXME: This is very ugly. Restructure the code so that the
* randomness need only be considered in one place.
*/
if (move[pos].value == 0.0) {
move[pos].value +=
0.01 * move[pos].random_number * move[pos].randomness_scaling;
}
TRACE("%1m: %f + %f = %f\n", pos, move[pos].value,
move[pos].additional_ko_value,
move[pos].value + move[pos].additional_ko_value);
move[pos].value += move[pos].additional_ko_value;
}
}
/* Redistribute points. When one move is declared a replacement for
* another by a replacement move reason, the move values for the
* inferior move are transferred to the replacement.
*/
static void
redistribute_points(void)
{
int source;
int target;
for (target = BOARDMIN; target < BOARDMAX; target++)
if (ON_BOARD(target))
move[target].final_value = move[target].value;
for (source = BOARDMIN; source < BOARDMAX; source++) {
if (!ON_BOARD(source))
continue;
target = replacement_map[source];
if (target == NO_MOVE)
continue;
TRACE("Redistributing points from %1m to %1m.\n", source, target);
if (move[target].final_value < move[source].final_value) {
TRACE("%1m is now valued %f.\n", target, move[source].final_value);
move[target].final_value = move[source].final_value;
}
TRACE("%1m is now valued 0.\n", source);
move[source].final_value = 0.0;
}
}
/* This selects the best move available according to their valuations.
* If the best move is an illegal ko capture, we add ko threat values.
* If the best move is a blunder, it gets devalued and continue to look
* for the best move.
*/
static int
find_best_move(int *the_move, float *value, int color,
int allowed_moves[BOARDMAX])
{
int good_move_found = 0;
signed char blunder_tested[BOARDMAX];
float best_value = 0.0;
int best_move = NO_MOVE;
int pos;
memset(blunder_tested, 0, sizeof(blunder_tested));
while (!good_move_found) {
best_value = 0.0;
best_move = NO_MOVE;
/* Search through all board positions for the highest valued move. */
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
float this_value = move[pos].final_value;
if (allowed_moves && !allowed_moves[pos])
continue;
if (!ON_BOARD(pos) || move[pos].final_value == 0.0)
continue;
if (this_value > best_value) {
if (is_legal(pos, color) || is_illegal_ko_capture(pos, color)) {
best_value = this_value;
best_move = pos;
}
else {
TRACE("Move at %1m would be suicide.\n", pos);
remove_top_move(pos);
move[pos].value = 0.0;
move[pos].final_value = 0.0;
}
}
}
/* If the best move is an illegal ko capture, reevaluate ko
* threats and search again.
*/
if (best_value > 0.0
&& (is_illegal_ko_capture(best_move, color)
|| !is_allowed_move(best_move, color))) {
TRACE("Move at %1m would be an illegal ko capture.\n", best_move);
reevaluate_ko_threats(best_move, color, best_value);
redistribute_points();
time_report(2, " reevaluate_ko_threats", NO_MOVE, 1.0);
remove_top_move(best_move);
move[best_move].value = 0.0;
move[best_move].final_value = 0.0;
print_top_moves();
good_move_found = 0;
}
/* Call blunder_size() to check that we're not about to make a
* blunder. Otherwise devalue this move and scan through all move
* values once more.
*/
else if (best_value > 0.0) {
if (!blunder_tested[best_move]) {
float blunder_size = value_moves_get_blunder_size(best_move, color);
if (blunder_size > 0.0) {
TRACE("Move at %1m is a blunder, subtracting %f.\n", best_move,
blunder_size);
remove_top_move(best_move);
move[best_move].value -= blunder_size;
move[best_move].final_value -= blunder_size;
TRACE("Move at %1m is now valued %f.\n", best_move,
move[best_move].final_value);
record_top_move(best_move, move[best_move].final_value);
good_move_found = 0;
blunder_tested[best_move] = 1;
}
else
good_move_found = 1; /* Best move was not a blunder. */
}
else /* The move apparently was a blunder, but still the best move. */
good_move_found = 1;
}
else
good_move_found = 1; /* It's best to pass. */
}
if (best_value > 0.0
&& best_move != NO_MOVE) {
*the_move = best_move;
*value = best_value;
return 1;
}
return 0;
}
/*
* Review the move reasons to find which (if any) move we want to play.
*
* The parameter pure_threat_value is the value assigned to a move
* which only threatens to capture or kill something. The reason for
* playing these is that the move may be effective because we have
* misevaluated the dangers or because the opponent misplays.
*
* The array allowed_moves restricts which moves may be considered. If
* NULL any move is allowed.
*/
int
review_move_reasons(int *the_move, float *value, int color,
float pure_threat_value, float our_score,
int allowed_moves[BOARDMAX],
int use_thrashing_dragon_heuristics)
{
int save_verbose;
current_color = color;
start_timer(2);
find_more_attack_and_defense_moves(color);
time_report(2, " find_more_attack_and_defense_moves", NO_MOVE, 1.0);
if (get_level() >= 6) {
find_more_owl_attack_and_defense_moves(color);
time_report(2, " find_more_owl_attack_and_defense_moves", NO_MOVE, 1.0);
}
if (large_scale && get_level() >= 6) {
find_large_scale_owl_attack_moves(color);
time_report(2, " find_large_scale_owl_attack_moves", NO_MOVE, 1.0);
}
find_more_semeai_moves(color);
time_report(2, " find_more_semeai_moves", NO_MOVE, 1.0);
save_verbose = verbose;
if (verbose > 0)
verbose--;
examine_move_safety(color);
time_report(2, " examine_move_safety", NO_MOVE, 1.0);
verbose = save_verbose;
/* We can't do this until move_safety is known. */
induce_secondary_move_reasons(color);
time_report(2, " induce_secondary_move_reasons", NO_MOVE, 1.0);
if (printworms || verbose)
list_move_reasons(stderr, NO_MOVE);
/* Evaluate all moves with move reasons. */
value_moves(color, pure_threat_value, our_score,
use_thrashing_dragon_heuristics);
time_report(2, " value_moves", NO_MOVE, 1.0);
/* Perform point redistribution */
redistribute_points();
/* Search through all board positions for the 10 highest valued
* moves and print them.
*/
print_top_moves();
/* Select the highest valued move and return it. */
return find_best_move(the_move, value, color, allowed_moves);
}
/*
* Choosing a strategy based on the current score estimate
* and the game status (between 0.0 (start) and 1.0 (game over)).
*/
void
choose_strategy(int color, float our_score, float game_status)
{
minimum_value_weight = 1.0;
maximum_value_weight = 1.0;
territorial_weight = 1.0;
strategical_weight = 1.0;
attack_dragon_weight = 1.0;
invasion_malus_weight = 1.0;
followup_weight = 1.0;
TRACE(" Game status = %f (0.0 = start, 1.0 = game over)\n", game_status);
if (cosmic_gnugo) {
if (game_status > 0.65 && our_score > 15.0) {
/* We seem to be winning, so we use conservative settings. */
minimum_value_weight = 0.66;
maximum_value_weight = 2.0;
territorial_weight = 0.95;
strategical_weight = 1.0;
attack_dragon_weight = 1.1;
invasion_malus_weight = 1.3;
followup_weight = 1.1;
TRACE(" %s is leading, using conservative settings.\n",
color == WHITE ? "White" : "Black");
}
else if (game_status > 0.16) {
/* We're not winning enough yet, try aggressive settings. */
minimum_value_weight = 0.66;
maximum_value_weight = 2.0;
territorial_weight = 1.4;
strategical_weight = 0.5;
attack_dragon_weight = 0.62;
invasion_malus_weight = 2.0;
followup_weight = 0.62;
/* If we're getting desesperate, try invasions as a last resort */
if (game_status > 0.75 && our_score < -25.0)
invasion_malus_weight = 0.2;
TRACE(" %s is not winning enough, using aggressive settings.\n",
color == WHITE ? "White" : "Black");
}
}
}
/* In order to get valid influence data after a move, we need to rerun
* estimate_territorial_value() for that move. A prerequisite for
* using this function is that move reasons have already been collected.
*
* This function should only be used for debugging purposes.
*/
void
prepare_move_influence_debugging(int pos, int color)
{
float our_score;
if (color == WHITE)
our_score = black_score;
else
our_score = -white_score;
estimate_territorial_value(pos, color, our_score, 1);
}
/* Compute probabilities of each move being played. It is assumed
* that the `move[]' array is filled with proper values (i.e. that
* one of the genmove*() functions has been called).
*
* The value of each move `V_k' should be a uniformly distributed
* random variable (`k' is a unique move index). Let it have values
* from the interval [l_k; u_k] . Then move value has constant
* probability density on the interval:
*
* 1
* d_k = -----------.
* u_k - l_k
*
* We need to determine the probability of `V_k' being the largest of
* {V_1, V_2, ..., V_n}. Probability density is like follows:
*
* D_k(t) = d_k * Product(P{V_i < t} for i != k), l_k <= t <= u_k,
*
* where P{A} is the probability of event `A'. By integrating D_k(t)
* from `l_k' to `u_k' we can find the probability in question:
*
* P{V_k > V_i for i != k} = Integrate(D_k(t) dt from l_k to u_k).
*
* Function D_k(t) is a polynomial on each of subintervals produced by
* points `l_k', `u_k', k = 1, ..., n. When t < min(l_k), D_k(t) is
* zero. On other subintervals it can be evaluated by taking into
* account that
*
* P{V_i < t} = d_i * (t - l_i) if t < u_i;
* P{V_i < t} = 1 if t >= u_i.
*/
void
compute_move_probabilities(float probabilities[BOARDMAX])
{
int k;
int pos;
int num_moves = 0;
int moves[BOARDMAX];
double lower_values[BOARDMAX];
double upper_values[BOARDMAX];
double densities[BOARDMAX];
double common_lower_limit = 0.0;
/* Find all moves with positive values. */
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
probabilities[pos] = 0.0;
if (ON_BOARD(pos)) {
/* FIXME: what about point redistribution? */
if (move[pos].final_value > 0.0) {
double scale = 0.01 * (double) move[pos].randomness_scaling;
moves[num_moves] = pos;
lower_values[num_moves] = ((double) move[pos].final_value
- (scale * move[pos].random_number));
upper_values[num_moves] = lower_values[num_moves] + scale;
densities[num_moves] = 1.0 / scale;
if (lower_values[num_moves] > common_lower_limit)
common_lower_limit = lower_values[num_moves];
num_moves++;
}
}
}
/* Compute probability of each move. */
for (k = 0; k < num_moves; k++) {
int i;
double lower_limit = common_lower_limit;
/* Iterate over subintervals for integration. */
while (lower_limit < upper_values[k]) {
int j;
double upper_limit = upper_values[k];
double span_power;
double polynomial[BOARDMAX];
int degree;
degree = 0;
polynomial[0] = 1.0;
for (i = 0; i < num_moves; i++) {
/* See if we need to decrease current subinterval. */
if (upper_values[i] > lower_limit && upper_values[i] < upper_limit)
upper_limit = upper_values[i];
}
/* Build the probability density polynomial for the current
* subinterval.
*/
for (i = 0; i < num_moves; i++) {
if (i != k && upper_values[i] >= upper_limit) {
polynomial[++degree] = 0.0;
for (j = degree; j > 0; j--) {
polynomial[j] = (densities[i]
* (polynomial[j - 1]
+ ((lower_limit - lower_values[i])
* polynomial[j])));
}
polynomial[0] *= densities[i] * (lower_limit - lower_values[i]);
}
}
/* And compute the integral of the polynomial on the current
* subinterval.
*/
span_power = 1.0;
for (j = 0; j <= degree; j++) {
span_power *= upper_limit - lower_limit;
probabilities[moves[k]] += (polynomial[j] * span_power) / (j + 1);
}
/* Go on to the next subinterval. */
lower_limit = upper_limit;
}
probabilities[moves[k]] *= densities[k];
}
}
/*
* Local Variables:
* tab-width: 8
* c-basic-offset: 2
* End:
*/
Reference in New Issue View Git Blame Copy Permalink