Initial commit of GNU Go v3.8.

[sgk-go] / engine / value_moves.c

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
* 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:
*/