Ticket #162: worm_data.diff

engine/aftermath.c

@@ -2 +2 @@
  * 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 and 2006       *
+ * Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 and 2007 *
  * by the Free Software Foundation.                                  *
  *                                                                   *
  * This program is free software; you can redistribute it and/or     *
@@ -501 +501 @@
           safety = INVINCIBLE;
         
         if (k < 4) {
-          int apos = worm[pos2].origin;
+          int apos = find_origin(pos2);
           int count_lib = countlib(apos);
           
           if (!mx[apos]) {

engine/combination.c

@@ -572 +572 @@
    */
   for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
     if (board[pos] == other
-        && worm[pos].origin == pos
-        && worm[pos].liberties == 2
+        && find_origin(pos) == pos
+        && countlib(pos) == 2
         && aa_status[pos] == ALIVE) {
       int libs[2];
       findlib(pos, 2, libs);
@@ -587 +587 @@
       if (!owl_substantial(pos)) {
         int pos2;
         for (pos2 = BOARDMIN; pos2 < BOARDMAX; pos2++)
-          if (ON_BOARD(pos2) && is_worm_origin(pos2, pos))
+          if (IS_STONE(board[pos2]) && is_worm_origin(pos2, pos))
             aa_status[pos2] = INSUBSTANTIAL;
       }
     }

engine/dragon.c

@@ -2 +2 @@
  * 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 and 2006       *
+ * Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 and 2007 *
  * by the Free Software Foundation.                                  *
  *                                                                   *
  * This program is free software; you can redistribute it and/or     *
@@ -442 +442 @@
     if (ON_BOARD(str)) {
       int food;
 
-      if (worm[str].origin != str
-          || board[str] == EMPTY
+      if (board[str] == EMPTY
+          || find_origin(str) != str
           || worm[str].lunch == NO_MOVE)
         continue;
 
@@ -571 +571 @@
    */
 
   for (str = BOARDMIN; str < BOARDMAX; str++)
-    if (ON_BOARD(str)) {
+    if (IS_STONE(board[str])) {
       if (is_worm_origin(str, str)
           && worm[str].attack_codes[0] != 0
           && worm[str].defense_codes[0] != 0

engine/liberty.h

@@ -797 +797 @@
 
 #define MAX_TACTICAL_POINTS 10
 
+/* all this data is valid only, when stackp==0 */
 struct worm_data {
   int color;         /* its color */
   int size;          /* its cardinality */

engine/move_reasons.c

@@ -2 +2 @@
  * 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 and 2006       *
+ * Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 and 2007 *
  * by the Free Software Foundation.                                  *
  *                                                                   *
  * This program is free software; you can redistribute it and/or     *
@@ -463 +463 @@
 int
 attack_move_reason_known(int pos, int what)
 {
-  ASSERT1(IS_STONE(board[what]), what);
-  what = worm[what].origin;
+  if (what > 0) {
+    ASSERT_ON_BOARD1(what);
+    ASSERT1(IS_STONE(board[what]), what);
+    ASSERT1(board[what] == worm[what].color, what);
+    what = worm[what].origin;
+  }
+
   if (move_reason_known(pos, ATTACK_MOVE, what))
     return WIN;
   if (move_reason_known(pos, ATTACK_MOVE_GOOD_KO, what))
@@ -481 +486 @@
 int
 defense_move_reason_known(int pos, int what)
 {
-  ASSERT1(IS_STONE(board[what]), what);
-  what = worm[what].origin;
+  if (what > 0) {
+    ASSERT_ON_BOARD1(what);
+    ASSERT1(IS_STONE(board[what]), what);
+    ASSERT1(board[what] == worm[what].color, what);
+    what = worm[what].origin;
+  }
+
   if (move_reason_known(pos, DEFEND_MOVE, what))
     return WIN;
   if (move_reason_known(pos, DEFEND_MOVE_GOOD_KO, what))
@@ -510 +520 @@
 int
 owl_attack_move_reason_known(int pos, int what)
 {
+  if (what > 0) {
+    ASSERT_ON_BOARD1(what);
+    ASSERT1(IS_STONE(board[what]), what);
+    ASSERT1(board[what] == dragon[what].color, what);
+    what = dragon[what].origin;
+  }
+
   if (move_reason_known(pos, OWL_ATTACK_MOVE, what))
     return WIN;
   if (move_reason_known(pos, OWL_ATTACK_MOVE_GOOD_KO, what))
@@ -526 +543 @@
 int
 owl_defense_move_reason_known(int pos, int what)
 {
+  if (what > 0) {
+    ASSERT_ON_BOARD1(what);
+    ASSERT1(IS_STONE(board[what]), what);
+    ASSERT1(board[what] == dragon[what].color, what);
+    what = dragon[what].origin;
+  }
+
   if (move_reason_known(pos, OWL_DEFEND_MOVE, what))
     return WIN;
   if (move_reason_known(pos, OWL_DEFEND_MOVE_GOOD_KO, what))
@@ -553 +577 @@
 static int
 owl_move_vs_worm_known(int pos, int what)
 {
-  return owl_move_reason_known(pos, dragon[what].origin);
+  return owl_move_reason_known(pos, what);
 }
 
 int
 semeai_move_reason_known(int pos, int what)
 {
-  return move_reason_known(pos, SEMEAI_MOVE, what);
+  ASSERT_ON_BOARD1(what);
+  ASSERT1(IS_STONE(board[what]), what);
+  ASSERT1(board[what] == dragon[what].color, what);
+  return move_reason_known(pos, SEMEAI_MOVE, dragon[what].origin);
 }
 
 /* Check whether a worm is inessential */
@@ -637 +664 @@
 add_attack_move(int pos, int ww, int code)
 {
   ASSERT_ON_BOARD1(ww);
+  ASSERT1(IS_STONE(board[ww]), ww);
+  ASSERT1(board[ww] == worm[ww].color, ww);
   ww = worm[ww].origin;
 
   if (code == WIN)
@@ -655 +684 @@
 add_defense_move(int pos, int ww, int code)
 {
   ASSERT_ON_BOARD1(ww);
+  ASSERT1(IS_STONE(board[ww]), ww);
+  ASSERT1(board[ww] == worm[ww].color, ww);
   ww = worm[ww].origin;
 
   if (code == WIN)
@@ -673 +704 @@
 add_attack_threat_move(int pos, int ww, int code)
 {
   UNUSED(code);
-  
+
   ASSERT_ON_BOARD1(ww);
+  ASSERT1(IS_STONE(board[ww]), ww);
+  ASSERT1(board[ww] == worm[ww].color, ww);
+  
   add_move_reason(pos, ATTACK_THREAT, worm[ww].origin);
 }
 
@@ -684 +718 @@
 remove_attack_threat_move(int pos, int ww)
 {
   ASSERT_ON_BOARD1(ww);
+  ASSERT1(IS_STONE(board[ww]), ww);
+  ASSERT1(board[ww] == worm[ww].color, ww);
+
   remove_move_reason(pos, ATTACK_THREAT, worm[ww].origin);
 }
 
@@ -697 +734 @@
   UNUSED(code);
 
   ASSERT_ON_BOARD1(ww);
+  ASSERT1(IS_STONE(board[ww]), ww);
+  ASSERT1(board[ww] == worm[ww].color, ww);
+
   add_move_reason(pos, DEFEND_THREAT, worm[ww].origin);
 }
 
@@ -787 +827 @@
 
 /*
  * Add to the reasons for the move at (pos) that it connects the
- * dragons at (dr1) and (dr2). Require that the dragons are
- * distinct.
+ * worms at (w1) and (w2).
  */
 void
 add_connection_move(int pos, int w1, int w2)
@@ -796 +835 @@
   int connection;
 
   ASSERT_ON_BOARD1(w1);
+  ASSERT1(IS_STONE(board[w1]), w1);
+  ASSERT1(board[w1] == worm[w1].color, w1);
   ASSERT_ON_BOARD1(w2);
+  ASSERT1(IS_STONE(board[w2]), w2);
+  ASSERT1(board[w2] == worm[w2].color, w2);
   ASSERT1(worm[w1].color == worm[w2].color, w1);
   if (worm[w1].origin == worm[w2].origin)
     return;
@@ -807 +850 @@
 
 /*
  * Add to the reasons for the move at (pos) that it cuts the
- * dragons at (dr1) and (dr2). Require that the dragons are
- * distinct.
+ * worms at (w1) and (w2).
  */
 void
 add_cut_move(int pos, int w1, int w2)
@@ -816 +858 @@
   int connection;
 
   ASSERT_ON_BOARD1(w1);
+  ASSERT1(IS_STONE(board[w1]), w1);
+  ASSERT1(board[w1] == worm[w1].color, w1);
   ASSERT_ON_BOARD1(w2);
+  ASSERT1(IS_STONE(board[w2]), w2);
+  ASSERT1(board[w2] == worm[w2].color, w2);
   ASSERT1(worm[w1].color == worm[w2].color, w1);
   if (worm[w1].origin == worm[w2].origin)
     return;
+  
   connection = find_connection(worm[w1].origin, worm[w2].origin);
   
   /*
@@ -857 +904 @@
 add_semeai_move(int pos, int dr)
 {
   ASSERT_ON_BOARD1(dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
   add_move_reason(pos, SEMEAI_MOVE, dragon[dr].origin);
 }
 
@@ -867 +916 @@
 static void
 add_potential_semeai_move(int pos, int type, int dr1, int dr2)
 {
-  ASSERT1(ON_BOARD(dr1), pos);
-  ASSERT1(ON_BOARD(dr2), pos);
+  ASSERT_ON_BOARD1(dr1);
+  ASSERT1(IS_STONE(board[dr1]), dr1);
+  ASSERT1(board[dr1] == dragon[dr1].color, dr1);
+  ASSERT_ON_BOARD1(dr2);
+  ASSERT1(IS_STONE(board[dr2]), dr2);
+  ASSERT1(board[dr2] == dragon[dr2].color, dr2);
+
   if (next_semeai >= MAX_POTENTIAL_SEMEAI)
     DEBUG(DEBUG_MOVE_REASONS,
           "Potential semeai move at %1m dropped as list was full\n", pos);
   else {
-    semeai_target1[next_semeai] = dr1;
-    semeai_target2[next_semeai] = dr2;
+    semeai_target1[next_semeai] = dragon[dr1].origin;
+    semeai_target2[next_semeai] = dragon[dr2].origin;
     add_move_reason(pos, type, next_semeai);
     next_semeai++;
   }
@@ -887 +941 @@
 void
 add_potential_semeai_attack(int pos, int dr1, int dr2)
 {
+  ASSERT_ON_BOARD1(dr1);
+  ASSERT1(IS_STONE(board[dr1]), dr1);
+  ASSERT1(board[dr1] == dragon[dr1].color, dr1);
+  ASSERT_ON_BOARD1(dr2);
+  ASSERT1(IS_STONE(board[dr2]), dr2);
+  ASSERT1(board[dr2] == dragon[dr2].color, dr2);
   add_potential_semeai_move(pos, POTENTIAL_SEMEAI_ATTACK, dr1, dr2);
 }
 
@@ -897 +957 @@
 void
 add_potential_semeai_defense(int pos, int dr1, int dr2)
 {
+  ASSERT_ON_BOARD1(dr1);
+  ASSERT1(IS_STONE(board[dr1]), dr1);
+  ASSERT1(board[dr1] == dragon[dr1].color, dr1);
+  ASSERT_ON_BOARD1(dr2);
+  ASSERT1(IS_STONE(board[dr2]), dr2);
+  ASSERT1(board[dr2] == dragon[dr2].color, dr2);
   add_potential_semeai_move(pos, POTENTIAL_SEMEAI_DEFENSE, dr1, dr2);
 }
 
@@ -911 +977 @@
 add_semeai_threat(int pos, int dr)
 {
   ASSERT_ON_BOARD1(dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
   add_move_reason(pos, SEMEAI_THREAT, dragon[dr].origin);
 }
 
@@ -949 +1017 @@
   switch (reason1) {
   case ATTACK_STRING:
     {
+      ASSERT1(IS_STONE(board[target1]), target1);
+      ASSERT1(board[target1] == worm[target1].color, target1);
       what1 = worm[target1].origin;
 
       /* If this string is already attacked, and with no defense, then
@@ -966 +1036 @@
   switch (reason2) {
   case ATTACK_STRING:
     {
+      ASSERT1(IS_STONE(board[target2]), target2);
+      ASSERT1(board[target2] == worm[target2].color, target2);
       what2 = worm[target2].origin;
 
       /* If this string is already attacked, and with no defense, then
@@ -1019 +1091 @@
 
   switch (reason1) {
   case DEFEND_STRING:
+    ASSERT1(IS_STONE(board[target1]), target1);
+    ASSERT1(board[target1] == worm[target1].color, target1);
     what1 = worm[target1].origin;
     break;
 
@@ -1028 +1102 @@
 
   switch (reason2) {
   case DEFEND_STRING:
+    ASSERT1(IS_STONE(board[target2]), target2);
+    ASSERT1(board[target2] == worm[target2].color, target2);
     what2 = worm[target2].origin;
     break;
 
@@ -1043 +1119 @@
 void
 add_loss_move(int pos, int target1, int target2)
 {
-  int what1 = dragon[target1].origin;
-  int what2 = worm[target2].origin;
-  int index = find_pair_data(what1, what2);
-  ASSERT1(target2 != NO_MOVE, pos);
+  int index;
+
+  ASSERT_ON_BOARD1(target1);
+  ASSERT1(IS_STONE(board[target1]), target1);
+  ASSERT1(board[target1] == dragon[target1].color, target1);
+  ASSERT_ON_BOARD1(target2);
+  ASSERT1(IS_STONE(board[target2]), target2);
+  ASSERT1(board[target2] == worm[target2].color, target2);
+
+  index = find_pair_data(dragon[target1].origin,
+                         worm[target2].origin);
   add_move_reason(pos, OWL_DEFEND_MOVE_LOSS, index);
 }
 
@@ -1121 +1204 @@
 void
 add_strategical_attack_move(int pos, int dr)
 {
-  dr = dragon[dr].origin;
   ASSERT_ON_BOARD1(dr);
-  add_move_reason(pos, STRATEGIC_ATTACK_MOVE, dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
+  add_move_reason(pos, STRATEGIC_ATTACK_MOVE, dragon[dr].origin);
 }
 
 /*
@@ -1133 +1217 @@
 void
 add_strategical_defense_move(int pos, int dr)
 {
-  dr = dragon[dr].origin;
   ASSERT_ON_BOARD1(dr);
-  add_move_reason(pos, STRATEGIC_DEFEND_MOVE, dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
+  add_move_reason(pos, STRATEGIC_DEFEND_MOVE, dragon[dr].origin);
 }
 
 /*
@@ -1145 +1230 @@
 void
 add_owl_attack_move(int pos, int dr, int kworm, int code)
 {
+  ASSERT_ON_BOARD1(dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
   dr = dragon[dr].origin;
 
-  ASSERT_ON_BOARD1(dr);
   if (code == WIN)
     add_move_reason(pos, OWL_ATTACK_MOVE, dr);
   else if (code == KO_A)
@@ -1156 +1243 @@
     add_move_reason(pos, OWL_ATTACK_MOVE_BAD_KO, dr);
   else if (code == GAIN) {
     ASSERT_ON_BOARD1(kworm);
+    ASSERT1(IS_STONE(board[kworm]), kworm);
+    ASSERT1(board[kworm] == worm[kworm].color, kworm);
     add_move_reason(pos, OWL_ATTACK_MOVE_GAIN, find_pair_data(dr, kworm));
   }
 }
@@ -1167 +1256 @@
 void
 add_owl_defense_move(int pos, int dr, int code)
 {
+  ASSERT_ON_BOARD1(dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
   dr = dragon[dr].origin;
 
-  ASSERT_ON_BOARD1(dr);
   if (code == WIN)
     add_move_reason(pos, OWL_DEFEND_MOVE, dr);
   else if (code == KO_A)
@@ -1188 +1279 @@
 add_owl_attack_threat_move(int pos, int dr, int code)
 {
   UNUSED(code);
-  dr = dragon[dr].origin;
-  
   ASSERT_ON_BOARD1(dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
   add_move_reason(pos, OWL_ATTACK_THREAT, dragon[dr].origin);
   add_worthwhile_threat_move(pos);
 }
@@ -1202 +1293 @@
 void
 add_owl_uncertain_defense_move(int pos, int dr)
 {
-  dr = dragon[dr].origin;
   ASSERT_ON_BOARD1(dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
   add_move_reason(pos, UNCERTAIN_OWL_DEFENSE, dragon[dr].origin);
 }
 
@@ -1214 +1306 @@
 void
 add_owl_uncertain_attack_move(int pos, int dr)
 {
-  dr = dragon[dr].origin;
   ASSERT_ON_BOARD1(dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
   add_move_reason(pos, UNCERTAIN_OWL_ATTACK, dragon[dr].origin);
 }
 
@@ -1229 +1322 @@
 add_owl_defense_threat_move(int pos, int dr, int code)
 {
   UNUSED(code);
-  dr = dragon[dr].origin;
-
   ASSERT_ON_BOARD1(dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
   add_move_reason(pos, OWL_DEFEND_THREAT, dragon[dr].origin);
   add_worthwhile_threat_move(pos);
 }
@@ -1269 +1362 @@
 add_owl_prevent_threat_move(int pos, int dr)
 {
   ASSERT_ON_BOARD1(dr);
+  ASSERT1(IS_STONE(board[dr]), dr);
+  ASSERT1(board[dr] == dragon[dr].color, dr);
   add_move_reason(pos, OWL_PREVENT_THREAT, dragon[dr].origin);
 }
 
@@ -1418 +1513 @@
      * move is unsafe.
      */
     if (move_reasons[r].type == DEFEND_MOVE)
-      mark_string(worm[what].origin, saved, 1);
+      mark_string(what, saved, 1);
     else if (move_reasons[r].type == OWL_DEFEND_MOVE_LOSS) {
       int origin = dragon[what].origin;
       int kworm = worm[what].origin;
@@ -1426 +1521 @@
       for (ii = BOARDMIN; ii < BOARDMAX; ii++)
         if (IS_STONE(board[ii]) && dragon[ii].origin == origin
             && worm[ii].origin != kworm)
-          mark_string(worm[ii].origin, saved, 1);
+          mark_string(ii, saved, 1);
     }
   }    
 }
@@ -1990 +2085 @@
   int k;
   ASSERT_ON_BOARD1(move);
   ASSERT_ON_BOARD1(target);
-  ASSERT1(IS_STONE(worm[target].color), move);
+  ASSERT1(IS_STONE(board[target]), target);
+  ASSERT1(board[target] == worm[target].color, target);
 
   target = worm[target].origin;
   for (k = 0; k < MAX_ATTACK_THREATS; k++) {
@@ -2011 +2107 @@
   int k;
   ASSERT_ON_BOARD1(move);
   ASSERT_ON_BOARD1(target);
-  ASSERT1(IS_STONE(worm[target].color), move);
+  ASSERT1(IS_STONE(board[target]), target);
+  ASSERT1(board[target] == worm[target].color, target);
 
   target = worm[target].origin;
   for (k = 0; k < MAX_ATTACK_THREATS; k++) {

engine/owl.c

@@ -454 +454 @@
   if (verbose > 0)
     verbose--;
   for (str = BOARDMIN; str < BOARDMAX; str++) 
-    if (ON_BOARD(str) && ms[str] && worm[str].origin == str) {
+    if (ON_BOARD(str) && ms[str] && find_origin(str) == str) {
       int adj;
       int adjs[MAXCHAIN];
       int k;
@@ -1947 +1947 @@
         if (board[worm_goal] == EMPTY
             || countlib(worm_goal) > 1)
           continue;
-        if (worm[worm_goal].size > size) {
+        if (countstones(worm_goal) > size) {
           saveworm = k;
-          size = worm[worm_goal].size;
+          size = countstones(worm_goal);
         }
       }
       if (saveworm != MAX_GOAL_WORMS && size >= 3) {
         acode = GAIN;
-        findlib(worm[owl_goal_worm[saveworm]].origin, 1, &mpos);
+        findlib(find_origin(owl_goal_worm[saveworm]), 1, &mpos);
         /* ASSERT1( ... */
       }
     }
@@ -4636 +4636 @@
 
   for (pos = BOARDMIN; pos < BOARDMAX; pos++)
     if (ON_BOARD(pos)) {
-      if (is_same_worm(pos, apos) || is_same_worm(pos, bpos))
+      if (IS_STONE(board[pos])
+          && (is_same_worm(pos, apos) || is_same_worm(pos, bpos)))
         owl->goal[pos] = 1;
       else
         owl->goal[pos] = 0;
@@ -6916 +6917 @@
         continue;
 
       for (ii = BOARDMIN; ii < BOARDMAX && w < MAX_GOAL_WORMS; ii++)
-        if (ON_BOARD(ii) && board[ii] && worm[ii].origin == ii
-            && worm[ii].size >= 3 && dragon[ii].id == d)
+        if (IS_STONE(board[ii]) && find_origin(ii) == ii
+            && countstones(ii) >= 3 && dragon[ii].id == d)
           goal_worm[w++] = ii;
     }
   }

engine/utils.c

@@ -2 +2 @@
  * 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 and 2006       *
+ * Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 and 2007 *
  * by the Free Software Foundation.                                  *
  *                                                                   *
  * This program is free software; you can redistribute it and/or     *
@@ -1075 +1075 @@
      */
     if (board[bpos] != color)
       continue;
-    if (liberties <= worm[bpos].liberties
+    if (liberties <= countlib(bpos)
         && liberties <= 4)
       trouble = 1;
     else
@@ -1139 +1139 @@
               *return_value += 2.0 * worm[kworm].effective_size;
               if (safe_stones)
                 for (ii = BOARDMIN; ii < BOARDMAX; ii++)
-                  if (ON_BOARD(ii) && worm[ii].origin == worm[kworm].origin)
+                  if (IS_STONE(board[ii]) && is_same_worm(ii, kworm))
                     safe_stones[ii] = 0;
             }
           }
@@ -1148 +1148 @@
           *return_value += 2.0 * worm[kworm].effective_size;
           if (safe_stones)
             for (ii = BOARDMIN; ii < BOARDMAX; ii++)
-              if (ON_BOARD(ii) && worm[ii].origin == worm[kworm].origin)
+              if (IS_STONE(board[ii]) && is_same_worm(ii, kworm))
                 safe_stones[ii] = 0;
         }
       }
@@ -1182 +1182 @@
   
   for (pos = BOARDMIN; pos < BOARDMAX; pos++) {
     if (!IS_STONE(board[pos])
-        || worm[pos].origin != pos
+        || find_origin(pos) != pos
         || pos == move)
       continue;
     
@@ -1217 +1217 @@
       *return_value += worm[pos].effective_size;
       if (safe_stones) /* Can't use mark_string. */
         for (ii = BOARDMIN; ii < BOARDMAX; ii++)
-          if (worm[ii].origin == worm[pos].origin)
+          if (IS_STONE(board[ii]) && is_same_worm(ii, pos))
             safe_stones[ii] = 0;
     }
     else if (board[pos] == other
-             && worm[pos].origin == pos
+             && find_origin(pos) == pos
              && worm[pos].attack_codes[0] != 0
              && worm[pos].defense_codes[0] == 0
              && find_defense(pos, NULL)) {