/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* 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 "random.h"
#include "move_reasons.h"
/* All these data structures are declared in move_reasons.h */
struct move_data move[BOARDMAX];
struct move_reason move_reasons[MAX_MOVE_REASONS];
int next_reason;
/* Connections */
int conn_worm1[MAX_CONNECTIONS];
int conn_worm2[MAX_CONNECTIONS];
int next_connection;
/* Potential semeai moves. */
int semeai_target1[MAX_POTENTIAL_SEMEAI];
int semeai_target2[MAX_POTENTIAL_SEMEAI];
static int next_semeai;
/* Unordered sets (currently pairs) of move reasons / targets */
Reason_set either_data[MAX_EITHER];
int next_either;
Reason_set all_data[MAX_ALL];
int next_all;
/* Eye shapes */
int eyes[MAX_EYES];
int eyecolor[MAX_EYES];
int next_eye;
/* Lunches */
int lunch_dragon[MAX_LUNCHES]; /* eater */
int lunch_worm[MAX_LUNCHES]; /* food */
int next_lunch;
/* Point redistribution */
int replacement_map[BOARDMAX];
/* The color for which we are evaluating moves. */
int current_color;
/* Attack threats that are known to be sente locally. */
static int known_good_attack_threats[BOARDMAX][MAX_ATTACK_THREATS];
/* Moves that are known to be safe (in the sense that played stones can
* be captured, but opponent loses much more when attempting to do so)
*/
static int known_safe_moves[BOARDMAX];
/* Helper functions to check conditions in discard rules. */
typedef int (*discard_condition_fn_ptr)(int pos, int what);
struct discard_rule {
int reason_type[MAX_REASONS];
discard_condition_fn_ptr condition;
int flags;
char trace_message[MAX_TRACE_LENGTH];
};
/* Initialize move reason data structures. */
void
clear_move_reasons(void)
{
int pos;
int k;
next_reason = 0;
next_connection = 0;
next_semeai = 0;
next_either = 0;
next_all = 0;
next_eye = 0;
next_lunch = 0;
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
if (ON_BOARD(pos)) {
move[pos].value = 0.0;
move[pos].final_value = 0.0;
move[pos].additional_ko_value = 0.0;
move[pos].territorial_value = 0.0;
move[pos].strategical_value = 0.0;
move[pos].maxpos_shape = 0.0;
move[pos].numpos_shape = 0;
move[pos].maxneg_shape = 0.0;
move[pos].numneg_shape = 0;
move[pos].followup_value = 0.0;
move[pos].influence_followup_value = 0.0;
move[pos].reverse_followup_value = 0.0;
move[pos].secondary_value = 0.0;
move[pos].min_value = 0.0;
move[pos].max_value = HUGE_MOVE_VALUE;
move[pos].min_territory = 0.0;
move[pos].max_territory = HUGE_MOVE_VALUE;
for (k = 0; k < MAX_REASONS; k++)
move[pos].reason[k] = -1;
move[pos].move_safety = 0;
move[pos].worthwhile_threat = 0;
move[pos].randomness_scaling = 1.0;
/* The reason we assign a random number to each move immediately
* is to avoid dependence on which moves are evaluated when it
* comes to choosing between multiple moves of the same value.
* In this way we can get consistent results for use in the
* regression tests.
*/
move[pos].random_number = gg_drand();
/* Do not send away the points (yet). */
replacement_map[pos] = NO_MOVE;
}
}
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
known_safe_moves[pos] = 0;
for (k = 0; k < MAX_ATTACK_THREATS; k++)
known_good_attack_threats[pos][k] = NO_MOVE;
}
}
/*
* Find the index of a connection in the list of connections.
* If necessary, add a new entry.
*/
int
find_connection(int worm1, int worm2)
{
int k;
if (worm1 > worm2) {
/* Swap to canonical order. */
int tmp = worm1;
worm1 = worm2;
worm2 = tmp;
}
for (k = 0; k < next_connection; k++)
if (conn_worm1[k] == worm1 && conn_worm2[k] == worm2)
return k;
/* Add a new entry. */
gg_assert(next_connection < MAX_CONNECTIONS);
conn_worm1[next_connection] = worm1;
conn_worm2[next_connection] = worm2;
next_connection++;
return next_connection - 1;
}
static int
find_either_data(int reason1, int what1, int reason2, int what2)
{
int k;
/* Make sure the worms are ordered canonically. */
if (what1 > what2) {
int tmp = what1;
what1 = what2;
what2 = tmp;
}
for (k = 0; k < next_either; k++)
if (either_data[k].reason1 == reason1
&& either_data[k].what1 == what1
&& either_data[k].reason2 == reason2
&& either_data[k].what2 == what2)
return k;
/* Add a new entry. */
gg_assert(next_either < MAX_EITHER);
either_data[next_either].reason1 = reason1;
either_data[next_either].what1 = what1;
either_data[next_either].reason2 = reason2;
either_data[next_either].what2 = what2;
next_either++;
return next_either - 1;
}
static int
find_all_data(int reason1, int what1, int reason2, int what2)
{
int k;
/* Make sure the worms are ordered canonically. */
if (what1 > what2) {
int tmp = what1;
what1 = what2;
what2 = tmp;
}
for (k = 0; k < next_all; k++)
if (all_data[k].reason1 == reason1
&& all_data[k].what1 == what1
&& all_data[k].reason2 == reason2
&& all_data[k].what2 == what2)
return k;
/* Add a new entry. */
gg_assert(next_all < MAX_ALL);
all_data[next_all].reason1 = reason1;
all_data[next_all].what1 = what1;
all_data[next_all].reason2 = reason2;
all_data[next_all].what2 = what2;
next_all++;
return next_all - 1;
}
static int
find_pair_data(int what1, int what2)
{
int k;
for (k = 0; k < next_either; k++)
if (either_data[k].what1 == what1
&& either_data[k].what2 == what2)
return k;
/* Add a new entry. */
gg_assert(next_either < MAX_EITHER);
either_data[next_either].what1 = what1;
either_data[next_either].what2 = what2;
next_either++;
return next_either - 1;
}
/* Interprets the object of a reason and returns its position.
* If the object is a pair (of worms or dragons), the position of the first
* object is returned. (This is only used for trace outputs.) Returns
* NO_MOVE if move does not point to a location.
* FIXME: This new function produces some code duplication with other
* trace output function. Do some code cleanup here.
*/
static int
get_pos(int reason, int what)
{
switch (reason) {
case ATTACK_MOVE:
case DEFEND_MOVE:
case ATTACK_THREAT:
case DEFEND_THREAT:
case ATTACK_MOVE_GOOD_KO:
case ATTACK_MOVE_BAD_KO:
case DEFEND_MOVE_GOOD_KO:
case DEFEND_MOVE_BAD_KO:
return what;
case SEMEAI_MOVE:
case SEMEAI_THREAT:
case STRATEGIC_ATTACK_MOVE:
case STRATEGIC_DEFEND_MOVE:
case OWL_ATTACK_MOVE:
case OWL_DEFEND_MOVE:
case OWL_ATTACK_THREAT:
case OWL_DEFEND_THREAT:
case OWL_PREVENT_THREAT:
case UNCERTAIN_OWL_ATTACK:
case UNCERTAIN_OWL_DEFENSE:
case OWL_ATTACK_MOVE_GOOD_KO:
case OWL_ATTACK_MOVE_BAD_KO:
case OWL_DEFEND_MOVE_GOOD_KO:
case OWL_DEFEND_MOVE_BAD_KO:
return what;
case EITHER_MOVE:
/* FIXME: What should we return here? */
return either_data[what].what1;
case ALL_MOVE:
/* FIXME: What should we return here? */
return all_data[what].what1;
case CONNECT_MOVE:
case CUT_MOVE:
return conn_worm1[what];
case ANTISUJI_MOVE:
case EXPAND_TERRITORY_MOVE:
case EXPAND_MOYO_MOVE:
case INVASION_MOVE:
case MY_ATARI_ATARI_MOVE:
case YOUR_ATARI_ATARI_MOVE:
return NO_MOVE;
case OWL_ATTACK_MOVE_GAIN:
case OWL_DEFEND_MOVE_LOSS:
/* FIXME: What should we return here? */
return either_data[what].what1;
default:
/* We should never get here: */
gg_assert(0);
return 0; /* To keep gcc happy. */
}
}
/*
* See if a lunch is already in the list of lunches, otherwise add a new
* entry. A lunch is in this context a pair of eater (a dragon) and food
* (a worm).
*/
void
add_lunch(int eater, int food)
{
int k;
int dragon1 = dragon[eater].origin;
int worm1 = worm[food].origin;
ASSERT_ON_BOARD1(eater);
ASSERT_ON_BOARD1(food);
for (k = 0; k < next_lunch; k++)
if ((lunch_dragon[k] == dragon1) && (lunch_worm[k] == worm1))
return;
/* Add a new entry. */
gg_assert(next_lunch < MAX_LUNCHES);
lunch_dragon[next_lunch] = dragon1;
lunch_worm[next_lunch] = worm1;
next_lunch++;
return;
}
/* ---------------------------------------------------------------- */
/*
* Add a move reason for (pos) if it's not already there or the
* table is full.
*/
static void
add_move_reason(int pos, int type, int what)
{
int k;
ASSERT_ON_BOARD1(pos);
if (stackp == 0) {
ASSERT1(board[pos] == EMPTY, pos);
}
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == type
&& move_reasons[r].what == what)
return; /* Reason already listed. */
}
/* Reason not found, add it if there is place left in both lists.
* Otherwise drop it.
*/
if (k >= MAX_REASONS) {
DEBUG(DEBUG_MOVE_REASONS,
"Move reason at %1m (type=%d, what=%d) dropped because list full.\n",
pos, type, what);
return;
}
if (next_reason >= MAX_MOVE_REASONS) {
DEBUG(DEBUG_MOVE_REASONS,
"Move reason at %1m (type=%d, what=%d) dropped because global list full.\n",
pos, type, what);
return;
}
/* Add a new entry. */
move[pos].reason[k] = next_reason;
move_reasons[next_reason].type = type;
move_reasons[next_reason].what = what;
move_reasons[next_reason].status = ACTIVE;
next_reason++;
}
/*
* Remove a move reason for (pos). Ignore silently if the reason
* wasn't there.
*/
static void
remove_move_reason(int pos, int type, int what)
{
int k;
int n = -1; /* Position of the move reason to be deleted. */
ASSERT_ON_BOARD1(pos);
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == type
&& move_reasons[r].what == what)
n = k;
}
if (n == -1)
return; /* Move reason wasn't there. */
/* Now move the last move reason to position n, thereby removing the
* one we were looking for.
*/
k--;
move[pos].reason[n] = move[pos].reason[k];
move[pos].reason[k] = -1;
}
/*
* Check whether a move reason already is recorded for a move.
* A negative value for 'what' means only match 'type'.
*/
int
move_reason_known(int pos, int type, int what)
{
int k;
int r;
ASSERT_ON_BOARD1(pos);
for (k = 0; k < MAX_REASONS; k++) {
r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == type
&& (what < 0
|| move_reasons[r].what == what))
return 1;
}
return 0;
}
/* ---------------------------------------------------------------- */
/* Functions used in discard_rules follow below. */
/*
* Check whether an attack move reason already is recorded for a move.
* A negative value for 'what' means only match 'type'.
*/
int
attack_move_reason_known(int pos, int what)
{
ASSERT1(what < 0 || IS_STONE(board[what]), what);
what = worm[what].origin;
if (move_reason_known(pos, ATTACK_MOVE, what))
return WIN;
if (move_reason_known(pos, ATTACK_MOVE_GOOD_KO, what))
return KO_A;
if (move_reason_known(pos, ATTACK_MOVE_BAD_KO, what))
return KO_B;
return 0;
}
/*
* Check whether a defense move reason already is recorded for a move.
* A negative value for 'what' means only match 'type'.
*/
int
defense_move_reason_known(int pos, int what)
{
ASSERT1(what < 0 || IS_STONE(board[what]), what);
what = worm[what].origin;
if (move_reason_known(pos, DEFEND_MOVE, what))
return WIN;
if (move_reason_known(pos, DEFEND_MOVE_GOOD_KO, what))
return KO_A;
if (move_reason_known(pos, DEFEND_MOVE_BAD_KO, what))
return KO_B;
return 0;
}
/* Check whether a dragon consists of only one worm. If so, check
* whether we know of a tactical attack or defense move.
*/
static int
tactical_move_vs_whole_dragon_known(int pos, int what)
{
return ((worm[what].size == dragon[what].size)
&& (attack_move_reason_known(pos, what)
|| defense_move_reason_known(pos, what)));
}
/*
* Check whether an owl attack move reason already is recorded for a move.
* A negative value for 'what' means only match 'type'.
*/
int
owl_attack_move_reason_known(int pos, int what)
{
if (move_reason_known(pos, OWL_ATTACK_MOVE, what))
return WIN;
if (move_reason_known(pos, OWL_ATTACK_MOVE_GOOD_KO, what))
return KO_A;
if (move_reason_known(pos, OWL_ATTACK_MOVE_BAD_KO, what))
return KO_B;
return 0;
}
/*
* Check whether an owl defense move reason already is recorded for a move.
* A negative value for 'what' means only match 'type'.
*/
int
owl_defense_move_reason_known(int pos, int what)
{
if (move_reason_known(pos, OWL_DEFEND_MOVE, what))
return WIN;
if (move_reason_known(pos, OWL_DEFEND_MOVE_GOOD_KO, what))
return KO_A;
if (move_reason_known(pos, OWL_DEFEND_MOVE_BAD_KO, what))
return KO_B;
return 0;
}
/*
* Check whether an owl attack/defense move reason is recorded for a move.
* A negative value for 'what' means only match 'type'.
*/
int
owl_move_reason_known(int pos, int what)
{
return (owl_attack_move_reason_known(pos, what)
|| owl_defense_move_reason_known(pos, what));
}
/*
* Check whether we have an owl attack/defense reason for a move that
* involves a specific worm.
*/
static int
owl_move_vs_worm_known(int pos, int what)
{
return owl_move_reason_known(pos, dragon[what].origin);
}
int
semeai_move_reason_known(int pos, int what)
{
return move_reason_known(pos, SEMEAI_MOVE, what);
}
/* Check whether a worm is inessential */
static int
concerns_inessential_worm(int pos, int what)
{
UNUSED(pos);
return DRAGON2(what).safety == INESSENTIAL
|| worm[what].inessential;
}
/* Check whether a dragon is inessential */
static int
concerns_inessential_dragon(int pos, int what)
{
UNUSED(pos);
return DRAGON2(what).safety == INESSENTIAL;
}
static int
move_is_marked_unsafe(int pos, int what)
{
UNUSED(what);
return (!move[pos].move_safety
&& !adjacent_to_nondead_stone(pos, current_color));
}
/* Check whether a dragon is non-critical. */
static int
concerns_noncritical_dragon(int pos, int what)
{
UNUSED(pos);
return (dragon[what].status != CRITICAL
&& worm[what].attack_codes[0] == 0);
}
/* (what) points to two worms listed in either_data. Returns true if
* this is a "attack either" move reason, and one of the worms attackable.
* FIXME: Ko?
*/
static int
either_worm_attackable(int pos, int what)
{
UNUSED(pos);
return (either_data[what].reason1 == ATTACK_STRING
&& either_data[what].reason2 == ATTACK_STRING
&& (worm[either_data[what].what1].attack_codes[0] != 0
|| worm[either_data[what].what2].attack_codes[0] != 0));
}
/* (what) points to two worms via all_data. Returns true if this is
* a "defend both" move reason, and one of the worms is attackable.
* FIXME: Ko?
*/
static int
one_of_both_attackable(int pos, int what)
{
UNUSED(pos);
return (all_data[what].reason1 == DEFEND_STRING
&& all_data[what].reason2 == DEFEND_STRING
&& (worm[all_data[what].what1].attack_codes[0] != 0
|| worm[all_data[what].what2].attack_codes[0] != 0));
}
/* ---------------------------------------------------------------- */
/*
* Add to the reasons for the move at (pos) that it attacks the worm
* at (ww).
*/
void
add_attack_move(int pos, int ww, int code)
{
ASSERT_ON_BOARD1(ww);
ww = worm[ww].origin;
if (code == WIN)
add_move_reason(pos, ATTACK_MOVE, ww);
else if (code == KO_A)
add_move_reason(pos, ATTACK_MOVE_GOOD_KO, ww);
else if (code == KO_B)
add_move_reason(pos, ATTACK_MOVE_BAD_KO, ww);
}
/*
* Add to the reasons for the move at (pos) that it defends the worm
* at (ww).
*/
void
add_defense_move(int pos, int ww, int code)
{
ASSERT_ON_BOARD1(ww);
ww = worm[ww].origin;
if (code == WIN)
add_move_reason(pos, DEFEND_MOVE, ww);
else if (code == KO_A)
add_move_reason(pos, DEFEND_MOVE_GOOD_KO, ww);
else if (code == KO_B)
add_move_reason(pos, DEFEND_MOVE_BAD_KO, ww);
}
/*
* Add to the reasons for the move at (pos) that it threatens to
* attack the worm at (ww).
*/
void
add_attack_threat_move(int pos, int ww, int code)
{
UNUSED(code);
ASSERT_ON_BOARD1(ww);
add_move_reason(pos, ATTACK_THREAT, worm[ww].origin);
}
/* Remove an attack threat move reason. */
void
remove_attack_threat_move(int pos, int ww)
{
ASSERT_ON_BOARD1(ww);
remove_move_reason(pos, ATTACK_THREAT, worm[ww].origin);
}
/*
* Add to the reasons for the move at (pos) that it defends the worm
* at (ww).
*/
void
add_defense_threat_move(int pos, int ww, int code)
{
UNUSED(code);
ASSERT_ON_BOARD1(ww);
add_move_reason(pos, DEFEND_THREAT, worm[ww].origin);
}
/* Report all, or up to max_strings, strings that are threatened
* at (pos).
*/
int
get_attack_threats(int pos, int max_strings, int strings[])
{
int k;
int num_strings;
num_strings = 0;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == ATTACK_THREAT)
strings[num_strings++] = move_reasons[r].what;
if (num_strings == max_strings)
break;
}
return num_strings;
}
/* Report all, or up to max_strings, strings that might be defended
* at (pos).
*/
int
get_defense_threats(int pos, int max_strings, int strings[])
{
int k;
int num_strings;
num_strings = 0;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == DEFEND_THREAT)
strings[num_strings++] = move_reasons[r].what;
if (num_strings == max_strings)
break;
}
return num_strings;
}
/* Report the biggest dragon that is owl-affected (possibily with ko)
* by a move at (pos).
*/
int
get_biggest_owl_target(int pos)
{
int k;
int biggest_target = -1;
float target_size = 0.0;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
switch (move_reasons[r].type) {
case OWL_ATTACK_MOVE:
case OWL_ATTACK_MOVE_GOOD_KO:
case OWL_ATTACK_MOVE_BAD_KO:
case OWL_ATTACK_THREAT:
case OWL_DEFEND_MOVE:
case OWL_DEFEND_MOVE_GOOD_KO:
case OWL_DEFEND_MOVE_BAD_KO:
case OWL_DEFEND_THREAT:
case OWL_PREVENT_THREAT:
if (dragon[move_reasons[r].what].effective_size > target_size) {
biggest_target = move_reasons[r].what;
target_size = dragon[move_reasons[r].what].effective_size;
}
break;
}
}
return biggest_target;
}
/*
* Add to the reasons for the move at (pos) that it connects the
* dragons at (dr1) and (dr2). Require that the dragons are
* distinct.
*/
void
add_connection_move(int pos, int w1, int w2)
{
int connection;
ASSERT_ON_BOARD1(w1);
ASSERT_ON_BOARD1(w2);
ASSERT1(worm[w1].color == worm[w2].color, w1);
if (worm[w1].origin == worm[w2].origin)
return;
connection = find_connection(worm[w1].origin, worm[w2].origin);
add_move_reason(pos, CONNECT_MOVE, connection);
}
/*
* Add to the reasons for the move at (pos) that it cuts the
* dragons at (dr1) and (dr2). Require that the dragons are
* distinct.
*/
void
add_cut_move(int pos, int w1, int w2)
{
int connection;
ASSERT_ON_BOARD1(w1);
ASSERT_ON_BOARD1(w2);
ASSERT1(worm[w1].color == worm[w2].color, w1);
if (worm[w1].origin == worm[w2].origin)
return;
connection = find_connection(worm[w1].origin, worm[w2].origin);
/*
* Ignore the cut or connection if either (w1) or (w2)
* points to a tactically captured worm.
*/
if ((worm[w1].attack_codes[0] != 0 && worm[w1].defense_codes[0] == 0)
|| (worm[w2].attack_codes[0] != 0 && worm[w2].defense_codes[0] == 0))
return;
add_move_reason(pos, CUT_MOVE, connection);
}
/*
* Add to the reasons for the move at (pos) that it is an anti-suji.
* This means that it's a locally inferior move or for some other reason
* must *not* be played.
*/
void
add_antisuji_move(int pos)
{
add_move_reason(pos, ANTISUJI_MOVE, 0);
}
/*
* Add to the reasons for the move at (pos) that it wins the
* dragon (friendly or not) at (dr) in semeai. Since it is
* possible that in some semeai one player can kill but the
* other can only make seki, it is possible that one dragon
* is already alive in seki. Therefore separate move reasons
* must be added for the two dragons.
*/
void
add_semeai_move(int pos, int dr)
{
ASSERT_ON_BOARD1(dr);
add_move_reason(pos, SEMEAI_MOVE, dragon[dr].origin);
}
/*
* Add to the reasons for the move at (pos) that it might
* kill/save the dragon at (dr1) in the semeai against (dr2).
*/
static void
add_potential_semeai_move(int pos, int type, int dr1, int dr2)
{
ASSERT1(ON_BOARD(dr1), pos);
ASSERT1(ON_BOARD(dr2), pos);
if (next_semeai >= MAX_POTENTIAL_SEMEAI)
DEBUG(DEBUG_MOVE_REASONS,
"Potential semeai move at %1m dropped as list was full\n", pos);
else {
semeai_target1[next_semeai] = dr1;
semeai_target2[next_semeai] = dr2;
add_move_reason(pos, type, next_semeai);
next_semeai++;
}
}
/*
* Add to the reasons for the move at (pos) that it might
* kill the dragon at (dr1) in the semeai against (dr2).
*/
void
add_potential_semeai_attack(int pos, int dr1, int dr2)
{
add_potential_semeai_move(pos, POTENTIAL_SEMEAI_ATTACK, dr1, dr2);
}
/*
* Add to the reasons for the move at (pos) that it might
* save the dragon at (dr1) in the semeai against (dr2).
*/
void
add_potential_semeai_defense(int pos, int dr1, int dr2)
{
add_potential_semeai_move(pos, POTENTIAL_SEMEAI_DEFENSE, dr1, dr2);
}
/*
* Add to the reasons for the move at (pos) that given two
* moves in a row a move here can win the dragon (friendly or
* not) at (dr) in semeai. Such a move can be used as a
* ko threat, and it is also given some value due to uncertainty
* in the counting of liberties.
*/
void
add_semeai_threat(int pos, int dr)
{
ASSERT_ON_BOARD1(dr);
add_move_reason(pos, SEMEAI_THREAT, dragon[dr].origin);
}
/*
* Add to the reasons for the move at (pos) that it will accomplish
* one of two things: either (reason1) on (target1) or (reason2) on
* (target2).
*
* At this time, (reason) can only be ATTACK_STRING.
* However, more reasons will be implemented in the future.
*
* FIXME: Implement at least ATTACK_MOVE_GOOD_KO, ATTACK_MOVE_BAD_KO,
* DEFEND_MOVE and associates, CONNECT_MOVE, OWL_ATTACK_MOVE,
* OWL_DEFEND_MOVE, and possibly more.
*
* FIXME: Generalize to more than 2 parameters.
* When that is done, this will be a good way to add
* atari_atari moves.
*/
void
add_either_move(int pos, int reason1, int target1, int reason2, int target2)
{
int what1 = 0;
int what2 = 0;
int index;
ASSERT_ON_BOARD1(target1);
ASSERT_ON_BOARD1(target2);
if (reason1 == reason2 && target1 == target2)
return;
/* For now. */
gg_assert(reason1 == ATTACK_STRING);
gg_assert(reason2 == ATTACK_STRING);
switch (reason1) {
case ATTACK_STRING:
{
what1 = worm[target1].origin;
/* If this string is already attacked, and with no defense, then
* there is no additional value of this move reason. */
if (worm[target1].attack_codes[0] != 0
&& worm[target1].defense_codes[0] == 0)
return;
}
break;
default:
break;
}
switch (reason2) {
case ATTACK_STRING:
{
what2 = worm[target2].origin;
/* If this string is already attacked, and with no defense, then
* there is no additional value of this move reason. */
if (worm[target2].attack_codes[0] != 0
&& worm[target2].defense_codes[0] == 0)
return;
}
break;
default:
break;
}
index = find_either_data(reason1, what1, reason2, what2);
add_move_reason(pos, EITHER_MOVE, index);
}
/*
* Add to the reasons for the move at (pos) that it will accomplish
* both of two things: (reason1) on (target1) and (reason2) on
* (target2).
*
* At this time, (reason) can only be DEFEND_STRING.
* However, more reasons will be implemented in the future.
*
* FIXME: Implement at least ATTACK_MOVE_GOOD_KO, ATTACK_MOVE_BAD_KO,
* DEFEND_MOVE and associates, CONNECT_MOVE, OWL_ATTACK_MOVE,
* OWL_DEFEND_MOVE, and possibly more.
*
* FIXME: Generalize to more than 2 parameters.
* When that is done, this will be a good way to add
* atari_atari moves.
*/
void
add_all_move(int pos, int reason1, int target1, int reason2, int target2)
{
int what1 = 0;
int what2 = 0;
int index;
ASSERT_ON_BOARD1(target1);
ASSERT_ON_BOARD1(target2);
if (reason1 == reason2 && target1 == target2)
return;
/* For now. */
gg_assert(reason1 == DEFEND_STRING);
gg_assert(reason2 == DEFEND_STRING);
switch (reason1) {
case DEFEND_STRING:
what1 = worm[target1].origin;
break;
default:
break;
}
switch (reason2) {
case DEFEND_STRING:
what2 = worm[target2].origin;
break;
default:
break;
}
index = find_all_data(reason1, what1, reason2, what2);
add_move_reason(pos, ALL_MOVE, index);
}
void
add_loss_move(int pos, int target1, int target2)
{
int what1 = dragon[target1].origin;
int what2 = worm[target2].origin;
int index = find_pair_data(what1, what2);
ASSERT1(target2 != NO_MOVE, pos);
add_move_reason(pos, OWL_DEFEND_MOVE_LOSS, index);
}
/*
* Add to the reasons for the move at (pos) that it expands
* territory.
*/
void
add_expand_territory_move(int pos)
{
add_move_reason(pos, EXPAND_TERRITORY_MOVE, 0);
}
/*
* Add to the reasons for the move at (pos) that it expands
* moyo.
*/
void
add_expand_moyo_move(int pos)
{
add_move_reason(pos, EXPAND_MOYO_MOVE, 0);
}
/*
* Add to the reasons for the move at (pos) that it is an invasion.
*/
void
add_invasion_move(int pos)
{
add_move_reason(pos, INVASION_MOVE, 0);
}
/*
* This function is called when a shape value for the move at (pos)
* is found.
*
* We keep track of the largest positive shape value found, and the
* total number of positive contributions, as well as the largest
* negative shape value found, and the total number of negative
* shape contributions.
*/
void
add_shape_value(int pos, float value)
{
ASSERT_ON_BOARD1(pos);
if (value > 0.0) {
if (value > move[pos].maxpos_shape)
move[pos].maxpos_shape = value;
move[pos].numpos_shape += 1;
}
else if (value < 0.0) {
value = -value;
if (value > move[pos].maxneg_shape)
move[pos].maxneg_shape = value;
move[pos].numneg_shape += 1;
}
}
/*
* Flag that this move is worthwhile to play as a pure threat move.
*/
void
add_worthwhile_threat_move(int pos)
{
move[pos].worthwhile_threat = 1;
}
/*
* Add to the reasons for the move at (pos) that it attacks
* the dragon (dr) on a strategical level.
*/
void
add_strategical_attack_move(int pos, int dr)
{
dr = dragon[dr].origin;
ASSERT_ON_BOARD1(dr);
add_move_reason(pos, STRATEGIC_ATTACK_MOVE, dr);
}
/*
* Add to the reasons for the move at (pos) that it defends
* the dragon (dr) on a strategical level.
*/
void
add_strategical_defense_move(int pos, int dr)
{
dr = dragon[dr].origin;
ASSERT_ON_BOARD1(dr);
add_move_reason(pos, STRATEGIC_DEFEND_MOVE, dr);
}
/*
* Add to the reasons for the move at (pos) that the owl
* code reports an attack on the dragon (dr).
*/
void
add_owl_attack_move(int pos, int dr, int kworm, int code)
{
dr = dragon[dr].origin;
ASSERT_ON_BOARD1(dr);
if (code == WIN)
add_move_reason(pos, OWL_ATTACK_MOVE, dr);
else if (code == KO_A)
add_move_reason(pos, OWL_ATTACK_MOVE_GOOD_KO, dr);
else if (code == KO_B)
add_move_reason(pos, OWL_ATTACK_MOVE_BAD_KO, dr);
else if (code == GAIN) {
ASSERT_ON_BOARD1(kworm);
add_move_reason(pos, OWL_ATTACK_MOVE_GAIN, find_pair_data(dr, kworm));
}
}
/*
* Add to the reasons for the move at (pos) that the owl
* code reports a defense of the dragon (dr).
*/
void
add_owl_defense_move(int pos, int dr, int code)
{
dr = dragon[dr].origin;
ASSERT_ON_BOARD1(dr);
if (code == WIN)
add_move_reason(pos, OWL_DEFEND_MOVE, dr);
else if (code == KO_A)
add_move_reason(pos, OWL_DEFEND_MOVE_GOOD_KO, dr);
else if (code == KO_B)
add_move_reason(pos, OWL_DEFEND_MOVE_BAD_KO, dr);
}
/*
* Add to the reasons for the move at (pos) that the owl
* code reports a move threatening to attack the dragon enemy (dr).
* That is, if the attacker is given two moves in a row, (pos)
* can be the first move.
*/
void
add_owl_attack_threat_move(int pos, int dr, int code)
{
UNUSED(code);
dr = dragon[dr].origin;
ASSERT_ON_BOARD1(dr);
add_move_reason(pos, OWL_ATTACK_THREAT, dragon[dr].origin);
add_worthwhile_threat_move(pos);
}
/* The owl code found the friendly dragon alive, or the unfriendly dragon
* dead, and an extra point of attack or defense was found, so this might be a
* good place to play.
*/
void
add_owl_uncertain_defense_move(int pos, int dr)
{
dr = dragon[dr].origin;
ASSERT_ON_BOARD1(dr);
add_move_reason(pos, UNCERTAIN_OWL_DEFENSE, dragon[dr].origin);
}
/* The owl code found the opponent dragon alive, or the friendly
* dragon dead, but was uncertain, and this move reason propose
* an attack or defense which is expected to fail but might succeed.
*/
void
add_owl_uncertain_attack_move(int pos, int dr)
{
dr = dragon[dr].origin;
ASSERT_ON_BOARD1(dr);
add_move_reason(pos, UNCERTAIN_OWL_ATTACK, dragon[dr].origin);
}
/*
* Add to the reasons for the move at (pos) that the owl
* code reports a move threatening to rescue the dragon (dr).
* That is, if the defender is given two moves in a row, (pos)
* can be the first move.
*/
void
add_owl_defense_threat_move(int pos, int dr, int code)
{
UNUSED(code);
dr = dragon[dr].origin;
ASSERT_ON_BOARD1(dr);
add_move_reason(pos, OWL_DEFEND_THREAT, dragon[dr].origin);
add_worthwhile_threat_move(pos);
}
/* Add to the reasons for the move at (pos) that it captures
* at least one of a set of worms which individually are tactically
* safe (such as a double atari). Only one such move reason is
* permitted per move.
*/
void
add_my_atari_atari_move(int pos, int size)
{
add_move_reason(pos, MY_ATARI_ATARI_MOVE, size);
}
/* Add to the reasons for the move at (pos) that it stops a
* combination attack for the opponent.
*/
void
add_your_atari_atari_move(int pos, int size)
{
add_move_reason(pos, YOUR_ATARI_ATARI_MOVE, size);
}
/*
* Add to the reasons for the move at (pos) that the owl
* code reports a move threatening to defend the dragon enemy (dr),
* and that (pos) is a move which attacks the dragon.
* That is, if the defender is given two moves in a row, (pos)
* can be the first move. Hopefully playing at (pos) makes it harder
* for the dragon to live.
*/
void
add_owl_prevent_threat_move(int pos, int dr)
{
ASSERT_ON_BOARD1(dr);
add_move_reason(pos, OWL_PREVENT_THREAT, dragon[dr].origin);
}
/*
* Add value of followup moves.
*/
void
add_followup_value(int pos, float value)
{
ASSERT_ON_BOARD1(pos);
if (value > move[pos].followup_value)
move[pos].followup_value = value;
}
/*
* Add value of reverse followup moves.
*/
void
add_reverse_followup_value(int pos, float value)
{
ASSERT_ON_BOARD1(pos);
if (value > move[pos].reverse_followup_value)
move[pos].reverse_followup_value = value;
}
/*
* Set a minimum allowed value for the move.
*/
int
set_minimum_move_value(int pos, float value)
{
ASSERT_ON_BOARD1(pos);
if (value > move[pos].min_value) {
move[pos].min_value = value;
return 1;
}
return 0;
}
/*
* Set a maximum allowed value for the move.
*/
void
set_maximum_move_value(int pos, float value)
{
ASSERT_ON_BOARD1(pos);
if (value < move[pos].max_value)
move[pos].max_value = value;
}
/*
* Set a minimum allowed territorial value for the move.
*/
void
set_minimum_territorial_value(int pos, float value)
{
ASSERT_ON_BOARD1(pos);
if (value > move[pos].min_territory)
move[pos].min_territory = value;
}
/*
* Set a maximum allowed territorial value for the move.
*/
void
set_maximum_territorial_value(int pos, float value)
{
ASSERT_ON_BOARD1(pos);
if (value < move[pos].max_territory)
move[pos].max_territory = value;
}
/*
* Add a point redistribution rule, sending the points from (from)
* to (to).
*/
void
add_replacement_move(int from, int to, int color)
{
int cc;
int pos;
int dummy;
ASSERT_ON_BOARD1(from);
ASSERT_ON_BOARD1(to);
if (board[from] != EMPTY)
return;
ASSERT1(board[to] == EMPTY, to);
cc = replacement_map[to];
if (unconditionally_meaningless_move(to, color, &dummy)) {
/* Silently ignore replacement patterns which conflict with the
* unconditional analysis since the latter is always correct and
* it's difficult to anticipate such situations for the patterns.
*/
return;
}
/* First check for an incompatible redistribution rule. */
if (replacement_map[from] != NO_MOVE) {
int dd = replacement_map[from];
/* Abort if the old rule isn't compatible with the new one.
* (But not in the stable release.)
*/
if (0) {
ASSERT1(dd == to || to == replacement_map[dd], from);
}
/* There already is a redistribution in effect so we
* have nothing more to do.
*/
return;
}
TRACE("Move at %1m is replaced by %1m.\n", from, to);
/* Verify that we don't introduce a cyclic redistribution. */
if (cc == from) {
gprintf("Cyclic point redistribution detected.\n");
ASSERT1(0, from);
}
/* Update the replacement map. Make sure that all replacements
* always are directed immediately to the final destination.
*/
if (cc != NO_MOVE)
replacement_map[from] = cc;
else
replacement_map[from] = to;
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
if (ON_BOARD(pos) && replacement_map[pos] == from)
replacement_map[pos] = replacement_map[from];
}
}
/* Find worms rescued by a move at (pos). */
void
get_saved_worms(int pos, signed char saved[BOARDMAX])
{
int k;
memset(saved, 0, sizeof(saved[0]) * BOARDMAX);
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
int what;
if (r < 0)
break;
what = move_reasons[r].what;
/* We exclude the ko contingent defenses, to avoid that the
* confirm_safety routines spot an attack with ko and thinks the
* move is unsafe.
*/
if (move_reasons[r].type == DEFEND_MOVE)
mark_string(worm[what].origin, saved, 1);
else if (move_reasons[r].type == OWL_DEFEND_MOVE_LOSS) {
int origin = dragon[what].origin;
int kworm = worm[what].origin;
int ii;
for (ii = BOARDMIN; ii < BOARDMAX; ii++)
if (IS_STONE(board[ii]) && dragon[ii].origin == origin
&& worm[ii].origin != kworm)
mark_string(worm[ii].origin, saved, 1);
}
}
}
/* This function marks all stones whose status is changed by an owl move
* reason according to the following rules:
* 1. For an owl attack, all stones belonging to the attacked dragon are
* marked as INFLUENCE_CAPTURED_STONE
* 2. For an owl defense, all stones belonging to the defended dragon are
* markes as INFLUENCE_SAVED_STONE if they are also sufficiently
* tactically stable.
*
* In effective_size, the sum of the effective size of the changed worms
* is returned (unless it is a NULL pointer).
*/
void
mark_changed_dragon(int pos, int color, int affected, int affected2,
int move_reason_type, signed char safe_stones[BOARDMAX],
float strength[BOARDMAX], float *effective_size)
{
int ii;
signed char new_status = INFLUENCE_SAVED_STONE;
int result_to_beat = 0;
ASSERT1(board[pos] == EMPTY, pos);
ASSERT1(IS_STONE(board[affected]), pos);
if (effective_size)
*effective_size = 0.0;
/* For attack moves, we immediately can set the effective size.
* For defense moves, it will be calculated in the course of
* updating the worms' status.
*/
switch (move_reason_type) {
case OWL_ATTACK_MOVE:
case OWL_ATTACK_MOVE_GOOD_KO:
case OWL_ATTACK_MOVE_BAD_KO:
ASSERT1(board[affected] == OTHER_COLOR(color), pos);
new_status = 0;
if (effective_size)
*effective_size = dragon[affected].effective_size;
break;
case OWL_DEFEND_MOVE:
ASSERT1(board[affected] == color, pos);
result_to_beat = WIN;
break;
case OWL_DEFEND_MOVE_GOOD_KO:
ASSERT1(board[affected] == color, pos);
result_to_beat = KO_A;
break;
case OWL_DEFEND_MOVE_BAD_KO:
ASSERT1(board[affected] == color, pos);
result_to_beat = KO_B;
break;
case OWL_ATTACK_MOVE_GAIN:
ASSERT1(board[affected] == OTHER_COLOR(color), pos);
new_status = 0;
if (effective_size)
*effective_size = worm[affected2].effective_size;
break;
case OWL_DEFEND_MOVE_LOSS:
ASSERT1(board[affected] == color, pos);
if (effective_size)
*effective_size = dragon[affected].effective_size
- worm[affected2].effective_size;
result_to_beat = WIN;
break;
case SEMEAI_MOVE:
ASSERT1(IS_STONE(board[affected]), pos);
if (board[affected] == color)
result_to_beat = WIN;
else {
new_status = 0;
if (effective_size)
*effective_size = dragon[affected].effective_size;
}
break;
default:
/* mark_changed_dragon() called with invalid move reason. */
ASSERT1(0, pos);
}
if (move_reason_type == OWL_ATTACK_MOVE_GAIN)
mark_changed_string(affected2, safe_stones, strength, new_status);
else {
for (ii = first_worm_in_dragon(affected); ii != NO_MOVE;
ii = next_worm_in_dragon(ii))
if (new_status == 0)
mark_changed_string(ii, safe_stones, strength, new_status);
else {
int worm_is_safe = 0;
if (worm[ii].attack_codes[0] == NO_MOVE
|| defense_move_reason_known(pos, ii))
worm_is_safe = 1;
else if (trymove(pos, color, "mark-changed-dragon", ii)) {
if (REVERSE_RESULT(attack(ii, NULL)) >= result_to_beat)
worm_is_safe = 1;
popgo();
}
if (worm_is_safe || move_reason_type == SEMEAI_MOVE) {
/* This string can now be considered safe. Hence we mark the
* whole string as such:
*/
mark_changed_string(ii, safe_stones, strength, new_status);
if (effective_size)
*effective_size += worm[ii].effective_size;
}
}
if (move_reason_type == OWL_DEFEND_MOVE_LOSS) {
new_status = 0;
mark_changed_string(affected2, safe_stones, strength, new_status);
}
}
}
/* Marks the string at (affected) with the new status and accordingly
* with the new strength.
*/
void
mark_changed_string(int affected, signed char safe_stones[BOARDMAX],
float strength[BOARDMAX], signed char new_status)
{
float new_strength;
int ii;
ASSERT1(IS_STONE(board[affected]), affected);
if (new_status == 0)
new_strength = 0.0;
else {
gg_assert(new_status == INFLUENCE_SAVED_STONE);
new_strength = DEFAULT_STRENGTH;
}
for (ii = BOARDMIN; ii < BOARDMAX; ii++)
if (board[ii] == board[affected]
&& same_string(ii, affected)) {
strength[ii] = new_strength;
safe_stones[ii] = new_status;
}
}
/* Find dragons rescued by a move at (pos). */
void
get_saved_dragons(int pos, signed char saved[BOARDMAX])
{
int k;
memset(saved, 0, sizeof(saved[0]) * BOARDMAX);
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
int what;
if (r < 0)
break;
what = move_reasons[r].what;
/* We exclude the ko contingent defenses, to avoid that the
* confirm_safety routines spot an attack with ko and thinks the
* move is unsafe.
*/
if (move_reasons[r].type == OWL_DEFEND_MOVE)
mark_dragon(what, saved, 1);
}
}
/* If a move has saved the dragons in saved_dragons[] and worms in
* saved_worms[], this functions writes the stones now supposedly safe
* in the array safe_stones[].
*
* The safety of the played move itself is set according to
* move[pos].move_safety.
*/
void
mark_safe_stones(int color, int move_pos,
const signed char saved_dragons[BOARDMAX],
const signed char saved_worms[BOARDMAX],
signed char safe_stones[BOARDMAX])
{
int pos;
for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
if (board[pos] == OTHER_COLOR(color)) {
if (dragon[pos].status == DEAD
|| (worm[pos].attack_codes[0] != 0
&& worm[pos].defense_codes[0] == 0))
safe_stones[pos] = 0;
else
safe_stones[pos] = SAFE_STONE;
}
else if (board[pos] == color) {
if ((worm[pos].attack_codes[0] != 0
&& (worm[pos].defense_codes[0] == 0 || !saved_worms[pos]))
|| dragon[pos].status == DEAD)
safe_stones[pos] = 0;
else if (saved_dragons[pos])
safe_stones[pos] = OWL_SAVED_STONE;
else if (dragon[pos].status == CRITICAL)
safe_stones[pos] = 0;
else
safe_stones[pos] = SAFE_STONE;
}
else
safe_stones[pos] = 0;
}
safe_stones[move_pos]
= move[move_pos].move_safety && safe_move(move_pos, color) == WIN;
}
/* List the move reasons for (color)'s move at (pos). Return the
* number of move reasons.
*/
int
list_move_reasons(FILE *out, int move_pos)
{
int m;
int n;
int pos;
int k;
int reason1;
int reason2;
int aa = NO_MOVE;
int bb = NO_MOVE;
int worm1 = -1;
int worm2 = -1;
int num_move_reasons = 0;
gprintf("\nMove reasons:\n");
for (n = 0; n < board_size; n++)
for (m = board_size-1; m >= 0; m--) {
pos = POS(m, n);
if (move_pos != NO_MOVE && move_pos != pos)
continue;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
num_move_reasons++;
switch (move_reasons[r].type) {
case ATTACK_MOVE:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m attacks %1m%s\n", pos, aa,
(worm[aa].defense_codes[0] == 0) ? " (defenseless)" : "");
break;
case ATTACK_MOVE_GOOD_KO:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m attacks %1m%s with good ko\n", pos, aa,
(worm[aa].defense_codes[0] == 0) ? " (defenseless)" : "");
break;
case ATTACK_MOVE_BAD_KO:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m attacks %1m%s with bad ko\n", pos, aa,
(worm[aa].defense_codes[0] == 0) ? " (defenseless)" : "");
break;
case DEFEND_MOVE:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m defends %1m\n", pos, aa);
break;
case DEFEND_MOVE_GOOD_KO:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m defends %1m with good ko\n", pos, aa);
break;
case DEFEND_MOVE_BAD_KO:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m defends %1m with bad ko\n", pos, aa);
break;
case ATTACK_THREAT:
case DEFEND_THREAT:
aa = move_reasons[r].what;
if (move_reasons[r].type == ATTACK_THREAT)
gfprintf(out, "Move at %1m threatens to attack %1m\n", pos, aa);
else if (move_reasons[r].type == DEFEND_THREAT)
gfprintf(out, "Move at %1m threatens to defend %1m\n", pos, aa);
break;
case UNCERTAIN_OWL_DEFENSE:
aa = move_reasons[r].what;
if (board[aa] == current_color)
gfprintf(out, "%1m found alive but not certainly, %1m defends it again\n",
aa, pos);
else
gfprintf(out, "%1m found dead but not certainly, %1m attacks it again\n",
aa, pos);
break;
case CONNECT_MOVE:
case CUT_MOVE:
worm1 = conn_worm1[move_reasons[r].what];
worm2 = conn_worm2[move_reasons[r].what];
if (move_reasons[r].type == CONNECT_MOVE)
gfprintf(out, "Move at %1m connects %1m and %1m\n",
pos, worm1, worm2);
else
gfprintf(out, "Move at %1m cuts %1m and %1m\n", pos, worm1, worm2);
break;
case ANTISUJI_MOVE:
gfprintf(out, "Move at %1m is an antisuji\n", pos);
break;
case SEMEAI_MOVE:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m wins semeai for %1m\n", pos, aa);
break;
case SEMEAI_THREAT:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m threatens to win semeai for %1m\n",
pos, aa);
break;
case EITHER_MOVE:
reason1 = either_data[move_reasons[r].what].reason1;
reason2 = either_data[move_reasons[r].what].reason2;
worm1 = either_data[move_reasons[r].what].what1;
worm2 = either_data[move_reasons[r].what].what2;
gfprintf(out, "Move at %1m either %s %1m or %s %1m\n", pos,
reason1 == ATTACK_STRING ? "attacks" : "defends", worm1,
reason2 == ATTACK_STRING ? "attacks" : "defends", worm2);
break;
case ALL_MOVE:
reason1 = all_data[move_reasons[r].what].reason1;
reason2 = all_data[move_reasons[r].what].reason2;
worm1 = all_data[move_reasons[r].what].what1;
worm2 = all_data[move_reasons[r].what].what2;
gfprintf(out, "Move at %1m both %s %1m and %s %1m\n", pos,
reason1 == ATTACK_STRING ? "attacks" : "defends", worm1,
reason2 == ATTACK_STRING ? "attacks" : "defends", worm2);
break;
case OWL_ATTACK_MOVE:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m owl-attacks %1m\n", pos, aa);
break;
case OWL_ATTACK_MOVE_GOOD_KO:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m owl-attacks %1m with good ko\n", pos, aa);
break;
case OWL_ATTACK_MOVE_BAD_KO:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m owl-attacks %1m with bad ko\n", pos, aa);
break;
case OWL_ATTACK_MOVE_GAIN:
aa = either_data[move_reasons[r].what].what1;
bb = either_data[move_reasons[r].what].what2;
gfprintf(out, "Move at %1m owl-attacks %1m (captures %1m)\n",
pos, aa, bb);
break;
case OWL_DEFEND_MOVE:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m owl-defends %1m\n", pos, aa);
break;
case OWL_DEFEND_MOVE_GOOD_KO:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m owl-defends %1m with good ko\n", pos, aa);
break;
case OWL_DEFEND_MOVE_BAD_KO:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m owl-defends %1m with bad ko\n", pos, aa);
break;
case OWL_DEFEND_MOVE_LOSS:
aa = either_data[move_reasons[r].what].what1;
bb = either_data[move_reasons[r].what].what2;
gfprintf(out, "Move at %1m owl-defends %1m (loses %1m)\n",
pos, aa, bb);
break;
case OWL_ATTACK_THREAT:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m owl-threatens to attack %1m\n", pos, aa);
break;
case OWL_DEFEND_THREAT:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m owl-threatens to defend %1m\n", pos, aa);
break;
case OWL_PREVENT_THREAT:
aa = move_reasons[r].what;
gfprintf(out, "Move at %1m owl-prevents a threat to attack or defend %1m\n",
pos, aa);
break;
case EXPAND_TERRITORY_MOVE:
gfprintf(out, "Move at %1m expands territory\n", pos);
break;
case EXPAND_MOYO_MOVE:
gfprintf(out, "Move at %1m expands moyo\n", pos);
break;
case INVASION_MOVE:
gfprintf(out, "Move at %1m is an invasion\n", pos);
break;
case STRATEGIC_ATTACK_MOVE:
case STRATEGIC_DEFEND_MOVE:
aa = move_reasons[r].what;
if (move_reasons[r].type == STRATEGIC_ATTACK_MOVE)
gfprintf(out, "Move at %1m strategically attacks %1m\n", pos, aa);
else
gfprintf(out, "Move at %1m strategically defends %1m\n", pos, aa);
break;
case MY_ATARI_ATARI_MOVE:
gfprintf(out, "Move at %1m captures something\n", pos);
case YOUR_ATARI_ATARI_MOVE:
gfprintf(out, "Move at %1m defends against combination attack\n",
pos);
}
}
if (k > 0 && move[pos].move_safety == 0)
gfprintf(out, "Move at %1m strategically or tactically unsafe\n", pos);
}
return num_move_reasons;
}
/* This array lists rules according to which we set the status
* flags of a move reasons.
* The format is:
* { List of reasons to which the rule applies, condition of the rule,
* flags to be set, trace message }
* The condition must be of type discard_condition_fn_ptr, that is a pointer
* to a function with parameters (pos, what).
*
* FIXME: Add handling of ALL and EITHER moves for inessential worms.
*/
static struct discard_rule discard_rules[] =
{
{ { ATTACK_MOVE, ATTACK_MOVE_GOOD_KO,
ATTACK_MOVE_BAD_KO, ATTACK_THREAT,
DEFEND_MOVE, DEFEND_MOVE_GOOD_KO,
DEFEND_MOVE_BAD_KO, DEFEND_THREAT, -1 },
owl_move_vs_worm_known, TERRITORY_REDUNDANT,
" %1m: 0.0 - (threat of) attack/defense of %1m (owl attack/defense as well)\n" },
{ { SEMEAI_MOVE, SEMEAI_THREAT, -1 },
owl_move_reason_known, REDUNDANT,
" %1m: 0.0 - (threat to) win semeai involving %1m (owl move as well)\n"},
{ { SEMEAI_MOVE, SEMEAI_THREAT, -1 },
tactical_move_vs_whole_dragon_known, REDUNDANT,
" %1m: 0.0 - (threat to) win semeai involving %1m (tactical move as well)\n"},
{ { EITHER_MOVE, -1 },
either_worm_attackable, REDUNDANT,
" %1m: 0.0 - 'attack either' is redundant at %1m (direct att./def. as well)\n"},
{ { ALL_MOVE, -1 },
one_of_both_attackable, REDUNDANT,
" %1m: 0.0 - 'defend both' is redundant at %1m (direct att./def. as well)\n"},
{ { ATTACK_THREAT, DEFEND_THREAT, -1 },
concerns_inessential_worm, TERRITORY_REDUNDANT,
" %1m: 0.0 - attack/defense threat of %1m (inessential)\n"},
{ { OWL_ATTACK_THREAT, UNCERTAIN_OWL_DEFENSE, -1 },
concerns_inessential_dragon, REDUNDANT,
" %1m: 0.0 - (uncertain) owl attack/defense of %1m (inessential)\n"},
{ { ATTACK_MOVE, ATTACK_MOVE_GOOD_KO, ATTACK_MOVE_BAD_KO,
DEFEND_MOVE, DEFEND_MOVE_GOOD_KO, DEFEND_MOVE_BAD_KO, -1},
move_is_marked_unsafe, REDUNDANT,
" %1m: 0.0 - tactical move vs %1m (unsafe move)\n"},
{ { OWL_ATTACK_MOVE, OWL_ATTACK_MOVE_GOOD_KO, OWL_ATTACK_MOVE_BAD_KO,
OWL_DEFEND_MOVE, OWL_DEFEND_MOVE_GOOD_KO, OWL_DEFEND_MOVE_BAD_KO, -1},
concerns_noncritical_dragon, REDUNDANT,
" %1m: 0.0 - owl move vs %1m (non-critical)\n"},
{ { -1 }, NULL, 0, ""} /* Keep this entry at end of the list. */
};
/* This function checks the list of move reasons for redundant move
* reasons and marks them accordingly in their status field.
*/
void
discard_redundant_move_reasons(int pos)
{
int k1, k2;
int l;
for (k1 = 0; !(discard_rules[k1].reason_type[0] == -1); k1++) {
for (k2 = 0; !(discard_rules[k1].reason_type[k2] == -1); k2++) {
for (l = 0; l < MAX_REASONS; l++) {
int r = move[pos].reason[l];
if (r < 0)
break;
if ((move_reasons[r].type == discard_rules[k1].reason_type[k2])
&& (discard_rules[k1].condition(pos, move_reasons[r].what))) {
DEBUG(DEBUG_MOVE_REASONS, discard_rules[k1].trace_message,
pos, get_pos(move_reasons[r].type, move_reasons[r].what));
move_reasons[r].status |= discard_rules[k1].flags;
}
}
}
}
}
/* Look through the move reasons to see whether (pos) is an antisuji move. */
int
is_antisuji_move(int pos)
{
int k;
for (k = 0; k < MAX_REASONS; k++) {
int r = move[pos].reason[k];
if (r < 0)
break;
if (move_reasons[r].type == ANTISUJI_MOVE)
return 1; /* This move must not be played. End of story. */
}
return 0;
}
/* Increase the randomness scaling factor.
* This causes the move value to be more random.
*/
void
scale_randomness(int pos, float scaling)
{
if (scaling > move[pos].randomness_scaling)
move[pos].randomness_scaling = scaling;
}
/* Register the given `move' as a good attack threat against `target'. By
* "good" we mean a threat which is effectively a sente for the player.
* E.g. in this position the threat is good, because it results in four
* sente moves locally (trevord:950):
*
* ..OX..
* .O.*..
* .OXX..
* .OOX..
* ------
*
* We use this list of good threats for performance reasons so that
* estimate_territorial_value() in valuemoves.c doesn't have to read
* through all the moves. Such threats are found with patterns.
*/
void
register_good_attack_threat(int move, int target)
{
int k;
ASSERT_ON_BOARD1(move);
ASSERT_ON_BOARD1(target);
ASSERT1(IS_STONE(worm[target].color), move);
target = worm[target].origin;
for (k = 0; k < MAX_ATTACK_THREATS; k++) {
if (known_good_attack_threats[move][k] == target)
break;
if (known_good_attack_threats[move][k] == NO_MOVE) {
known_good_attack_threats[move][k] = target;
break;
}
}
}
/* Determine if an attack threat is registered as good (see above). */
int
is_known_good_attack_threat(int move, int target)
{
int k;
ASSERT_ON_BOARD1(move);
ASSERT_ON_BOARD1(target);
ASSERT1(IS_STONE(worm[target].color), move);
target = worm[target].origin;
for (k = 0; k < MAX_ATTACK_THREATS; k++) {
if (known_good_attack_threats[move][k] == target)
return 1;
if (known_good_attack_threats[move][k] == NO_MOVE)
break;
}
return 0;
}
/* Like documented in endgame:980, there are also moves which aren't
* safe by themselves, but attempting to capture these stones would
* result in a loss for the opponent (typically, by damezumari).
* Simple examples include snapbacks, but more complicated ones do
* exist. Following functions are helpers for the valuation processing
* which deal with such special cases.
*/
void
register_known_safe_move(int move)
{
ASSERT_ON_BOARD1(move);
known_safe_moves[move] = 1;
}
int
is_known_safe_move(int move)
{
ASSERT_ON_BOARD1(move);
return known_safe_moves[move];
}
/*
* Local Variables:
* tab-width: 8
* c-basic-offset: 2
* End:
*/