board.c

   1 /*
   2 ** board.c
   3 ** $Id$
   4 **
   5 ** logging will only occur if the log-flag for a board is different from NULL
   6 */
   7 /*
   8 **    Copyright (C) 1998 Kurt Van den Branden
   9 **
  10 ** This program is free software; you can redistribute it and/or modify
  11 ** it under the terms of the GNU General Public License as published by
  12 ** the Free Software Foundation; either version 2 of the License, or
  13 ** (at your option) any later version.
  14 **
  15 ** This program is distributed in the hope that it will be useful,
  16 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ** GNU General Public License for more details.
  19 **
  20 ** You should have received a copy of the GNU General Public License
  21 ** along with this program; if not, write to the Free Software
  22 ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23 */
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include "board.h"
  27
  28 #undef WINGIPF
  29 #ifdef WINGIPF
  30 extern void waitremrow (board * oldb, rem_row * row, board * newb);
  31 extern void waitremgipf (board * oldb, position * gipf, board * newb);
  32
  33 extern void animatemove (board * oldb, listheader * pieces, board * newb);
  34
  35 typedef struct {
  36     char piece;
  37     position from;
  38     position to;
  39 } piecemove;
  40 #endif
  41
  42 int _colsize[] = {0, 5, 6, 7, 8, 7, 6, 5, 0};
  43
  44 char _colchar[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'};
  45
  46 /* 42 different possible moves, without gipf-pieces */
  47 fromto allmovesn[] = {
  48               {"b1","b2",'n'},        {"a1","b2",'n'},        {"a2","b2",'n'},
  49               {"a2","b3",'n'},        {"a3","b3",'n'},
  50               {"a3","b4",'n'},        {"a4","b4",'n'},
  51               {"a4","b5",'n'},        {"a5","b5",'n'},        {"b6","b5",'n'},
  52               {"b6","c6",'n'},        {"c7","c6",'n'},
  53               {"c7","d7",'n'},        {"d8","d7",'n'},
  54               {"d8","e8",'n'},        {"e9","e8",'n'},        {"f8","e8",'n'},
  55               {"f8","f7",'n'},        {"g7","f7",'n'},
  56               {"g7","g6",'n'},        {"h6","g6",'n'},
  57               {"h6","h5",'n'},        {"i5","h5",'n'},        {"i4","h5",'n'},
  58               {"i4","h4",'n'},        {"i3","h4",'n'},
  59               {"i3","h3",'n'},        {"i2","h3",'n'},
  60               {"i2","h2",'n'},        {"i1","h2",'n'},        {"h1","h2",'n'},
  61               {"h1","g2",'n'},        {"g1","g2",'n'},
  62               {"g1","f2",'n'},        {"f1","f2",'n'},
  63               {"f1","e2",'n'},        {"e1","e2",'n'},        {"d1","e2",'n'},
  64               {"d1","d2",'n'},        {"c1","d2",'n'},
  65               {"c1","c2",'n'},        {"b1","c2",'n'}
  66 };
  67
  68 /* 84 different possible moves, with gipf-pieces */
  69 fromto allmovesg[] = {
  70               {"b1","b2",'g'},        {"a1","b2",'g'},        {"a2","b2",'g'},
  71               {"a2","b3",'g'},        {"a3","b3",'g'},
  72               {"a3","b4",'g'},        {"a4","b4",'g'},
  73               {"a4","b5",'g'},        {"a5","b5",'g'},        {"b6","b5",'g'},
  74               {"b6","c6",'g'},        {"c7","c6",'g'},
  75               {"c7","d7",'g'},        {"d8","d7",'g'},
  76               {"d8","e8",'g'},        {"e9","e8",'g'},        {"f8","e8",'g'},
  77               {"f8","f7",'g'},        {"g7","f7",'g'},
  78               {"g7","g6",'g'},        {"h6","g6",'g'},
  79               {"h6","h5",'g'},        {"i5","h5",'g'},        {"i4","h5",'g'},
  80               {"i4","h4",'g'},        {"i3","h4",'g'},
  81               {"i3","h3",'g'},        {"i2","h3",'g'},
  82               {"i2","h2",'g'},        {"i1","h2",'g'},        {"h1","h2",'g'},
  83               {"h1","g2",'g'},        {"g1","g2",'g'},
  84               {"g1","f2",'g'},        {"f1","f2",'g'},
  85               {"f1","e2",'g'},        {"e1","e2",'g'},        {"d1","e2",'g'},
  86               {"d1","d2",'g'},        {"c1","d2",'g'},
  87               {"c1","c2",'g'},        {"b1","c2",'g'},
  88               {"b1","b2",'n'},        {"a1","b2",'n'},        {"a2","b2",'n'},
  89               {"a2","b3",'n'},        {"a3","b3",'n'},
  90               {"a3","b4",'n'},        {"a4","b4",'n'},
  91               {"a4","b5",'n'},        {"a5","b5",'n'},        {"b6","b5",'n'},
  92               {"b6","c6",'n'},        {"c7","c6",'n'},
  93               {"c7","d7",'n'},        {"d8","d7",'n'},
  94               {"d8","e8",'n'},        {"e9","e8",'n'},        {"f8","e8",'n'},
  95               {"f8","f7",'n'},        {"g7","f7",'n'},
  96               {"g7","g6",'n'},        {"h6","g6",'n'},
  97               {"h6","h5",'n'},        {"i5","h5",'n'},        {"i4","h5",'n'},
  98               {"i4","h4",'n'},        {"i3","h4",'n'},
  99               {"i3","h3",'n'},        {"i2","h3",'n'},
 100               {"i2","h2",'n'},        {"i1","h2",'n'},        {"h1","h2",'n'},
 101               {"h1","g2",'n'},        {"g1","g2",'n'},
 102               {"g1","f2",'n'},        {"f1","f2",'n'},
 103               {"f1","e2",'n'},        {"e1","e2",'n'},        {"d1","e2",'n'},
 104               {"d1","d2",'n'},        {"c1","d2",'n'},
 105               {"c1","c2",'n'},        {"b1","c2",'n'}
 106 };
 107
 108
 109 /*
 110 ** list of all the neighbours of a board-position
 111 **
 112 **                         3
 113 **                    1         5
 114 **                        pos
 115 **                    0         4
 116 **                         2
 117 */
 118 unsigned char b_buren[9][9][6][2] = {
 119   {{{0}}/* row a */},
 120   {/* row b */
 121     {{0}},
 122     {{0}},
 123     {{0, 0}, {0, 0}, {0, 0}, {1, 3}, {2, 2}, {2, 3}}, /* b2 */
 124     {{0, 0}, {0, 0}, {1, 2}, {1, 4}, {2, 3}, {2, 4}}, /* b3 */
 125     {{0, 0}, {0, 0}, {1, 3}, {1, 5}, {2, 4}, {2, 5}}, /* b4 */
 126     {{0, 0}, {0, 0}, {1, 4}, {0, 0}, {2, 5}, {2, 6}}  /* b5 */
 127   },
 128   {/* row c */
 129     {{0}},
 130     {{0}},
 131     {{0, 0}, {1, 2}, {0, 0}, {2, 3}, {3, 2}, {3, 3}}, /* c2 */
 132     {{1, 2}, {1, 3}, {2, 2}, {2, 4}, {3, 3}, {3, 4}}, /* c3 */
 133     {{1, 3}, {1, 4}, {2, 3}, {2, 5}, {3, 4}, {3, 5}}, /* c4 */
 134     {{1, 4}, {1, 5}, {2, 4}, {2, 6}, {3, 5}, {3, 6}}, /* c5 */
 135     {{1, 5}, {0, 0}, {2, 5}, {0, 0}, {3, 6}, {3, 7}}  /* c6 */
 136   },
 137   {/* row d */
 138     {{0}},
 139     {{0}},
 140     {{0, 0}, {2, 2}, {0, 0}, {3, 3}, {4, 2}, {4, 3}}, /* d2 */
 141     {{2, 2}, {2, 3}, {3, 2}, {3, 4}, {4, 3}, {4, 4}}, /* d3 */
 142     {{2, 3}, {2, 4}, {3, 3}, {3, 5}, {4, 4}, {4, 5}}, /* d4 */
 143     {{2, 4}, {2, 5}, {3, 4}, {3, 6}, {4, 5}, {4, 6}}, /* d5 */
 144     {{2, 5}, {2, 6}, {3, 5}, {3, 7}, {4, 6}, {4, 7}}, /* d6 */
 145     {{2, 6}, {0, 0}, {3, 6}, {0, 0}, {4, 7}, {4, 8}}  /* d7 */
 146   },
 147   {/* row e */
 148     {{0}},
 149     {{0}},
 150     {{0, 0}, {3, 2}, {0, 0}, {4, 3}, {0, 0}, {5, 2}}, /* e2 */
 151     {{3, 2}, {3, 3}, {4, 2}, {4, 4}, {5, 2}, {5, 3}}, /* e3 */
 152     {{3, 3}, {3, 4}, {4, 3}, {4, 5}, {5, 3}, {5, 4}}, /* e4 */
 153     {{3, 4}, {3, 5}, {4, 4}, {4, 6}, {5, 4}, {5, 5}}, /* e5 */
 154     {{3, 5}, {3, 6}, {4, 5}, {4, 7}, {5, 5}, {5, 6}}, /* e6 */
 155     {{3, 6}, {3, 7}, {4, 6}, {4, 8}, {5, 6}, {5, 7}}, /* e7 */
 156     {{3, 7}, {0, 0}, {4, 7}, {0, 0}, {5, 7}, {0, 0}}  /* e8 */
 157   },
 158   {/* row f */
 159     {{0}},
 160     {{0}},
 161     {{4, 2}, {4, 3}, {0, 0}, {5, 3}, {0, 0}, {6, 2}}, /* f2 */
 162     {{4, 3}, {4, 4}, {5, 2}, {5, 4}, {6, 2}, {6, 3}}, /* f3 */
 163     {{4, 4}, {4, 5}, {5, 3}, {5, 5}, {6, 3}, {6, 4}}, /* f4 */
 164     {{4, 5}, {4, 6}, {5, 4}, {5, 6}, {6, 4}, {6, 5}}, /* f5 */
 165     {{4, 6}, {4, 7}, {5, 5}, {5, 7}, {6, 5}, {6, 6}}, /* f6 */
 166     {{4, 7}, {4, 8}, {5, 6}, {0, 0}, {6, 6}, {0, 0}}  /* f7 */
 167   },
 168   {/* row g */
 169     {{0}},
 170     {{0}},
 171     {{5, 2}, {5, 3}, {0, 0}, {6, 3}, {0, 0}, {7, 2}}, /* g2 */
 172     {{5, 3}, {5, 4}, {6, 2}, {6, 4}, {7, 2}, {7, 3}}, /* g3 */
 173     {{5, 4}, {5, 5}, {6, 3}, {6, 5}, {7, 3}, {7, 4}}, /* g4 */
 174     {{5, 5}, {5, 6}, {6, 4}, {6, 6}, {7, 4}, {7, 5}}, /* g5 */
 175     {{5, 6}, {5, 7}, {6, 5}, {0, 0}, {7, 5}, {0, 0}}  /* g6 */
 176   },
 177   {/* row h */
 178     {{0}},
 179     {{0}},
 180     {{6, 2}, {6, 3}, {0, 0}, {7, 3}, {0, 0}, {0, 0}}, /* h2 */
 181     {{6, 3}, {6, 4}, {7, 2}, {7, 4}, {0, 0}, {0, 0}}, /* h3 */
 182     {{6, 4}, {6, 5}, {7, 3}, {7, 5}, {0, 0}, {0, 0}}, /* h4 */
 183     {{6, 5}, {6, 6}, {7, 4}, {0, 0}, {0, 0}, {0, 0}}  /* h5 */
 184   },
 185   {{{0}}/* row i */}
 186 };
 187
 188
 189 /*
 190 ** each item of the list contains:
 191 **   - middle point for the row
 192 **   - first direction for this row (second direction = 5 - first direction)
 193 **   - second direction
 194 **   - minimum nr of pieces necessary in the first direction
 195 */
 196 int rowlist[][5] = {
 197             {2, 2, 1, 4, 2},
 198             {3, 3, 1, 4, 2},
 199             {4, 4, 1, 4, 2},
 200             {4, 5, 1, 4, 1},
 201             {5, 5, 1, 4, 2},
 202             {5, 6, 1, 4, 2},
 203             {5, 7, 1, 4, 2},
 204             {1, 3, 2, 3, 2},
 205             {2, 4, 2, 3, 2},
 206             {3, 5, 2, 3, 2},
 207             {4, 5, 2, 3, 1},
 208             {5, 5, 2, 3, 2},
 209             {6, 4, 2, 3, 2},
 210             {7, 3, 2, 3, 2},
 211             {5, 2, 0, 5, 2},
 212             {5, 3, 0, 5, 2},
 213             {5, 4, 0, 5, 2},
 214             {4, 5, 0, 5, 1},
 215             {4, 6, 0, 5, 2},
 216             {3, 6, 0, 5, 2},
 217             {2, 6, 0, 5, 2}
 218             };
 219
 220
 221
 222 board * b_new (int board_type)
 223 {
 224     board * board_ref;
 225     int i, j;
 226
 227     board_ref = b_newboard();
 228     for (i = 0; i < 8; i++)
 229         for (j = 0; j < 9; j++)
 230             board_ref->pieces[i][j] = '.';
 231
 232     board_ref->status = S_NORMAL;
 233     board_ref->nextpiece = 'o';
 234     board_ref->gipfextra = NULL;
 235     board_ref->rowextraw = NULL;
 236     board_ref->rowextrab = NULL;
 237     board_ref->white = 18;
 238     board_ref->lostwhite = 0;
 239     board_ref->gipfwhite = 0;
 240     board_ref->typewhite = 'n';
 241     board_ref->black = 18;
 242     board_ref->lostblack = 0;
 243     board_ref->gipfblack = 0;
 244     board_ref->typeblack = 'n';
 245     board_ref->winner = '.';
 246     board_ref->checkfour = 'n';
 247     board_ref->log = NULL;
 248     board_ref->movecounter = 0;
 249 #ifdef WINGIPF
 250     board_ref->removewait = 0;
 251     board_ref->animate = 0;
 252 #endif
 253
 254     if (board_type == T_BASIC)
 255     {
 256         board_ref->white = 12;
 257         board_ref->black = 12;
 258         board_ref->pieces[1][5] = 'o';
 259         board_ref->pieces[7][5] = 'o';
 260         board_ref->pieces[4][2] = 'o';
 261         board_ref->pieces[1][2] = 'x';
 262         board_ref->pieces[4][8] = 'x';
 263         board_ref->pieces[7][2] = 'x';
 264         board_ref->gipfwhite = -1;
 265         board_ref->gipfblack = -1;
 266     }
 267     else if (board_type == T_STANDARD)
 268     {
 269         board_ref->white = 12;
 270         board_ref->black = 12;
 271         board_ref->pieces[1][5] = 'O';
 272         board_ref->pieces[7][5] = 'O';
 273         board_ref->pieces[4][2] = 'O';
 274         board_ref->pieces[1][2] = 'X';
 275         board_ref->pieces[4][8] = 'X';
 276         board_ref->pieces[7][2] = 'X';
 277         board_ref->gipfwhite = 3;
 278         board_ref->gipfblack = 3;
 279     }
 280     else
 281     {   /* tournament */
 282         board_ref->typewhite = 'g';
 283         board_ref->typeblack = 'g';
 284     }
 285
 286     return (board_ref);
 287 }
 288
 289 board * b_copy (board * orig_board)
 290 {
 291     board * new_board;
 292     int i, j;
 293
 294     if (orig_board == NULL)
 295         return (NULL);
 296
 297     new_board = b_newboard();
 298
 299 #define MEMCPY 1
 300 #ifndef MEMCPY
 301     for (i = 1; i < 8; i++)
 302         for (j = 2; j <= b_colsize (i); j++)
 303             new_board->pieces[i][j] = orig_board->pieces[i][j];
 304
 305     new_board->status = orig_board->status;
 306     new_board->nextpiece = orig_board->nextpiece;
 307     new_board->winner = orig_board->winner;
 308     new_board->checkfour = orig_board->checkfour;
 309     new_board->log = orig_board->log;
 310     new_board->movecounter = orig_board->movecounter;
 311
 312     new_board->white = orig_board->white;
 313     new_board->typewhite = orig_board->typewhite;
 314     new_board->lostwhite = orig_board->lostwhite;
 315     new_board->gipfwhite = orig_board->gipfwhite;
 316     new_board->black = orig_board->black;
 317     new_board->typeblack = orig_board->typeblack;
 318     new_board->lostblack = orig_board->lostblack;
 319     new_board->gipfblack = orig_board->gipfblack;
 320 #else
 321     memcpy (new_board, orig_board, sizeof (board));
 322 #endif
 323
 324     if (orig_board->gipfextra != NULL)
 325     {
 326         new_board->gipfextra = copy_rem_gipf_row (orig_board->gipfextra);
 327     }
 328     if (orig_board->rowextraw != NULL)
 329     {
 330         new_board->rowextraw = copy_rem_row_row (orig_board->rowextraw);
 331     }
 332     if (orig_board->rowextrab != NULL)
 333     {
 334         new_board->rowextrab = copy_rem_row_row (orig_board->rowextrab);
 335     }
 336     return (new_board);
 337 }
 338
 339
 340 void b_print (board * boardp)
 341 {
 342 #ifndef WINGIPF
 343     if (boardp == NULL)
 344     {
 345         printf ("\nERROR: the boardp-pointer is NULL (b_print)\n\n");
 346         return;
 347     }
 348
 349     printf ("A   B   C   D   E   F   G   H   I\n");
 350     printf ("5   6   7   8   9   8   7   6   5\n\n");
 351     printf ("                *\n");
 352     printf ("            *       *\n");
 353     printf ("        *       %c       *\n", boardp->pieces[4][8]);
 354     printf ("    *       %c       %c       *\n",
 355              boardp->pieces[3][7], boardp->pieces[5][7]);
 356     printf ("*       %c       %c       %c       *\n",
 357              boardp->pieces[2][6], boardp->pieces[4][7], boardp->pieces[6][6]);
 358     printf ("    %c       %c       %c       %c\n",
 359              boardp->pieces[1][5], boardp->pieces[3][6],
 360              boardp->pieces[5][6], boardp->pieces[7][5]);
 361     printf ("*       %c       %c       %c       *\n",
 362              boardp->pieces[2][5], boardp->pieces[4][6], boardp->pieces[6][5]);
 363     printf ("    %c       %c       %c       %c\n",
 364              boardp->pieces[1][4], boardp->pieces[3][5],
 365              boardp->pieces[5][5], boardp->pieces[7][4]);
 366     printf ("*       %c       %c       %c       *\n",
 367             boardp->pieces[2][4], boardp->pieces[4][5], boardp->pieces[6][4]);
 368     printf ("    %c       %c       %c       %c\n",
 369              boardp->pieces[1][3], boardp->pieces[3][4],
 370              boardp->pieces[5][4], boardp->pieces[7][3]);
 371     printf ("*       %c       %c       %c       *\n",
 372              boardp->pieces[2][3], boardp->pieces[4][4], boardp->pieces[6][3]);
 373     printf ("    %c       %c       %c       %c\n",
 374              boardp->pieces[1][2], boardp->pieces[3][3],
 375              boardp->pieces[5][3], boardp->pieces[7][2]);
 376     printf ("*       %c       %c       %c       *\n",
 377              boardp->pieces[2][2], boardp->pieces[4][3], boardp->pieces[6][2]);
 378     printf ("    *       %c       %c       *\n",
 379              boardp->pieces[3][2], boardp->pieces[5][2]);
 380     printf ("        *       %c       *\n", boardp->pieces[4][2]);
 381     printf ("            *       *\n");
 382     printf ("                *                        white: %d\n",
 383             boardp->white);
 384     printf ("                                     lostwhite: %d\n",
 385             boardp->lostwhite);
 386     printf ("1   1   1   1   1   1   1   1   1        black: %d\n",
 387             boardp->black);
 388     printf ("A   B   C   D   E   F   G   H   I    lostblack: %d\n",
 389             boardp->lostblack);
 390 #endif
 391     return;
 392 }
 393
 394
 395 void b_del (board * dboard)
 396 {
 397     if (dboard != NULL)
 398     {
 399         if (dboard->gipfextra != NULL)
 400         {
 401             emptyll (dboard->gipfextra, del_rem_gipf);
 402             free (dboard->gipfextra);
 403         }
 404         if (dboard->rowextraw != NULL)
 405         {
 406             emptyll (dboard->rowextraw, del_rem_row);
 407             free (dboard->rowextraw);
 408         }
 409         if (dboard->rowextrab != NULL)
 410         {
 411             emptyll (dboard->rowextrab, del_rem_row);
 412             free (dboard->rowextrab);
 413         }
 414         free (dboard);
 415     }
 416
 417     return;
 418 }
 419
 420
 421 /*
 422 ** b_move : move a piece on a gipf-board
 423 **
 424 ** parameters:
 425 **      oboard : pointer to original board
 426 **      from : string with from-position
 427 **      to   : string with to-position
 428 **      npiece: piece to add to the board (o, O, x, X)
 429 **
 430 ** returns:
 431 **      pointer to a new board
 432 **      NULL
 433 */
 434 board * b_move (board * oboard, char * from, char * to, char npiece)
 435 {
 436     position * from_p,
 437         * to_p,
 438         * next_p;
 439     int row_dif,
 440         col_dif;
 441     board * nboard,
 442         * new_board;
 443     char save_piece,
 444         piece,
 445         tempstr[80],
 446         * lastmoved = NULL;
 447 #ifdef WINGIPF
 448     listheader * pmoves;
 449     piecemove * piecem;
 450 #endif
 451
 452     /* check if oboard is in the correct state */
 453     if (oboard->status == S_REMOVEROW)
 454     {   /* wrong status */
 455         return (NULL);
 456     }
 457     if ((npiece != oboard->nextpiece) &&
 458         (b_otherpiece (npiece) != oboard->nextpiece))
 459     {   /* wrong player */
 460         return (NULL);
 461     }
 462
 463     /* check if the player has pieces left */
 464     if ((npiece == 'o') || (npiece == 'O'))
 465     {
 466         if (oboard->white <= 0)
 467         {
 468             return (NULL);
 469         }
 470     }
 471     else if (oboard->black <= 0)
 472     {
 473         return (NULL);
 474     }
 475
 476     /* if the player wants to place a gipf, check if this is allowed */
 477     if ((npiece == 'O') && (oboard->typewhite != 'g'))
 478     {
 479         return (NULL);
 480     }
 481     else if ((npiece == 'X') && (oboard->typeblack != 'g'))
 482     {
 483         return (NULL);
 484     }
 485
 486     /* move the piece */
 487     from_p = strtopos (from);
 488     to_p = strtopos (to);
 489     if ((from_p == NULL) || (to_p == NULL))
 490     {   /* invalid from or to position */
 491         del_position (from_p);
 492         del_position (to_p);
 493         return (NULL);
 494     }
 495     next_p = (position *) copy_position ((void *) to_p);
 496     row_dif = to_p->row - from_p->row;
 497     col_dif = to_p->col - from_p->col;
 498
 499     /* valid to-position ? */
 500     if (((to_p->col < 1) || (to_p->col > 7)) ||
 501         ((to_p->col != 1) && (to_p->col != 7) &&
 502          (to_p->row != 2) && (to_p->row != b_colsize (to_p->col))) ||
 503         (((to_p->col == 1) | (to_p->col == 7)) &&
 504          ((to_p->row <2) || (to_p->row >5))))
 505     {
 506 #ifndef WINGIPF
 507         printf ("invalid move (to): (%s, %s)\n", from, to);
 508 #endif
 509         del_position (from_p);
 510         del_position (to_p);
 511         del_position (next_p);
 512         return (NULL);
 513     }
 514
 515     /* valid from-position ? */
 516     if ((abs (row_dif) > 1) ||
 517         (abs (col_dif) > 1) ||
 518         (((from_p->col == 0) || (from_p->col == 8)) && (row_dif < 0)) ||
 519         (( from_p->row == 1) && (((from_p->col < 5) && (col_dif < 0)) ||
 520                                  ((from_p->col > 3) && (col_dif > 0)))) ||
 521         ((from_p->col > 0) && (from_p->col < 8) &&
 522          (from_p->row != 1) && (from_p->row != b_colsize (from_p->col) + 1)))
 523     {
 524 #ifndef WINGIPF
 525         printf ("invalid move (from): (%s, %s)\n", from, to);
 526 #endif
 527         del_position (from_p);
 528         del_position (to_p);
 529         del_position (next_p);
 530         return (NULL);
 531     }
 532
 533     nboard = b_copy (oboard);
 534     if (nboard->gipfextra != NULL)
 535     {
 536         emptyll (nboard->gipfextra, del_rem_gipf);
 537         free (nboard->gipfextra);
 538         nboard->gipfextra = NULL;
 539     }
 540
 541     nboard->status = S_NORMAL;
 542     if (oboard->nextpiece == 'o')
 543     {
 544         nboard->movecounter++;
 545     }
 546
 547 #ifdef WINGIPF
 548     pmoves = (listheader *) malloc (sizeof (listheader));
 549     newlist (pmoves);
 550
 551     piecem = (piecemove *) malloc (sizeof (piecemove));
 552     piecem->piece = npiece;
 553     piecem->from.col = from_p->col;
 554     piecem->from.row = from_p->row;
 555     piecem->to.col = to_p->col;
 556     piecem->to.row = to_p->row;
 557     pushll (pmoves, (void *) piecem);
 558 #endif
 559
 560     save_piece = nboard->pieces[to_p->col][to_p->row];
 561     nboard->pieces[to_p->col][to_p->row] = npiece;
 562     while (save_piece != '.')
 563     {
 564 #ifdef WINGIPF
 565         piecem = (piecemove *) malloc (sizeof (piecemove));
 566         piecem->piece = save_piece;
 567         piecem->from.col = next_p->col;
 568         piecem->from.row = next_p->row;
 569 #endif
 570         if (col_dif != 0)
 571         {   /* going diagonally */
 572             if (next_p->col == 4)
 573             {   /* going over the middle line */
 574                 row_dif--;
 575             }
 576             next_p->col += col_dif;
 577         }
 578         next_p->row += row_dif;
 579         if ((next_p->col == 0) ||
 580             (next_p->col == 8) ||
 581             (next_p->row < 2) ||
 582             (next_p->row > b_colsize (next_p->col)))
 583         {   /* the row is full, no pieces can be added */
 584             del_position (from_p);
 585             del_position (next_p);
 586             del_position (to_p);
 587             b_del (nboard);
 588 #ifdef WINGIPF
 589             free (piecem);
 590             while ((piecem = (piecemove *) llrembynr (pmoves, 1)) != NULL)
 591             {
 592                 free (piecem);
 593             }
 594             free (pmoves);
 595 #endif
 596             return (NULL);
 597         }
 598 #ifdef WINGIPF
 599         piecem->to.col = next_p->col;
 600         piecem->to.row = next_p->row;
 601         pushll (pmoves, (void *) piecem);
 602 #endif
 603         piece = save_piece;
 604         save_piece = nboard->pieces[next_p->col][next_p->row];
 605         nboard->pieces[next_p->col][next_p->row] = piece;
 606     }
 607     lastmoved = postostr (next_p); /* just for logging-purposes */
 608
 609     if (npiece == 'o')
 610     {
 611         nboard->white -= 1;
 612         nboard->typewhite = 'n';
 613     }
 614     else if (npiece == 'O')
 615     {
 616         nboard->white -= 2;
 617         nboard->gipfwhite++;
 618     }
 619     else if (npiece == 'x')
 620     {
 621         nboard->black -= 1;
 622         nboard->typeblack = 'n';
 623     }
 624     else
 625     {
 626         nboard->black -= 2;
 627         nboard->gipfblack++;
 628     }
 629     nboard->nextpiece = b_opponent (nboard->nextpiece);
 630
 631     if (nboard->log)
 632     {
 633         sprintf (tempstr, "%c:%2s:%2s", npiece, from, lastmoved);
 634         addtolog (nboard->log, LOGMOVE, tempstr);
 635     }
 636     free (lastmoved);
 637
 638 #ifdef WINGIPF
 639     /* animate move */
 640     if (nboard->animate)
 641     {
 642         animatemove (oboard, pmoves, nboard);
 643     }
 644
 645     while ((piecem = (piecemove *) llrembynr (pmoves, 1)) != NULL)
 646     {
 647         free (piecem);
 648     }
 649     free (pmoves);
 650 #endif
 651
 652     /* check for 4 in a row */
 653     nboard->checkfour = 'y';
 654     new_board = b_checkfour (nboard);
 655
 656     /* cleanup memory */
 657     del_position (from_p);
 658     del_position (next_p);
 659     del_position (to_p);
 660     b_del (nboard);
 661
 662     return (new_board);
 663 }
 664
 665
 666 /*
 667 ** b_remove_row: remove a row from the playing field, adapt the different
 668 **               counters
 669 **
 670 ** parameters:
 671 **    oboard : pointer to gipf-board
 672 **    rownr : nr of the row to be removed from gipfextra
 673 **
 674 ** returns:
 675 **    pointer to a new gipf-board
 676 **    NULL
 677 */
 678 board * b_remove_row (board * oboard, int rownr)
 679 {
 680     rem_row * row_ptr,
 681         * n_row;
 682     board * nboard,
 683         * new_board;
 684     listheader * glist,
 685         * plist,
 686         * rowextra_o,
 687         * rowextra_n;
 688     int nrg = 0,
 689         counter,
 690         str_offset;
 691     position * coor;
 692     char winpiece,
 693         piece,
 694         colour,
 695         tempstr[80],
 696         * strpos,
 697         * start,
 698         * end;
 699     rem_gipf * gipf_ptr;
 700
 701     if ((oboard->rowextraw != NULL) &&
 702         ((oboard->nextpiece == 'x') || (oboard->rowextrab == NULL)))
 703     {
 704         colour = 'o';
 705         rowextra_o = oboard->rowextraw;
 706     }
 707     else if (oboard->rowextrab != NULL)
 708     {
 709         colour = 'x';
 710         rowextra_o = oboard->rowextrab;
 711     }
 712     else
 713     {
 714         return (NULL);
 715     }
 716
 717     row_ptr = (rem_row *) llitembynr (rowextra_o, rownr);
 718     /* this shouldn't happen */
 719     if (row_ptr == NULL)
 720     {
 721         return (NULL);
 722     }
 723
 724     glist = (listheader *) malloc (sizeof (listheader));
 725     newlist (glist);
 726     nboard = b_copy (oboard);
 727     if (nboard->gipfextra != NULL)
 728     {
 729         emptyll (nboard->gipfextra, del_rem_gipf);
 730         free (nboard->gipfextra);
 731         nboard->gipfextra = NULL;
 732     }
 733
 734     nboard->status = S_NORMAL;
 735     plist = row_ptr->piecelist;
 736     winpiece = row_owner (row_ptr);
 737
 738     if (nboard->log)
 739     {
 740         start = postostr (row_start (row_ptr));
 741         end = postostr (row_end (row_ptr));
 742         sprintf (tempstr, "%c:%s:%s:", winpiece, start, end);
 743         free (start);
 744         free (end);
 745         str_offset = 8;
 746     }
 747
 748     counter = 1;
 749     while ((coor = (position *) llitembynr (plist, counter)) != NULL)
 750     {
 751         counter++;
 752
 753         piece = nboard->pieces[coor->col][coor->row];
 754         if ((piece == 'O') || (piece == 'X'))
 755         {
 756             nrg++;
 757             gipf_ptr = new_rem_gipf ();
 758             gipf_ptr->pos = (position *) copy_position ((void *) coor);
 759             gipf_ptr->owner = winpiece;
 760             pushll (glist, (void *) gipf_ptr);
 761             continue;
 762         }
 763
 764         if (nboard->log)
 765         {
 766             strpos = postostr (coor);
 767             sprintf (tempstr + str_offset, "%2s%c:", strpos, piece);
 768             free (strpos);
 769             str_offset += 4;
 770         }
 771
 772         if (piece == 'o')
 773         {
 774             if (piece == winpiece)
 775             {
 776                 nboard->white++;
 777             }
 778             else
 779             {
 780                 nboard->lostwhite++;
 781             }
 782         }
 783         else
 784         {
 785             if (piece == winpiece)
 786             {
 787                 nboard->black++;
 788             }
 789             else
 790             {
 791                 nboard->lostblack++;
 792             }
 793         }
 794
 795         nboard->pieces[coor->col][coor->row] = '.';
 796     }
 797
 798     if (nboard->log)
 799     {
 800         addtolog (nboard->log, LOGREMROW, tempstr);
 801     }
 802
 803 #ifdef WINGIPF
 804     if (nboard->removewait)
 805     {
 806         waitremrow (oboard, row_ptr, nboard);
 807     }
 808 #endif
 809
 810     /*
 811     ** remove the row that was just removed from rowextra
 812     ** and check if the other rows are still complete
 813     */
 814     /* check white rowlist */
 815     if (nboard->rowextraw != NULL)
 816     {
 817         /* check if all rows are still valid */
 818         emptyll (nboard->rowextraw, del_rem_row);/* I now have an empty list */
 819
 820         counter = 1;
 821         while ((row_ptr = (rem_row *) llitembynr (oboard->rowextraw, counter))
 822                != NULL)
 823         {
 824             counter++;
 825             if ((colour == 'o') && ((counter - 1) == rownr))
 826             {
 827                 continue;
 828             }
 829             if ((n_row = b_rowoffour (nboard, row_ptr->rowindex)) != NULL)
 830             {
 831                 pushll (nboard->rowextraw, n_row);
 832             }
 833         }
 834
 835         if (llitembynr (nboard->rowextraw, 1) == NULL)
 836         {
 837             free (nboard->rowextraw);
 838             nboard->rowextraw = NULL;
 839         }
 840     }
 841
 842     /* check black rowlist */
 843     if (nboard->rowextrab != NULL)
 844     {
 845         /* check if all rows are still valid */
 846
 847         emptyll (nboard->rowextrab, del_rem_row);/* I now have an empty list */
 848
 849         counter = 1;
 850         while ((row_ptr = (rem_row *) llitembynr (oboard->rowextrab, counter))
 851                != NULL)
 852         {
 853             counter++;
 854             if ((colour == 'x') && ((counter - 1) == rownr))
 855             {
 856                 continue;
 857             }
 858             if ((n_row = b_rowoffour (nboard, row_ptr->rowindex)) != NULL)
 859             {
 860                 pushll (nboard->rowextrab, n_row);
 861             }
 862         }
 863
 864         if (llitembynr (nboard->rowextrab, 1) == NULL)
 865         {
 866             free (nboard->rowextrab);
 867             nboard->rowextrab = NULL;
 868         }
 869     }
 870
 871     if ((nboard->rowextraw == NULL) && (nboard->rowextrab == NULL))
 872     {
 873         nboard->checkfour = 'n';
 874     }
 875
 876     if (nrg != 0)
 877     {
 878         nboard->gipfextra = glist;
 879         nboard->status = S_REMOVEGIPF;
 880         return (nboard);
 881     }
 882     else if (nboard->checkfour == 'y')
 883     {
 884         free (glist);
 885         new_board = b_checkfour (nboard);
 886         b_del (nboard);
 887         return (new_board);
 888     }
 889     else
 890     {
 891         free (glist);
 892         return (nboard);
 893     }
 894 }
 895
 896
 897 /*
 898 ** remove a gipf from the board and add the retrieved pieces to the
 899 ** correct counter
 900 **
 901 ** parameters:
 902 **    oboard: pointer to gipf-board
 903 **
 904 ** returns:
 905 **    pointer to new board
 906 **    NULL
 907 */
 908 board * b_remove_gipf (board * oboard, rem_gipf * rgipf)
 909 {
 910     board * nboard;
 911     char piece,
 912         winpiece,
 913         tempstr[80],
 914         * strpos;
 915     rem_row * row_ptr,
 916         * n_row;
 917     int counter;
 918
 919     piece = oboard->pieces[rgipf->pos->col][rgipf->pos->row];
 920     winpiece = b_otherpiece (rgipf->owner);
 921
 922     if ((piece != 'O') && (piece != 'X'))
 923     {
 924         return (NULL);
 925     }
 926
 927     nboard = b_copy (oboard);
 928
 929     if (nboard->gipfextra != NULL)
 930     {
 931         emptyll (nboard->gipfextra, del_rem_gipf);
 932         free (nboard->gipfextra);
 933         nboard->gipfextra = NULL;
 934     }
 935
 936     nboard->status = S_NORMAL;
 937
 938     nboard->pieces[rgipf->pos->col][rgipf->pos->row] = '.';
 939
 940     if (nboard->log)
 941     {
 942         strpos = postostr (rgipf->pos);
 943         sprintf (tempstr, "%c:%2s%c", rgipf->owner, strpos, piece);
 944         free (strpos);
 945         addtolog (nboard->log, LOGREMGIPF, tempstr);
 946     }
 947
 948     if (piece == 'O')
 949     {
 950         nboard->gipfwhite--;
 951         if (piece == winpiece)
 952         {
 953             nboard->white += 2;
 954         }
 955         else
 956         {
 957             nboard->lostwhite += 2;
 958         }
 959     }
 960     else
 961     {
 962         nboard->gipfblack--;
 963         if (piece == winpiece)
 964         {
 965             nboard->black += 2;
 966         }
 967         else
 968         {
 969             nboard->lostblack += 2;
 970         }
 971     }
 972
 973     /* check white rowlist */
 974     if (nboard->rowextraw != NULL)
 975     {
 976         /* check if all rows are still valid */
 977         emptyll (nboard->rowextraw, del_rem_row);/* I now have an empty list */
 978
 979         counter = 1;
 980         while ((row_ptr = (rem_row *) llitembynr (oboard->rowextraw, counter))
 981                != NULL)
 982         {
 983             counter++;
 984             if ((n_row = b_rowoffour (nboard, row_ptr->rowindex)) != NULL)
 985             {
 986                 pushll (nboard->rowextraw, n_row);
 987             }
 988         }
 989
 990         if (llitembynr (nboard->rowextraw, 1) == NULL)
 991         {
 992             free (nboard->rowextraw);
 993             nboard->rowextraw = NULL;
 994         }
 995     }
 996
 997     /* check black rowlist */
 998     if (nboard->rowextrab != NULL)
 999     {
1000         /* check if all rows are still valid */
1001
1002         emptyll (nboard->rowextrab, del_rem_row);/* I now have an empty list */
1003
1004         counter = 1;
1005         while ((row_ptr = (rem_row *) llitembynr (oboard->rowextrab, counter))
1006                != NULL)
1007         {
1008             counter++;
1009             if ((n_row = b_rowoffour (nboard, row_ptr->rowindex)) != NULL)
1010             {
1011                 pushll (nboard->rowextrab, n_row);
1012             }
1013         }
1014
1015         if (llitembynr (nboard->rowextrab, 1) == NULL)
1016         {
1017             free (nboard->rowextrab);
1018             nboard->rowextrab = NULL;
1019         }
1020     }
1021
1022     if ((nboard->rowextraw == NULL) && (nboard->rowextrab == NULL))
1023     {
1024         nboard->checkfour = 'n';
1025     }
1026
1027 #ifdef WINGIPF
1028     if (nboard->removewait)
1029     {
1030         waitremgipf (oboard, rgipf->pos, nboard);
1031     }
1032 #endif
1033
1034     return (nboard);
1035 }
1036
1037
1038 /*
1039 ** b_checkfour: check for 4 in a row
1040 **
1041 ** parameters:
1042 **    oboard: pointer to gipf-board
1043 **
1044 ** returns:
1045 **    pointer to a new gipf-board
1046 */
1047 board * b_checkfour (board * oboard)
1048 {
1049     board * nboard,
1050         * new_board;
1051     int inrow4_w = 0,
1052         inrow4_b = 0,
1053         rownr,
1054         countrow,
1055         save_col,
1056         dir;
1057     listheader * row4list_w = NULL,
1058         * row4list_b = NULL;
1059     position base,
1060         next;
1061     char base_piece,
1062         base_piece2,
1063         piece;
1064     rem_row * rowp;
1065
1066     if (oboard->checkfour == 'n')
1067     {
1068         nboard = b_copy (oboard);
1069         nboard->status = S_NORMAL;
1070         return (nboard);
1071     }
1072     if ((oboard->rowextraw != NULL) &&
1073         ((oboard->nextpiece == 'x') || (oboard->rowextrab == NULL)))
1074     {
1075         if (llitembynr (oboard->rowextraw, 2) == NULL)
1076         {
1077             nboard = b_remove_row (oboard, 1);
1078             return (nboard);
1079         }
1080         else
1081         {
1082             nboard = b_copy (oboard);
1083             nboard->status = S_REMOVEROW;
1084             return (nboard);
1085         }
1086     }
1087     else if (oboard->rowextrab != NULL)
1088     {
1089         if (llitembynr (oboard->rowextrab, 2) == NULL)
1090         {
1091             nboard = b_remove_row (oboard, 1);
1092             return (nboard);
1093         }
1094         else
1095         {
1096             nboard = b_copy (oboard);
1097             nboard->status = S_REMOVEROW;
1098             return (nboard);
1099         }
1100     }
1101
1102 /*    base = new_position ();
1103     next = new_position ();*/
1104
1105     for (rownr=0; rownr<21; rownr++)
1106     {
1107         base.col = rowlist[rownr][0];
1108         base.row = rowlist[rownr][1];
1109
1110         if (oboard->pieces[base.col][base.row] == '.')
1111         {
1112             continue;
1113         }
1114
1115         countrow = 1;
1116
1117         base_piece = oboard->pieces[base.col][base.row];
1118         base_piece2 = b_otherpiece (base_piece);
1119
1120         /* first direction */
1121         dir = rowlist[rownr][2];
1122
1123 /*      next.col = base.col;
1124         next.row = base.row;
1125
1126         save_col = next.col;
1127         next.col = b_buren[save_col][next.row][dir][0];
1128         next.row = b_buren[save_col][next.row][dir][1];*/
1129         next.col = b_buren[base.col][base.row][dir][0];
1130         next.row = b_buren[base.col][base.row][dir][1];
1131
1132         piece = oboard->pieces[next.col][next.row];
1133         while ((next.col != 0) && (piece != '.'))
1134         {
1135             if ((piece == base_piece) || (piece == base_piece2))
1136             {
1137                 countrow++;
1138             }
1139             else
1140             {
1141                 break;
1142             }
1143             save_col = next.col;
1144             next.col = b_buren[save_col][next.row][dir][0];
1145             next.row = b_buren[save_col][next.row][dir][1];
1146
1147             piece = oboard->pieces[next.col][next.row];
1148         }
1149
1150         if (countrow < rowlist[rownr][4])
1151         {   /* not possible to get 4 in a row anymore */
1152             continue;
1153         }
1154
1155         /* second direction */
1156         /*dir = rowlist[rownr][3];*/
1157         dir = 5 - dir;
1158
1159 /*      next.col = base.col;
1160         next.row = base.row;
1161
1162         save_col = next.col;
1163         next.col = b_buren[save_col][next.row][dir][0];
1164         next.row = b_buren[save_col][next.row][dir][1];*/
1165         next.col = b_buren[base.col][base.row][dir][0];
1166         next.row = b_buren[base.col][base.row][dir][1];
1167
1168         piece = oboard->pieces[next.col][next.row];
1169         while ((next.col != 0) && (piece != '.'))
1170         {
1171             if ((piece == base_piece) || (piece == base_piece2))
1172             {
1173                 countrow++;
1174             }
1175             else
1176             {
1177                 break;
1178             }
1179             save_col = next.col;
1180             next.col = b_buren[save_col][next.row][dir][0];
1181             next.row = b_buren[save_col][next.row][dir][1];
1182
1183             piece = oboard->pieces[next.col][next.row];
1184         }
1185
1186         if (countrow > 3)
1187         {
1188             rowp = b_rowoffour (oboard, rownr);
1189
1190             if ((base_piece == 'o') || (base_piece == 'O'))
1191             {
1192                 inrow4_w++;
1193                 if (row4list_w == NULL)
1194                 {
1195                     row4list_w = (listheader *) malloc (sizeof (listheader));
1196                     newlist (row4list_w);
1197                 }
1198                 pushll (row4list_w, rowp);
1199             }
1200             else
1201             {
1202                 inrow4_b++;
1203                 if (row4list_b == NULL)
1204                 {
1205                     row4list_b = (listheader *) malloc (sizeof (listheader));
1206                     newlist (row4list_b);
1207                 }
1208                 pushll (row4list_b, rowp);
1209             }
1210         }
1211     }
1212
1213 /*    del_position (base);
1214     del_position (next);*/
1215
1216     nboard = b_copy (oboard);
1217
1218     if (inrow4_w != 0)
1219     {
1220         nboard->rowextraw = row4list_w;
1221     }
1222     if (inrow4_b != 0)
1223     {
1224         nboard->rowextrab = row4list_b;
1225     }
1226
1227     if ((inrow4_w == 0) && (inrow4_b == 0))
1228     {
1229         nboard->status = S_NORMAL;
1230         nboard->checkfour = 'n';
1231         return (nboard);
1232     }
1233     if ((nboard->rowextraw != NULL) &&
1234         ((nboard->nextpiece == 'x') || (nboard->rowextrab == NULL)))
1235     {
1236         if (inrow4_w == 1)
1237         {
1238             new_board = b_remove_row (nboard, 1);
1239             b_del (nboard);
1240             return (new_board);
1241         }
1242         else
1243         {
1244             nboard->status = S_REMOVEROW;
1245             return (nboard);
1246         }
1247     }
1248     else
1249     {
1250         if (inrow4_b == 1)
1251         {
1252             new_board = b_remove_row (nboard, 1);
1253             b_del (nboard);
1254             return (new_board);
1255         }
1256         else
1257         {
1258             nboard->status = S_REMOVEROW;
1259             return (nboard);
1260         }
1261     }
1262 }
1263
1264
1265 /*
1266 ** b_rowoffour: check if a certain row has four in a row
1267 **
1268 ** parameters:
1269 **    oboard: pointer to gipf-board
1270 **    rownr: nr of row in rowlist
1271 **
1272 ** returns:
1273 **    pointer to rem_row-structure
1274 **    NULL (if no 4 in a row found)
1275 */
1276 rem_row * b_rowoffour (board * oboard, int rownr)
1277 {
1278     int countrow,
1279         dir,
1280         save_col,
1281         count;
1282     listheader * temprow;
1283     position * start,
1284         * end,
1285         * base,
1286         * next;
1287     char base_piece,
1288         base_piece2,
1289         piece;
1290     rem_row * rowp;
1291
1292     temprow = (listheader *) malloc (sizeof (listheader));
1293     newlist (temprow);
1294     countrow = 1;
1295
1296     base = new_position();
1297     base->col = rowlist[rownr][0];
1298     base->row = rowlist[rownr][1];
1299     start = (position *) copy_position ((void *) base);
1300     end = (position *) copy_position ((void *) base);
1301     next = (position *) copy_position ((void *) base);
1302
1303     if (oboard->pieces[base->col][base->row] == '.')
1304     {
1305         /* cleanup */
1306         free (temprow);
1307         del_position ((void *) base);
1308         del_position ((void *) start);
1309         del_position ((void *) end);
1310         del_position ((void *) next);
1311         return (NULL);
1312     }
1313
1314     base_piece = oboard->pieces[base->col][base->row];
1315     base_piece2 = b_otherpiece (base_piece);
1316     pushll (temprow, copy_position ((void *) base));
1317
1318     /* first direction */
1319     dir = rowlist[rownr][2];
1320
1321     count = 1;
1322 /*    b_moveto (next, col_dif, &row_dif);*/
1323     save_col = next->col;
1324     next->col = b_buren[save_col][next->row][dir][0];
1325     next->row = b_buren[save_col][next->row][dir][1];
1326
1327     piece = oboard->pieces[next->col][next->row];
1328     while ((next->col != 0) && (piece != '.'))
1329     {
1330         pushll (temprow, copy_position ((void *) next));
1331         if ((count == 1) &&
1332             ((piece == base_piece) || (piece == base_piece2)))
1333         {
1334             countrow++;
1335             start->col = next->col;
1336             start->row = next->row;
1337         }
1338         else
1339         {
1340             count = 0;
1341         }
1342 /*      b_moveto (next, col_dif, &row_dif);*/
1343         save_col = next->col;
1344         next->col = b_buren[save_col][next->row][dir][0];
1345         next->row = b_buren[save_col][next->row][dir][1];
1346
1347         piece = oboard->pieces[next->col][next->row];
1348     }
1349
1350     /* second direction */
1351     /*dir = rowlist[rownr][3];*/
1352     dir = 5 - dir;
1353
1354     next->col = base->col;
1355     next->row = base->row;
1356
1357     count = 1;
1358 /*    b_moveto (next, col_dif, &row_dif);*/
1359     save_col = next->col;
1360     next->col = b_buren[save_col][next->row][dir][0];
1361     next->row = b_buren[save_col][next->row][dir][1];
1362
1363     piece = oboard->pieces[next->col][next->row];
1364     while ((next->col != 0) && (piece != '.'))
1365     {
1366         pushll (temprow, copy_position ((void *) next));
1367         if ((count == 1) &&
1368             ((piece == base_piece) || (piece == base_piece2)))
1369         {
1370             countrow++;
1371             end->col = next->col;
1372             end->row = next->row;
1373         }
1374         else
1375         {
1376             count = 0;
1377         }
1378 /*      b_moveto (next, col_dif, &row_dif);*/
1379         save_col = next->col;
1380         next->col = b_buren[save_col][next->row][dir][0];
1381         next->row = b_buren[save_col][next->row][dir][1];
1382
1383         piece = oboard->pieces[next->col][next->row];
1384     }
1385
1386     if (countrow > 3)
1387     {
1388         rowp = new_rem_row ();
1389         rowp->startpos = start;
1390         rowp->endpos = end;
1391         rowp->piecelist = temprow;
1392         rowp->rowindex = rownr;
1393         if ((base_piece == 'o') || (base_piece == 'x'))
1394         {
1395             rowp->owner = base_piece;
1396         }
1397         else
1398         {
1399             rowp->owner = base_piece2;
1400         }
1401     }
1402     else
1403     {
1404         emptyll (temprow, del_position_f);
1405         free (temprow);
1406         del_position (start);
1407         del_position (end);
1408         rowp = NULL;
1409     }
1410     del_position (base);
1411     del_position (next);
1412
1413     return (rowp);
1414 }
1415
1416 #if 0
1417 /*
1418 ** b_moveto: give coor of new position
1419 **
1420 ** parameters:
1421 **     pos: startpos, endpos after run
1422 **     col_dif: column difference
1423 **     row_dif: row difference
1424 */
1425 inline void b_moveto (position * pos, int col_dif, int * row_dif)
1426 {
1427     if (col_dif != 0)
1428     {
1429         if (pos->col == 4)
1430         {
1431             (*row_dif)--;
1432         }
1433         pos->col += col_dif;
1434     }
1435
1436     pos->row += (*row_dif);
1437     if ((pos->col == 0) ||
1438         (pos->col == 8) ||
1439         (pos->row < 2) ||
1440         (pos->row > b_colsize(pos->col)))
1441     {
1442         pos->col = 0;
1443         pos->row = 0;
1444     }
1445     return;
1446 }
1447
1448
1449 /*
1450 ** b_colour: return the number of available pieces for a colour
1451 **
1452 ** parameters:
1453 **    oboard : pointer to gipf-board
1454 **    colour : o, O, x, X
1455 **
1456 ** returns:
1457 **    nr of pieces
1458 */
1459 int b_colour (board * oboard, char colour)
1460 {
1461     if ((colour == 'o') || (colour == 'O'))
1462     {
1463         return (oboard->white);
1464     }
1465     else if ((colour == 'x') || (colour == 'X'))
1466     {
1467         return (oboard->black);
1468     }
1469     return (-1);
1470 }
1471
1472
1473 /*
1474 ** b_colour_gipf: return the number of gipfpieces for a colour
1475 **
1476 ** parameters:
1477 **    oboard : pointer to gipf-board
1478 **    colour : o, O, x, X
1479 **
1480 ** returns:
1481 **    nr of pieces
1482 */
1483 int b_colour_gipf (board * oboard, char colour)
1484 {
1485     if ((colour == 'o') || (colour == 'O'))
1486     {
1487         return (oboard->gipfwhite);
1488     }
1489     else if ((colour == 'x') || (colour == 'X'))
1490     {
1491         return (oboard->gipfblack);
1492     }
1493     return (-1);
1494 }
1495
1496
1497 /*
1498 ** b_colour_lost: return the number of lost pieces for a colour
1499 **
1500 ** parameters:
1501 **    oboard : pointer to gipf-board
1502 **    colour : o, O, x, X
1503 **
1504 ** returns:
1505 **    nr of pieces
1506 */
1507 int b_colour_lost (board * oboard, char colour)
1508 {
1509     if ((colour == 'o') || (colour == 'O'))
1510     {
1511         return (oboard->lostwhite);
1512     }
1513     else if ((colour == 'x') || (colour == 'X'))
1514     {
1515         return (oboard->lostblack);
1516     }
1517     return (-1);
1518 }
1519
1520
1521 /*
1522 ** b_colour_type: return the type of pieces this colour can place
1523 **
1524 ** parameters:
1525 **    oboard : pointer to gipf-board
1526 **    colour : o, O, x, X
1527 **
1528 ** returns:
1529 **    n or g
1530 */
1531 char b_colour_type (board * oboard, char colour)
1532 {
1533     if ((colour == 'o') || (colour == 'O'))
1534     {
1535         return (oboard->typewhite);
1536     }
1537     else if ((colour == 'x') || (colour == 'X'))
1538     {
1539         return (oboard->typeblack);
1540     }
1541     return (' ');
1542 }
1543 #endif
1544
1545 /*
1546 ** b_piece: return piece at position
1547 **
1548 ** parameters:
1549 **    oboard: pointer to gipf-board
1550 **    pos: position-string (ex. b4)
1551 **
1552 ** returns:
1553 **    piece
1554 */
1555 char b_piece (board * oboard, char * strpos)
1556 {
1557     position * pos;
1558     char piece;
1559
1560     pos = strtopos (strpos);
1561     piece = oboard->pieces[pos->col][pos->row];
1562     del_position (pos);
1563
1564     return (piece);
1565 }
1566
1567
1568 /*
1569 ** b_game_finished : check if game is finished
1570 **
1571 ** parameters:
1572 **    oboard: gipf-board
1573 **
1574 ** returns:
1575 **    0: game not finished
1576 **    1: game finished
1577 **
1578 ** REMARK: only do this if no more rows can be removed from the board
1579 */
1580 int b_game_finished (board * oboard)
1581 {
1582     /*
1583     ** check if a player has no gipf-pieces left
1584     ** but only do this at the second move
1585     */
1586     if ((oboard->movecounter > 0) &&
1587         (oboard->gipfwhite == 0))
1588     {
1589         oboard->status = S_FINISHED;
1590         oboard->winner = 'x';
1591         return (1);
1592     }
1593
1594     if (((oboard->movecounter > 1) ||
1595          ((oboard->nextpiece == 'o') && (oboard->movecounter == 1))) &&
1596         (oboard->gipfblack == 0))
1597     {
1598         oboard->status = S_FINISHED;
1599         oboard->winner = 'o';
1600         return (1);
1601     }
1602
1603     /* check if the next player has pieces left */
1604     if (b_colour (oboard, oboard->nextpiece) == 0)
1605     {
1606         oboard->status = S_FINISHED;
1607         oboard->winner = b_opponent (oboard->nextpiece);
1608         return (1);
1609     }
1610
1611     return (0);
1612 }
1613
1614
1615 /*
1616 ** b_compare: compare the contents of 2 gipf-boards
1617 **
1618 ** parameters:
1619 **    board1
1620 **    board2
1621 **
1622 ** returns:
1623 **    0: equal
1624 **    1: different
1625 */
1626 int b_compare (board * board1, board * board2)
1627 {
1628     int i,
1629         j;
1630
1631     /* sanity check */
1632     if ((board1 == NULL) || (board2 == NULL))
1633     {
1634         return (1);
1635     }
1636
1637     /* compare the different counters */
1638     if ((board1->nextpiece != board2->nextpiece) ||
1639         (board1->movecounter != board2->movecounter) ||
1640         (board1->white != board2->white) ||
1641         (board1->lostwhite != board2->lostwhite) ||
1642         (board1->gipfwhite != board2->gipfwhite) ||
1643         (board1->typewhite != board2->typewhite) ||
1644         (board1->black != board2->black) ||
1645         (board1->lostblack != board2->lostblack) ||
1646         (board1->gipfblack != board2->gipfblack) ||
1647         (board1->typeblack != board2->typeblack))
1648     {
1649         return (1);
1650     }
1651
1652 #define MEMCMP 1
1653 #ifndef MEMCMP
1654     /* compare board-contents */
1655     for (i = 1; i < 8; i++)
1656         for (j = 2; j <= b_colsize (i); j++)
1657             if (board1->pieces[i][j] != board2->pieces[i][j])
1658                 return (1);
1659 #else
1660     if (memcmp (&(board1->pieces), &(board2->pieces), 72) != 0)
1661     {
1662         return (1);
1663     }
1664 #endif
1665
1666     return (0);
1667 }
1668
1669
1670 listheader * b_row_extra (board * oboard)
1671 {
1672     if ((oboard->rowextraw != NULL) &&
1673         ((oboard->nextpiece == 'x') || (oboard->rowextrab == NULL)))
1674     {
1675         return (oboard->rowextraw);
1676     }
1677     else
1678     {
1679         return (oboard->rowextrab);
1680     }
1681 }
1682
1683
1684 /*
1685 ** replace the piece at position 'pos' with 'piece'
1686 ** try to adapt the counters
1687 **
1688 ** returns:
1689 **   NULL: error
1690 */
1691 board * b_edit_piece (board * oboard, position * pos, char piece)
1692 {
1693     board * nboard;
1694
1695     nboard = b_copy (oboard);
1696
1697     if (nboard->pieces[pos->col][pos->row] == piece)
1698     {
1699         return (nboard);
1700     }
1701
1702     /* remove piece */
1703     switch (nboard->pieces[pos->col][pos->row])
1704     {
1705     case 'o':
1706         nboard->white += 1;
1707         break;
1708     case 'O':
1709         nboard->white += 2;
1710         nboard->gipfwhite -= 1;
1711         break;
1712     case 'x':
1713         nboard->black += 1;
1714         break;
1715     case 'X':
1716         nboard->black += 2;
1717         nboard->gipfblack -= 1;
1718         break;
1719     default:
1720         break;
1721     }
1722
1723     /* add piece */
1724     switch (piece)
1725     {
1726     case 'o':
1727         if (nboard->white == 0)
1728         {
1729             b_del (nboard);
1730             return (NULL);
1731         }
1732         nboard->white -= 1;
1733         break;
1734     case 'O':
1735         if (nboard->white < 2)
1736         {
1737             b_del (nboard);
1738             return (NULL);
1739         }
1740         nboard->white -= 2;
1741         nboard->gipfwhite += 1;
1742         break;
1743     case 'x':
1744         if (nboard->black == 0)
1745         {
1746             b_del (nboard);
1747             return (NULL);
1748         }
1749         nboard->black -= 1;
1750         break;
1751     case 'X':
1752         if (nboard->black < 2)
1753         {
1754             b_del (nboard);
1755             return (NULL);
1756         }
1757         nboard->black -= 2;
1758         nboard->gipfblack += 1;
1759         break;
1760     default:
1761         break;
1762     }
1763
1764     nboard->pieces[pos->col][pos->row] = piece;
1765
1766     return (nboard);
1767 }
1768
1769
1770 board * b_edit_lostwhite (board * oboard, int newval)
1771 {
1772     board * nboard;
1773
1774     if ((oboard->white + oboard->lostwhite - newval) < 0)
1775     {
1776         return (NULL);
1777     }
1778
1779     nboard = b_copy (oboard);
1780     nboard->white = nboard->white + nboard->lostwhite - newval;
1781     nboard->lostwhite = newval;
1782
1783     return (nboard);
1784 }
1785
1786
1787 board * b_edit_lostblack (board * oboard, int newval)
1788 {
1789     board * nboard;
1790
1791     if ((oboard->black + oboard->lostblack - newval) < 0)
1792     {
1793         return (NULL);
1794     }
1795
1796     nboard = b_copy (oboard);
1797     nboard->black = nboard->black + nboard->lostblack - newval;
1798     nboard->lostblack = newval;
1799
1800     return (nboard);
1801 }
1802
1803
1804 /*
1805 ** write a boardsituation to a file
1806 ** use a format that can be read by b_from_file
1807 ** (should also be readable by gipfdraw, so you can easily
1808 **  make gif's from a board-position)
1809 **
1810 ** returns -1 on failure, otherwise 0
1811 **
1812 ** REMARK: the board must be in a stable state (S_NORMAL or S_FINISHED)
1813 **         otherwise the save will fail
1814 */
1815 int b_to_file (board * oboard, FILE * fp)
1816 {
1817     int i, j;
1818     position * temppos;
1819     char * tempstr;
1820
1821     if (oboard == NULL)
1822         return (-1);
1823
1824     if ((oboard->status != S_NORMAL) && (oboard->status != S_FINISHED))
1825     {
1826         return (-1);
1827     }
1828
1829     fprintf (fp, "whitepieces:%d\n", oboard->white);
1830     fprintf (fp, "whitelost:%d\n", oboard->lostwhite);
1831
1832     fprintf (fp, "blackpieces:%d\n", oboard->black);
1833     fprintf (fp, "blacklost:%d\n", oboard->lostblack);
1834
1835     fprintf (fp, "nextplayer:%c\n", oboard->nextpiece);
1836
1837     temppos = (position *) malloc (sizeof (position));
1838     for (i = 1; i < 8; i++)
1839     {
1840         temppos->col = i;
1841         for (j = 2; j <= b_colsize (i); j++)
1842         {
1843             temppos->row = j;
1844             if (b_ppiece (oboard, temppos) != '.')
1845             {
1846                 tempstr = postostr (temppos);
1847                 fprintf (fp, "%c:%2s\n",
1848                          b_ppiece (oboard, temppos), tempstr);
1849                 free (tempstr);
1850             }
1851         }
1852     }
1853     free (temppos);
1854
1855     fprintf (fp, "# end of board\n");
1856
1857     return (0);
1858 }
1859
1860
1861 /*
1862 ** read a boardsituation from a file and store it in a
1863 ** board-structure.
1864 **
1865 ** returns NULL on failure
1866 */
1867 board * b_from_file (FILE * fp)
1868 {
1869     char buffer[100]="",
1870         tempchar,
1871         tempstr[100];
1872     board * nboard;
1873     int tempnr;
1874     position * temppos;
1875
1876     nboard = b_new (T_TOURNAMENT);
1877     nboard->typewhite = 'n';
1878     nboard->typeblack = 'n';
1879
1880     while (strncmp (buffer, "# end of board", 14) != 0)
1881     {
1882         if (fgets (buffer, 100, fp) == NULL)
1883         {
1884             b_del (nboard);
1885             return (NULL);
1886         }
1887
1888         if (sscanf (buffer, "whitepieces:%d", &tempnr) == 1)
1889         {
1890             nboard->white = tempnr;
1891         }
1892         else if (sscanf (buffer, "whitelost:%d", &tempnr) == 1)
1893         {
1894             nboard->lostwhite = tempnr;
1895         }
1896         else if (sscanf (buffer, "blackpieces:%d", &tempnr) == 1)
1897         {
1898             nboard->black = tempnr;
1899         }
1900         else if (sscanf (buffer, "blacklost:%d", &tempnr) == 1)
1901         {
1902             nboard->lostblack = tempnr;
1903         }
1904         else if (sscanf (buffer, "nextplayer:%c", &tempchar) == 1)
1905         {
1906             nboard->nextpiece = tempchar;
1907         }
1908         else if (sscanf (buffer, "%c:%s", &tempchar, tempstr) == 2)
1909         {
1910             temppos = strtopos (tempstr);
1911             nboard->pieces[temppos->col][temppos->row] = tempchar;
1912             switch (tempchar)
1913             {
1914             case 'O':
1915                 nboard->gipfwhite += 1;
1916                 break;
1917             case 'X':
1918                 nboard->gipfblack += 1;
1919                 break;
1920             }
1921             del_position (temppos);
1922         }
1923     }
1924
1925     if ((nboard->gipfwhite == 0) && (nboard->gipfblack == 0))
1926     {
1927         nboard->gipfwhite = -1;
1928         nboard->gipfblack = -1;
1929     }
1930
1931     return (nboard);
1932 }