home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gnushogi-1.1 / src / genmoves.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-04-26  |  17.8 KB  |  759 lines
  1. /*
  2.  * genmoves.c - C source for GNU SHOGI
  3.  *
  4.  * Copyright (c) 1993 Matthias Mutz
  5.  *
  6.  * GNU SHOGI is based on GNU CHESS
  7.  *
  8.  * Copyright (c) 1988,1989,1990 John Stanback
  9.  * Copyright (c) 1992 Free Software Foundation
  10.  *
  11.  * This file is part of GNU SHOGI.
  12.  *
  13.  * GNU Shogi is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 1, or (at your option)
  16.  * any later version.
  17.  *
  18.  * GNU Shogi is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with GNU Shogi; see the file COPYING.  If not, write to
  25.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  26.  */
  27.  
  28. #include "gnushogi.h"
  29. #include "ataks.h"
  30.  
  31.  
  32. short *TrP;
  33.  
  34. static struct leaf *node;
  35. static short sqking, sqxking;
  36. static short InCheck = false;     
  37.  
  38.  
  39. /*
  40.  * Ply limits for deep search cut.
  41.  * No moves or drops flagged with "stupid" are considered beyond ply BEYOND_STUPID.
  42.  * Only moves or drops flagged with "kingattack" are considered beyond ply BEYOND_KINGATTACK.
  43.  * No moves or drops flagged with "questionable" are considered beyond ply BEYOND_QUESTIONABLE.
  44.  * Only moves or drops flagged with "tesuji" are considered beyond ply BEYOND_TESUJI.
  45.  * No drops are considered beyond ply BEYOND_DROP.
  46.  * Exceptions: moves or drops that prevent check or give check are always considered.
  47.  */
  48.  
  49. #ifdef THINK_C
  50. #define BEYOND_STUPID 2
  51. #define BEYOND_KINGATTACK 4
  52. #define BEYOND_QUESTIONABLE 6
  53. #define BEYOND_TESUJI 6
  54. #define BEYOND_DROP 8
  55. #else
  56. #define BEYOND_STUPID 2
  57. #define BEYOND_KINGATTACK 6
  58. #define BEYOND_QUESTIONABLE 8
  59. #define BEYOND_TESUJI 8
  60. #define BEYOND_DROP 10
  61. #endif
  62.  
  63. inline
  64. static
  65. void
  66. GenMakeMove (short int side,
  67.          short f,
  68.          short t,
  69.          short int *tempb,    /* piece at to square */
  70.          short int *tempc)    /* color of to square */
  71.  
  72. /*
  73.  * Update Arrays board[] and color[] to reflect the new board
  74.  * position obtained after making the move pointed to by node.
  75.  */
  76.  
  77. {
  78.   register short int piece;
  79.  
  80.   t = t & 0x7f;
  81.  
  82.   if (f > NO_SQUARES )
  83.     { 
  84.       piece = f - NO_SQUARES;
  85.       if ( side == white ) piece -= NO_PIECES;
  86.       board[t] = piece;
  87.       color[t] = side;
  88.     }
  89.   else
  90.     {
  91.       *tempb = board[t];
  92.       *tempc = color[t];
  93.       piece = board[f];
  94.       color[f] = neutral;
  95.       board[f] = no_piece;
  96.       color[t] = side;
  97.       board[t] = (node->flags & promote) ? promoted[piece] : piece;
  98.     } 
  99. }
  100.  
  101. static
  102. void
  103. GenUnmakeMove (short int side,
  104.            short f,
  105.            short t,
  106.            short int tempb,
  107.            short int tempc)
  108.  
  109. /*
  110.  * Take back a move.
  111.  */
  112.  
  113. {
  114.   register short piece;
  115.  
  116.   t = t & 0x7f;
  117.   
  118.   if (f > NO_SQUARES )
  119.     { 
  120.       piece = f - NO_SQUARES;
  121.       if ( piece >= NO_PIECES ) piece -= NO_PIECES;
  122.       board[t] = no_piece;
  123.       color[t] = neutral;
  124.     }
  125.   else
  126.     { 
  127.       piece = board[t];
  128.       color[t] = tempc;
  129.       board[t] = tempb;
  130.       color[f] = side;
  131.       board[f] = (node->flags & promote) ? unpromoted[piece] : piece;
  132.     }
  133. }
  134.  
  135.  
  136. inline
  137. static
  138. void
  139. Link (short side, short piece,
  140.       short from, short to, short local_flag, short s) 
  141. {        
  142.     if ( *TrP == TREE ) {
  143.       ShowMessage("TREE overflow\n");
  144.     } else {
  145.       node->f = from; 
  146.       node->t = (local_flag & promote) ? (to | 0x80) : to;
  147.       node->reply = 0;
  148.       node->flags = local_flag;
  149.       node->score = s;
  150.       if ( flag.tsume )
  151.         {
  152.           if ( InCheck )
  153.             {
  154.               short tempb, tempc, sq, threat;
  155.               GenMakeMove (side, node->f, node->t, &tempb, &tempc);
  156.               sq = (from == sqking) ? to : sqking;
  157.           threat = SqAtakd(sq,side ^ 1);
  158.               GenUnmakeMove (side, node->f, node->t, tempb, tempc);
  159.               if ( !threat ) 
  160.             (*TrP)++, node++;
  161.             }
  162.           else if ( !(local_flag & check) && (sqxking != to ) && (board[sqxking] == king) )
  163.             {                               
  164.               short tempb, tempc, sq, threat;
  165.               GenMakeMove (side, node->f, node->t, &tempb, &tempc);
  166.           if ( threat = SqAtakd(sqxking,side) )
  167.             local_flag |= check;
  168.               GenUnmakeMove (side, node->f, node->t, tempb, tempc);
  169.           if ( threat ) 
  170.             (*TrP)++, node++;
  171.             }
  172.           else
  173.         (*TrP)++, node++;
  174.         }
  175.       else
  176.     (*TrP)++, node++;
  177.     }
  178. }
  179.  
  180.  
  181.  
  182.  
  183.  
  184.  
  185. inline
  186. int
  187. InPromotionZone (short int color, short int sq)
  188. {
  189.   if ( color == black ) {
  190.     if ( sq < 54 ) return(false);
  191.   } else {
  192.     if ( sq > 26 ) return(false);
  193.   };
  194.   return(true);
  195. }
  196.  
  197.  
  198.  
  199. inline
  200. int
  201. PromotionPossible (short int color, short int f, short int t, short int p)
  202. { 
  203.   if ( color == black ) {
  204.     if ( f < 54 && t < 54 ) return(false);
  205.   } else {
  206.     if ( f > 26 && t > 26 ) return(false);
  207.   };
  208.  
  209.   switch ( p ) {
  210.     case pawn: return(true);
  211.     case lance: return(true);
  212.     case knight: return(true);
  213.     case silver: return(true);
  214.     case bishop: return(true);
  215.     case rook: return(true);
  216.   };
  217.  
  218.   return(false);
  219. }
  220.  
  221.  
  222. inline
  223. int
  224. NonPromotionPossible (short int color, short int f, short int t, short int p)
  225. {
  226.   switch ( p ) {
  227.     case pawn : 
  228.            if ( color == black )
  229.              return ( t < 72 );
  230.            else
  231.              return ( t > 8 );
  232.     case lance: 
  233.            if ( color == black )
  234.              return ( t < 72 );
  235.            else
  236.              return ( t > 8 );
  237.     case knight:
  238.            if ( color == black )
  239.              return ( t < 63 );
  240.            else
  241.              return ( t > 17 );
  242.   };
  243.  
  244.   return(true);
  245. }
  246.  
  247.  
  248. #if defined FIELDBONUS || defined DROPBONUS
  249.  
  250. inline
  251. static 
  252. short
  253. field_bonus (short int ply, short int side, short int piece, short int f, short int t, 
  254.          short int *local_flag)
  255.  
  256. /* bonus for possible next moves */
  257.  
  258. {
  259.   register short s, u, ptyp;
  260.   register unsigned char *ppos, *pdir;
  261.   register short xside;
  262.  
  263.   xside = side ^ 1;
  264.  
  265.   s = 0;
  266.  
  267.   ptyp = ptype[side][piece];
  268.   ppos = (*nextpos[ptyp])[t];
  269.   pdir = (*nextdir[ptyp])[t];
  270.  
  271.   u = ppos[t];
  272.  
  273.   do 
  274.     { short coloru = color[u];
  275.       if (distance(u,WhiteKing) <= 1 || distance(u,BlackKing) <= 1 ) {
  276.         /* move controls square near own king or enemy king */
  277.     s += 2;
  278.     *local_flag |= kingattack; 
  279.       }
  280.       if (coloru == side ) {
  281.         /* impossible next move */
  282.         u = pdir[u];
  283.       } else {
  284.         /* possible next move */
  285.         if (PromotionPossible(side,t,u,piece)) {
  286.           /* possible promotion in next move */
  287.       if ( piece == pawn )
  288.             {
  289.           s += 2;
  290. #ifdef TESUJIBONUS
  291.               if ( !InPromotionZone(side,t) ) {
  292.                 *local_flag |= tesuji; /* The dangling pawn */ 
  293.         s++;
  294.               }
  295. #endif
  296.             }
  297.           else
  298.         s++; 
  299.         }
  300.         if (coloru == neutral) {
  301.           /* next move to an empty square */
  302.       if ( u == FROMsquare )
  303.              /* opponent has just left this square */
  304.          s++;
  305.       u = ppos[u];
  306.         } else {
  307.           /* attack opponents piece */
  308. #ifdef TESUJIBONUS
  309.           short boardu, upiece, rvupiece, rvuboard;
  310. #endif
  311.       s++;
  312.       if ( u == TOsquare )
  313.         /* opponent has moved to TOsquare */
  314.         s++;
  315.           if ( (boardu = board[u]) == king ) {
  316.           *local_flag |= check; /* move threatens opponents king */ 
  317.       }
  318. #ifdef TESUJIBONUS
  319.           upiece = unpromoted[piece];
  320.           rvupiece = relative_value[upiece];
  321.           rvuboard = relative_value[unpromoted[boardu]];
  322.           if ( upiece == pawn && Captured[side][pawn] > 1 )
  323.         {                
  324.           *local_flag |= tesuji; /* The joining pawn attack */
  325.           s++;
  326.         }     
  327.       if ( rvupiece <= rvuboard ) 
  328.         {                
  329.           *local_flag |= tesuji; /* The striking pawn (piece) attack */
  330.               if ( f > NO_SQUARES )
  331.             s += 2;
  332.               else
  333.         s++;
  334.               if ( upiece == pawn )
  335.         s++;
  336.           if ( rvupiece == rvuboard && 
  337.                    upiece == pawn || upiece == bishop || upiece == knight ) {
  338.                 s++; /* The opposing pawn (piece) */
  339.         if ( upiece == pawn )
  340.           s++;
  341.               }
  342.         }
  343. #endif 
  344.       u = pdir[u];
  345.     }
  346.       };
  347.   } while (u != t);
  348.  
  349.   return(s);
  350. }
  351.  
  352.  
  353. #endif
  354.  
  355.  
  356.  
  357. inline void
  358. LinkMove (short int ply, short int f,
  359.       register short int t,
  360.       short int local_flag,
  361.       short int xside)
  362.  
  363. /*
  364.  * Add a move to the tree.  Assign a bonus to order the moves as follows:
  365.  * 1. Principle variation 2. Capture of last moved piece 3. Other captures
  366.  * (major pieces first) 4. Killer moves 5. Tesuji drops 6. Other Moves
  367.  * 7. Other drops. 8. Non-promoting moves
  368.  * If the flag.tsume is set, assign a high bonus for checks.
  369.  */
  370.  
  371. {
  372.   register short s = 0;
  373.   register short piece;
  374.   register short principle = false;
  375.   short flag_tsume;
  376.  
  377. #if defined DROPBONUS || defined FIELDBONUS
  378.   register short side;
  379.   side = xside ^ 1;
  380. #endif
  381.  
  382. #ifdef HISTORY
  383.   /* Principle variation */
  384.     { 
  385.       unsigned short c, z, ds;
  386.       c = (xside == black);
  387.       z = (f << 8) | t;
  388.       ds = history[hindex(c,z)];
  389.       principle = (ds != 0);
  390.       s += ds;
  391.     }   
  392. #endif
  393.  
  394.   if ( !flag.tsume ) {
  395.  
  396.     if (distance(t,WhiteKing) <= 1 || distance(t,BlackKing) <= 1 ) {
  397.       /* bonus for square near own king or enemy king */
  398.       s += 10;
  399.       local_flag |= kingattack; 
  400.     }
  401.  
  402.     if ( f > NO_SQUARES )
  403.       { 
  404.        /* bonus for drops, in order to place the before questionable moves */
  405.         s += 10;
  406.         if (t == FROMsquare) {
  407.           /* drop to the square the opponent has just left */
  408.           s++;
  409.         };
  410. #if defined DROPBONUS
  411.         piece = f - NO_SQUARES; 
  412.         if (piece > NO_PIECES) piece -= NO_PIECES;
  413.         s += field_bonus(ply,side,piece,f,t,&local_flag);
  414.         if ( s == 10 && piece != pawn )
  415.         local_flag |= questionable;
  416. #endif
  417.       }
  418.     else 
  419.       {
  420.         /* bonus for moves (non-drops) */
  421.         int consider_last = false;
  422.         piece = board[f];
  423.         s += 20; 
  424.         if (t == FROMsquare) {
  425.           /* move to the square the opponent has just left */
  426.           s++;
  427.         }
  428.         if (color[t] != neutral)
  429.           {
  430.             /* Captures */  
  431.             s +=  value[board[t]] - relative_value[piece];
  432.             if (t == TOsquare)
  433.               /* Capture of last moved piece */ 
  434.               s += 500;
  435.           }  
  436.         if ( local_flag & promote )
  437.           {
  438.             /* bonus for promotions */
  439.             s++;
  440.           }
  441.         else
  442.           {
  443.             /* bonus for non-promotions */
  444.             if ( PromotionPossible(side,f,t,piece) )
  445. #ifdef TESUJIBONUS
  446.             /* Look at non-promoting silver or knight */
  447.               if ( piece == silver || piece == knight ) 
  448.                 {
  449.                   local_flag |= tesuji; /* Non-promotion */
  450.                   s++;
  451.                 }
  452.               else           
  453. #endif        
  454.               if ( !principle )
  455.               {
  456.               consider_last = true;
  457.                   if ( piece == pawn || piece == bishop || piece == rook )
  458.             local_flag |= stupid;
  459.           else
  460.             local_flag |= questionable;
  461.             }
  462.           }
  463.         if ( consider_last )
  464.       {
  465.         if ( local_flag & stupid )
  466.           s = 0;
  467.         else 
  468.               s = s % 20;
  469.       }
  470. #if defined FIELDBONUS
  471.         else 
  472.             {
  473.             s += field_bonus(ply,side,piece,f,t,&local_flag);
  474.           }
  475. #endif
  476.       }
  477.  
  478.   }
  479.  
  480.   flag_tsume = flag.tsume;
  481.  
  482.   /* check conditions for deep search cut */
  483.  
  484.   if ( !flag.tsume )      
  485.   if ( *TrP > TREE - 300 ) {
  486.     /* too close to tree table limit */
  487.     flag.tsume = true;
  488.   }
  489. #ifdef DEEPSEARCHCUT
  490.     else if ( *TrP > TREE - 1000 ) {
  491.     if ( ply > BEYOND_STUPID  && (local_flag & questionable) ) {
  492.       flag.tsume = true; 
  493.     } else if ( ply > BEYOND_KINGATTACK && !(local_flag & kingattack) ) {
  494.       flag.tsume = true;
  495.     } else if ( ply > BEYOND_QUESTIONABLE && (local_flag & stupid) ) {
  496.       flag.tsume = true; 
  497.     } else if ( ply > BEYOND_TESUJI && !(local_flag & tesuji) ) {
  498.       flag.tsume = true;
  499.     } else if ( ply > BEYOND_DROP && (f > NO_SQUARES) ) {
  500.       flag.tsume = true;
  501.     } 
  502.   }
  503. #endif
  504.  
  505.   Link (side, piece, 
  506.         f, t, local_flag, s - ((SCORE_LIMIT+1000)*2));
  507.  
  508.   flag.tsume = flag_tsume;
  509. }                                                 
  510.  
  511.  
  512.  
  513.  
  514. inline
  515. static
  516. void
  517. GenDrops (register short int ply, register short int piece, short int side,
  518.       short int xside)
  519.  
  520. /*
  521.  * Generate drops for a piece.
  522.  */
  523.  
  524. { register short u; 
  525.  
  526.   for (u = 0; u < NO_SQUARES; u++)
  527.  
  528.     { short r = row(u), possible = true;
  529.  
  530.       if ( board[u] != no_piece )
  531.          possible = false; 
  532.       else if ( piece == pawn )
  533.         { 
  534.           if ( side == black && r == 8 )
  535.             possible = false;
  536.           else if ( side == white && r == 0 )
  537.             possible = false;
  538.           else if ( PawnCnt[side][column(u)] )
  539.             possible = false;
  540.         }
  541.       else if ( piece == lance )
  542.         {
  543.           if ( side == black && r == 8 )
  544.             possible = false;
  545.           else if ( side == white && r == 0 )
  546.             possible = false;          
  547.         }
  548.       else if ( piece == knight )
  549.         {
  550.           if ( side == black && r >= 7 )
  551.             possible = false;
  552.           else if ( side == white && r <= 1 )
  553.             possible = false;
  554.         } 
  555.  
  556.       if ( possible )
  557.        { short f;
  558.          f = NO_SQUARES + piece;
  559.          if ( side == white ) f += NO_PIECES;
  560.          LinkMove (ply, f, u, (dropmask | piece), xside);
  561.        }
  562.   
  563.     }
  564.  
  565. }
  566.  
  567.  
  568.  
  569. inline
  570. void
  571. GenMoves (register short int ply, register short int sq, short int side, 
  572.       short int xside)
  573.  
  574. /*
  575.  * Generate moves for a piece. The moves are taken from the precalulated
  576.  * array nextpos/nextdir. If the board is free, next move is choosen from
  577.  * nextpos else from nextdir.
  578.  */
  579.  
  580. {
  581.   register short u, piece, col;
  582.   register unsigned char *ppos, *pdir;
  583.   short ptyp;
  584.  
  585.   TrP = &TrPnt[ply + 1];
  586.   piece = board[sq];
  587.   ptyp = ptype[side][piece];
  588.   ppos = (*nextpos[ptyp])[sq];
  589.   pdir = (*nextdir[ptyp])[sq];
  590.  
  591.   u = ppos[sq];
  592.   do
  593.     { short int local_flag, c;
  594.       if ( (c = color[u]) == xside )
  595.         local_flag = capture;
  596.       else
  597.         local_flag = 0;
  598.       if ( c != side && board[u] != king ) {
  599.         if ( PromotionPossible(color[sq],sq,u,piece) ) {
  600.           LinkMove (ply, sq, u, local_flag | promote, xside);
  601.           if ( NonPromotionPossible(color[sq],sq,u,piece) )
  602.             LinkMove (ply, sq, u, local_flag, xside);
  603.         } else {
  604.           LinkMove (ply, sq, u, local_flag, xside);
  605.         }
  606.       }
  607.       if (c == neutral)
  608.         u = ppos[u];
  609.       else
  610.         u = pdir[u];
  611.   } while (u != sq);
  612. }
  613.  
  614.  
  615.  
  616. void
  617. MoveList (short int side, register short int ply)
  618.  
  619. /*
  620.  * Fill the array Tree[] with all available moves for side to play. Array
  621.  * TrPnt[ply] contains the index into Tree[] of the first move at a ply.
  622.  */
  623.  
  624. {
  625.   register short i, xside, f;
  626.   struct leaf *firstnode;
  627.  
  628.   xside = side ^ 1;
  629.   if ( flag.tsume )
  630.     {
  631.       sqking  = PieceList[side][0];
  632.       sqxking = PieceList[xside][0];
  633.       InCheck = (board[sqking] == king) ? SqAtakd(sqking,xside) : false;
  634.     }
  635.   TrP = &TrPnt[ply + 1];
  636.   *TrP = TrPnt[ply];
  637.   firstnode = node = &Tree[*TrP];
  638.   if (!PV)
  639.     Swag0 = killr0[ply];
  640.    else Swag0 = PV;
  641.   Swag1 = killr1[ply];
  642.   Swag2 = killr2[ply];
  643.   Swag3 = killr3[ply];
  644.   if (ply > 2)
  645.     Swag4 = killr1[ply - 2]; else Swag4 = 0;
  646. #ifdef HISTORY
  647.   history[hindex(side,SwagHt)] += 5000;
  648.   history[hindex(side,Swag0)] += 2000;
  649.   history[hindex(side,Swag1)] += 60;
  650.   history[hindex(side,Swag2)] += 50;
  651.   history[hindex(side,Swag3)] += 40;
  652.   history[hindex(side,Swag4)] += 30;
  653. #endif
  654.   for (i = PieceCnt[side]; i >= 0; i--)
  655.     GenMoves (ply, PieceList[side][i], side, xside);
  656.   for (i = pawn; i < king; i++)
  657.     if ( Captured[side][i] )
  658.       GenDrops (ply, i, side, xside);
  659. #ifdef HISTORY
  660.   history[hindex(side,SwagHt)] -= 5000;
  661.   history[hindex(side,Swag0)] -= 2000;
  662.   history[hindex(side,Swag1)] -= 60;
  663.   history[hindex(side,Swag2)] -= 50;
  664.   history[hindex(side,Swag3)] -= 40;
  665.   history[hindex(side,Swag4)] -= 30;
  666. #endif
  667.   SwagHt = 0;            /* SwagHt is only used once */
  668.   if ( 0 /* flag.tsume */ )
  669.     if ( node == firstnode )
  670.       (*TrP)++;
  671.   GenCnt += (TrPnt[ply+1] - TrPnt[ply]);
  672. }
  673.  
  674. void
  675. CaptureList (register short int side, short int ply)
  676.  
  677. /*
  678.  * Fill the array Tree[] with all available captures for side to play.
  679.  * If there is a non-promote option, discard the non-promoting move.
  680.  * Array TrPnt[ply] contains the index into Tree[] of the first move
  681.  * at a ply.      
  682.  * If flag.tsume is set, add moves (even non-promoting moves)
  683.  * that threatens the opponents piece.
  684.  */
  685.  
  686. {
  687.   register short u, sq, xside;
  688.   register unsigned char *ppos, *pdir;
  689.   short i, piece, flag_tsume;
  690.   small_short *PL;
  691.   struct leaf *firstnode;
  692.  
  693.   xside = side ^ 1;
  694.  
  695.   if ( flag.tsume )
  696.     {
  697.       sqking = PieceList[side][0];
  698.       sqxking = PieceList[xside][0];
  699.       InCheck = (board[sqking] == king) ? SqAtakd(sqking,xside) : false;
  700.     }
  701.  
  702.   TrP = &TrPnt[ply + 1];
  703.   *TrP = TrPnt[ply];
  704.   firstnode = node = &Tree[*TrP];
  705.  
  706.   flag_tsume = flag.tsume;
  707.  
  708.   if ( *TrP > TREE - 300 ) 
  709.     {
  710.       /* too close to tree table limit */
  711.       flag.tsume = true;
  712.     }
  713.  
  714.   PL = PieceList[side];
  715.  
  716.   for (i = 0; i <= PieceCnt[side]; i++)
  717.     { short ptyp;
  718.       sq = PL[i];
  719.       piece = board[sq];
  720.       ptyp = ptype[side][piece];
  721.       ppos = (*nextpos[ptyp])[sq];
  722.       pdir = (*nextdir[ptyp])[sq];
  723.       u = ppos[sq];
  724.       do
  725.     { 
  726.       if (color[u] == neutral)
  727.         { 
  728.           u = ppos[u];
  729.         }
  730.       else
  731.         { 
  732.           if ( color[u] == xside && board[u] != king )
  733.         { 
  734.           short PP;
  735.           if ( PP = PromotionPossible(color[sq],sq,u,piece) ) {
  736.                     Link (side, piece, 
  737.               sq, u, capture | promote,
  738.                           value[board[u]] + svalue[board[u]] 
  739.                             - relative_value[piece]);
  740.                   } 
  741.           if ( !PP || flag.tsume ) {
  742.                     Link (side, piece, 
  743.               sq, u, capture,
  744.                           value[board[u]] + svalue[board[u]] 
  745.                             - relative_value[piece]);
  746.                   }  
  747.            }
  748.           u = pdir[u];
  749.         }
  750.     } while (u != sq);
  751.     }
  752.  
  753.   flag.tsume = flag_tsume;
  754.  
  755.   SwagHt = 0;            /* SwagHt is only used once */
  756.  
  757. } 
  758.  
  759.