/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* 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 <stdio.h>
#include "liberty.h"
#include "patterns.h"
/* Test whether apos and bpos can be cut. If yes, return 1 and
* store it in the cut list of dragons.c.
*/
int
disconnect_helper(int apos, int bpos)
{
int color = board[apos];
int move;
ASSERT1(color == board[bpos] && IS_STONE(color), apos);
if (disconnect(apos, bpos, &move)) {
add_cut(apos, bpos, move);
return 1;
}
return 0;
}
/* Try to match all (permutations of) connection patterns at (m,n).
* For each match, if it is a B pattern, set cutting point in
* cutting_points array. If it is a C pattern, amalgamate the dragons
* in the pattern.
*/
static void
cut_connect_callback(int anchor, int color, struct pattern *pattern,
int ll, void *data)
{
int move;
int k;
int first_dragon = NO_MOVE;
int second_dragon = NO_MOVE;
int other = OTHER_COLOR(color);
UNUSED(data);
move = AFFINE_TRANSFORM(pattern->move_offset, ll, anchor);
if ((pattern->class & CLASS_B) && !safe_move(move, other))
return;
if (pattern->class & CLASS_C) {
/* If C pattern, test if there are more than one dragon in this
* pattern so that there is something to connect, before doing any
* expensive reading.
*/
for (k = 0; k < pattern->patlen; ++k) { /* match each point */
/* transform pattern real coordinate */
int pos = AFFINE_TRANSFORM(pattern->patn[k].offset, ll, anchor);
/* Look for distinct dragons. */
if (pattern->patn[k].att == ATT_O) {
if (first_dragon == NO_MOVE)
first_dragon = dragon[pos].origin;
else if (second_dragon == NO_MOVE
&& dragon[pos].origin != first_dragon) {
second_dragon = dragon[pos].origin;
/* A second dragon found, no need to continue looping. */
break;
}
}
}
if (second_dragon == NO_MOVE)
return; /* Nothing to amalgamate. */
}
/* If the pattern has a constraint, call the autohelper to see
* if the pattern must be rejected.
*/
if (pattern->autohelper_flag & HAVE_CONSTRAINT) {
if (!pattern->autohelper(ll, move, color, 0))
return;
}
/* If the pattern has a helper, call it to see if the pattern must
* be rejected.
*/
if (pattern->helper) {
if (!pattern->helper(pattern, ll, move, color))
return;
}
if ((pattern->class & CLASS_B)
&& !(pattern->class & CLASS_s)) {
/* Require that the X stones in the pattern are tactically safe. */
for (k = 0; k < pattern->patlen; ++k) { /* match each point */
if (pattern->patn[k].att == ATT_X) {
/* transform pattern real coordinate */
int pos = AFFINE_TRANSFORM(pattern->patn[k].offset, ll, anchor);
if (attack(pos, NULL) == WIN
&& (move == NO_MOVE
|| !does_defend(move, pos)))
return; /* Match failed */
}
}
}
/* Get here => Pattern matches. */
if (pattern->class & CLASS_B) {
DEBUG(DEBUG_DRAGONS, "Cutting pattern %s+%d found at %1m\n",
pattern->name, ll, anchor);
DEBUG(DEBUG_DRAGONS, "cutting point %1m\n", move);
}
else if (pattern->class & CLASS_C)
DEBUG(DEBUG_DRAGONS, "Connecting pattern %s+%d found at %1m\n",
pattern->name, ll, anchor);
/* does the pattern have an action? */
if (pattern->autohelper_flag & HAVE_ACTION) {
pattern->autohelper(ll, move, color, 1);
}
/* If it is a B pattern, set cutting point. */
if (pattern->class & CLASS_B) {
cutting_points[move] |= color;
}
else if (!(pattern->class & CLASS_C))
return; /* Nothing more to do, up to the helper or autohelper
to amalgamate dragons or modify eye space. */
/* If it is a C pattern, find the dragons to connect.
* If it is a B pattern, find eye space points to inhibit connection
* through.
*/
first_dragon = NO_MOVE;
second_dragon = NO_MOVE;
for (k = 0; k < pattern->patlen; ++k) { /* match each point */
/* transform pattern real coordinate */
int pos = AFFINE_TRANSFORM(pattern->patn[k].offset, ll, anchor);
/* Look for dragons to amalgamate. Never amalgamate stones which
* can be attacked.
*/
if ((pattern->class & CLASS_C)
&& board[pos] == color
&& pattern->patn[k].att == ATT_O
&& ((pattern->class & CLASS_s) || attack(pos, NULL) == 0)) {
if (first_dragon == NO_MOVE)
first_dragon = dragon[pos].origin;
else if (second_dragon == NO_MOVE
&& dragon[pos].origin != first_dragon) {
second_dragon = dragon[pos].origin;
/* A second dragon found, we amalgamate them at once. */
/* Want this output if verbose or DEBUG_DRAGONS is on. */
if (verbose || (debug & DEBUG_DRAGONS))
gprintf("Pattern %s joins %C dragons %1m, %1m\n",
pattern->name, color, first_dragon, second_dragon);
join_dragons(second_dragon, first_dragon);
/* Now look for another second dragon. */
second_dragon = NO_MOVE;
first_dragon = dragon[pos].origin;
}
}
/* Inhibit connections */
if (pattern->class & CLASS_B) {
if (pattern->patn[k].att != ATT_not)
break; /* The inhibition points are guaranteed to come first. */
cutting_points[pos] |= color;
DEBUG(DEBUG_DRAGONS, "inhibiting connection at %1m\n", pos);
}
} /* loop over elements */
}
/* Only consider B patterns. */
static void
cut_callback(int anchor, int color, struct pattern *pattern, int ll,
void *data)
{
if (pattern->class & CLASS_B)
cut_connect_callback(anchor, color, pattern, ll, data);
}
/* Consider C patterns and those without classification. */
static void
conn_callback(int anchor, int color, struct pattern *pattern, int ll,
void *data)
{
if (!(pattern->class & CLASS_B))
cut_connect_callback(anchor, color, pattern, ll, data);
}
/* Find cutting points which should inhibit amalgamations and sever
* the adjacent eye space.
*/
void
find_cuts(void)
{
matchpat(cut_callback, ANCHOR_COLOR, &conn_db, NULL, NULL);
}
/* Find explicit connection patterns and amalgamate the involved dragons. */
void
find_connections(void)
{
matchpat(conn_callback, ANCHOR_COLOR, &conn_db, NULL, NULL);
}
/*
* Local Variables:
* tab-width: 8
* c-basic-offset: 2
* End:
*/