WebSVN – Games.Chess Giants – Diff – //move.cpp

 #define IS_FREE(li,co) (IS_VALID ((li), (co)) && (move->slots[(li)][(co)].part == PART_NONE))
 #define CAN_PLAY(li,co) (IS_VALID ((li), (co)) && ((move->slots[(li)][(co)].part == PART_NONE) || (move->slots[(li)][(co)].color != boardslot->color)))
 // prototypes of local functions
+static bool Move_IsWayClearBetween (boardmove_t *move, int source_line, int source_column, int target_line, int target_column);
 static void AddPossibleMove (boardmove_t **possiblemoves, int *possiblemove_count, int color, int part, int source_line, int source_column, int target_line, int target_column, int promotion_type, bool has_captured, bool is_enpassant);
 void Move_SetSlot (boardmove_t *move, int line, int column, int color, int part_type)
+{
             for (index_line = line + 1; index_line < 8; index_line++)
                if (!CAN_PLAY (index_line, column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if rook can move downwards
             for (index_line = line - 1; index_line >= 0; index_line--)
                if (!CAN_PLAY (index_line, column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if rook can move right
             for (index_column = column + 1; index_column < 8; index_column++)
                if (!CAN_PLAY (line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if rook can move left
             for (index_column = column - 1; index_column >= 0; index_column--)
                if (!CAN_PLAY (line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
+         }
          //////////////////////////////////////////////////////////////////////////////////////////
          ///////////////////////////////////////// KNIGHT /////////////////////////////////////////
          //////////////////////////////////////////////////////////////////////////////////////////
             for (index_line = line + 1, index_column = column + 1; (index_line < 8) && (index_column < 8); index_line++, index_column++)
                if (!CAN_PLAY (index_line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if bishop can move SE
             for (index_line = line - 1, index_column = column + 1; (index_line >= 0) && (index_column < 8); index_line--, index_column++)
                if (!CAN_PLAY (index_line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if bishop can move NW
             for (index_line = line + 1, index_column = column - 1; (index_line < 8) && (index_column >= 0); index_line++, index_column--)
                if (!CAN_PLAY (index_line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if bishop can move SW
             for (index_line = line - 1, index_column = column - 1; (index_line >= 0) && (index_column >= 0); index_line--, index_column--)
                if (!CAN_PLAY (index_line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
+         }
          //////////////////////////////////////////////////////////////////////////////////////////
          ///////////////////////////////////////// QUEEN //////////////////////////////////////////
          //////////////////////////////////////////////////////////////////////////////////////////
             for (index_line = line + 1; index_line < 8; index_line++)
                if (!CAN_PLAY (index_line, column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if queen can move downwards
             for (index_line = line - 1; index_line >= 0; index_line--)
                if (!CAN_PLAY (index_line, column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if queen can move right
             for (index_column = column + 1; index_column < 8; index_column++)
                if (!CAN_PLAY (line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if queen can move left
             for (index_column = column - 1; index_column >= 0; index_column--)
                if (!CAN_PLAY (line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if queen can move NE
             for (index_line = line + 1, index_column = column + 1; (index_line < 8) && (index_column < 8); index_line++, index_column++)
                if (!CAN_PLAY (index_line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if queen can move SE
             for (index_line = line - 1, index_column = column + 1; (index_line >= 0) && (index_column < 8); index_line--, index_column++)
                if (!CAN_PLAY (index_line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if queen can move NW
             for (index_line = line + 1, index_column = column - 1; (index_line < 8) && (index_column >= 0); index_line++, index_column--)
                if (!CAN_PLAY (index_line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
             // see if queen can move SW
             for (index_line = line - 1, index_column = column - 1; (index_line >= 0) && (index_column >= 0); index_line--, index_column--)
                if (!CAN_PLAY (index_line, index_column))
                   break; // if part can no longer move this way, stop searching
                else if (!Move_IsColorInCheckAfterTestMove (move, line, column, index_line, index_column, color))
                   return (false); // this move is possible
+               else if (move->slots[index_line][index_column].part != PART_NONE)
+                  break; // no further moves are possible in the same direction
+         }
          //////////////////////////////////////////////////////////////////////////////////////////
          ////////////////////////////////////////// KING //////////////////////////////////////////
          //////////////////////////////////////////////////////////////////////////////////////////
    else if (boardslot->part == PART_ROOK)
+   {
       // quick checks
       if ((to_column != from_column) && (to_line != from_line))
          return (false); // rooks can only move horizontally or vertically
+      else if (!Move_IsWayClearBetween (move, from_line, from_column, to_line, to_column))
+         return (false); // way must be clear between source and target
       // do we want the rook to move upwards ?
       if (to_line > from_line)
+      {
          // see if rook can move upwards
          for (index_line = from_line + 1; index_line < 8; index_line++)
             if (!CAN_PLAY (index_line, to_column))
                return (false); // if rook can no longer move this way, stop searching
             else if (index_line == to_line)
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this rook can't move in the claimed way (its king would be in check)
-            }
-            else if (move->slots[index_line][to_column].part != PART_NONE)
-               return (false); // rook can take a part there BUT it's not the location we want
+      }
       // else do we want the rook to move downwards ?
       else if (to_line < from_line)
+      {
          // see if rook can move downwards
          for (index_line = from_line - 1; index_line >= 0; index_line--)
             if (!CAN_PLAY (index_line, to_column))
                return (false); // if rook can no longer move this way, stop searching
             else if (index_line == to_line)
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this rook can't move in the claimed way (its king would be in check)
-            }
-            else if (move->slots[index_line][to_column].part != PART_NONE)
-               return (false); // rook can take a part there BUT it's not the location we want
+      }
       // else do we want the rook to move right ?
       else if (to_column > from_column)
+      {
          // see if rook can move right
          for (index_column = from_column + 1; index_column < 8; index_column++)
             if (!CAN_PLAY (to_line, index_column))
                return (false); // if rook can no longer move this way, stop searching
             else if (index_column == to_column)
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this rook can't move in the claimed way (its king would be in check)
-            }
-            else if (move->slots[to_line][index_column].part != PART_NONE)
-               return (false); // rook can take a part there BUT it's not the location we want
+      }
       // else do we want the rook to move left ?
       else if (to_column < from_column)
+      {
          // see if rook can move left
          for (index_column = from_column - 1; index_column >= 0; index_column--)
             if (!CAN_PLAY (to_line, index_column))
                return (false); // if rook can no longer move this way, stop searching
             else if (index_column == to_column)
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this rook can't move in the claimed way (its king would be in check)
-            }
-            else if (move->slots[to_line][index_column].part != PART_NONE)
-               return (false); // rook can take a part there BUT it's not the location we want
+      }
       return (false); // this rook can't move in the claimed way
+   }
    //////////////////////////////////////////////////////////////////////////////////////////
    // else is it a knight ?
    else if (boardslot->part == PART_KNIGHT)
+   {
       // do we want to move that knight in one of the allowed directions ?
-      if (((from_line + 2 == to_line) && (from_column - 1 == to_column)) // NNW
+      if (   ((from_line + 2 == to_line) && (from_column - 1 == to_column)) // NNW
           || ((from_line + 2 == to_line) && (from_column + 1 == to_column)) // NNE
           || ((from_line + 1 == to_line) && (from_column + 2 == to_column)) // ENE
           || ((from_line - 1 == to_line) && (from_column + 2 == to_column)) // ESE
           || ((from_line - 2 == to_line) && (from_column - 1 == to_column)) // SSW
           || ((from_line - 2 == to_line) && (from_column + 1 == to_column)) // SSE
    else if (boardslot->part == PART_BISHOP)
+   {
       // quick checks
       if (abs (to_column - from_column) != abs (to_line - from_line))
          return (false); // bishops can only move diagonally
+      else if (!Move_IsWayClearBetween (move, from_line, from_column, to_line, to_column))
+         return (false); // way must be clear between source and target
       // do we want to move the bishop NE ?
       if ((to_line > from_line) && (to_column > from_column))
+      {
          // see if bishop can move NE
          for (index_line = from_line + 1, index_column = from_column + 1; (index_line < 8) && (index_column < 8); index_line++, index_column++)
             if (!CAN_PLAY (index_line, index_column))
                return (false); // if bishop can no longer move this way, stop searching
             else if ((index_line == to_line) && (index_column == to_column))
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this bishop can't move in the claimed way (his king would be in check)
-            }
-            else if (move->slots[index_line][index_column].part != PART_NONE)
-               return (false); // bishop can take a part there BUT it's not the location we want
+      }
       // else do we want to move the bishop SE ?
       else if ((to_line < from_line) && (to_column > from_column))
+      {
          // see if bishop can move SE
          for (index_line = from_line - 1, index_column = from_column + 1; (index_line >= 0) && (index_column < 8); index_line--, index_column++)
             if (!CAN_PLAY (index_line, index_column))
                return (false); // if bishop can no longer move this way, stop searching
             else if ((index_line == to_line) && (index_column == to_column))
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this bishop can't move in the claimed way (his king would be in check)
-            }
-            else if (move->slots[index_line][index_column].part != PART_NONE)
-               return (false); // bishop can take a part there BUT it's not the location we want
+      }
       // else do we want to move the bishop NW ?
       else if ((to_line > from_line) && (to_column < from_column))
+      {
          // see if bishop can move NW
          for (index_line = from_line + 1, index_column = from_column - 1; (index_line < 8) && (index_column >= 0); index_line++, index_column--)
             if (!CAN_PLAY (index_line, index_column))
                return (false); // if bishop can no longer move this way, stop searching
             else if ((index_line == to_line) && (index_column == to_column))
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this bishop can't move in the claimed way (his king would be in check)
-            }
-            else if (move->slots[index_line][index_column].part != PART_NONE)
-               return (false); // bishop can take a part there BUT it's not the location we want
+      }
       // else do we want to move the bishop SW ?
       else if ((to_line < from_line) && (to_column < from_column))
+      {
          // see if bishop can move SW
          for (index_line = from_line - 1, index_column = from_column - 1; (index_line >= 0) && (index_column >= 0); index_line--, index_column--)
             if (!CAN_PLAY (index_line, index_column))
                return (false); // if bishop can no longer move this way, stop searching
             else if ((index_line == to_line) && (index_column == to_column))
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this bishop can't move in the claimed way (his king would be in check)
-            }
-            else if (move->slots[index_line][index_column].part != PART_NONE)
-               return (false); // bishop can take a part there BUT it's not the location we want
+      }
       return (false); // this bishop can't move in the claimed way
+   }
+   {
       // quick checks
       if ((to_column != from_column) && (to_line != from_line)
           && (abs (to_column - from_column) != abs (to_line - from_line)))
          return (false); // queens can only move horizontally, vertically or diagonally
+      else if (!Move_IsWayClearBetween (move, from_line, from_column, to_line, to_column))
+         return (false); // way must be clear between source and target
       // do we want to move that queen vertically ?
       if (from_column == to_column)
+      {
          // do we want to move her upwards ?
             // see if queen can move upwards
             for (index_line = from_line + 1; index_line < 8; index_line++)
                if (!CAN_PLAY (index_line, to_column))
                   return (false); // if queen can no longer move this way, stop searching
                else if (index_line == to_line)
-               {
-                  if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color))
+                  return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color)); // if move is safe for king, then it's possible
-                     return (true); // this move is possible
-                  return (false); // else this queen can't move in the claimed way (her king would be in check)
-               }
-               else if (move->slots[index_line][to_column].part != PART_NONE)
-                  return (false); // queen can take a part there BUT it's not the location we want
+         }
          // else do we want to move her downwards ?
          else if (to_line < from_line)
+         {
             // see if queen can move downwards
             for (index_line = from_line - 1; index_line >= 0; index_line--)
                if (!CAN_PLAY (index_line, to_column))
                   return (false); // if queen can no longer move this way, stop searching
                else if (index_line == to_line)
-               {
-                  if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color))
+                  return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color)); // if move is safe for king, then it's possible
-                     return (true); // this move is possible
-                  return (false); // else this queen can't move in the claimed way (her king would be in check)
-               }
-               else if (move->slots[index_line][to_column].part != PART_NONE)
-                  return (false); // queen can take a part there BUT it's not the location we want
+         }
          return (false); // this queen can't move in the claimed way
+      }
             // see if queen can move right
             for (index_column = from_column + 1; index_column < 8; index_column++)
                if (!CAN_PLAY (to_line, index_column))
                   return (false); // if queen can no longer move this way, stop searching
                else if (index_column == to_column)
-               {
-                  if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color))
+                  return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color)); // if move is safe for king, then it's possible
-                     return (true); // this move is possible
-                  return (false); // else this queen can't move in the claimed way (her king would be in check)
-               }
-               else if (move->slots[to_line][index_column].part != PART_NONE)
-                  return (false); // queen can take a part there BUT it's not the location we want
+         }
          // else do we want this queen to move left ?
          else if (to_column < from_column)
+         {
             // see if queen can move left
             for (index_column = from_column - 1; index_column >= 0; index_column--)
                if (!CAN_PLAY (to_line, index_column))
                   return (false); // if queen can no longer move this way, stop searching
                else if (index_column == to_column)
-               {
-                  if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color))
+                  return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, to_line, to_column, boardslot->color)); // if move is safe for king, then it's possible
-                     return (true); // this move is possible
-                  return (false); // else this queen can't move in the claimed way (her king would be in check)
-               }
-               else if (move->slots[to_line][index_column].part != PART_NONE)
-                  return (false); // queen can take a part there BUT it's not the location we want
+         }
          return (false); // this queen can't move in the claimed way
+      }
          // see if queen can move NE
          for (index_line = from_line + 1, index_column = from_column + 1; (index_line < 8) && (index_column < 8); index_line++, index_column++)
             if (!CAN_PLAY (index_line, index_column))
                return (false); // if queen can no longer move this way, stop searching
             else if ((index_line == to_line) && (index_column == to_column))
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this queen can't move in the claimed way (her king would be in check)
-            }
-            else if (move->slots[index_line][index_column].part != PART_NONE)
-               return (false); // queen can take a part there BUT it's not the location we want
+      }
       // else do we want to move the queen SE ?
       else if ((to_line < from_line) && (to_column > from_column))
+      {
          // see if queen can move SE
          for (index_line = from_line - 1, index_column = from_column + 1; (index_line >= 0) && (index_column < 8); index_line--, index_column++)
             if (!CAN_PLAY (index_line, index_column))
                return (false); // if queen can no longer move this way, stop searching
             else if ((index_line == to_line) && (index_column == to_column))
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this queen can't move in the claimed way (her king would be in check)
-            }
-            else if (move->slots[index_line][index_column].part != PART_NONE)
-               return (false); // queen can take a part there BUT it's not the location we want
+      }
       // else do we want to move the queen NW ?
       else if ((to_line > from_line) && (to_column < from_column))
+      {
          // see if queen can move NW
          for (index_line = from_line + 1, index_column = from_column - 1; (index_line < 8) && (index_column >= 0); index_line++, index_column--)
             if (!CAN_PLAY (index_line, index_column))
                return (false); // if queen can no longer move this way, stop searching
             else if ((index_line == to_line) && (index_column == to_column))
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this queen can't move in the claimed way (her king would be in check)
-            }
-            else if (move->slots[index_line][index_column].part != PART_NONE)
-               return (false); // queen can take a part there BUT it's not the location we want
+      }
       // else do we want to move the queen SW ?
       else if ((to_line < from_line) && (to_column < from_column))
+      {
          // see if queen can move SW
          for (index_line = from_line - 1, index_column = from_column - 1; (index_line >= 0) && (index_column >= 0); index_line--, index_column--)
             if (!CAN_PLAY (index_line, index_column))
                return (false); // if queen can no longer move this way, stop searching
             else if ((index_line == to_line) && (index_column == to_column))
-            {
-               if (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color))
+               return (!Move_IsColorInCheckAfterTestMove (move, from_line, from_column, index_line, index_column, boardslot->color)); // if move is safe for king, then it's possible
-                  return (true); // this move is possible
-               return (false); // else this queen can't move in the claimed way (her king would be in check)
-            }
-            else if (move->slots[index_line][index_column].part != PART_NONE)
-               return (false); // queen can take a part there BUT it's not the location we want
+      }
       return (false); // this queen can't move in the claimed way
+   }
+   }
    // finally, save the FEN string with which we initialized this board
    Move_DescribeInFEN (move);
    return (true); // finished, no error encountered
+}
+static bool Move_IsWayClearBetween (boardmove_t *move, int source_line, int source_column, int target_line, int target_column)
+{
+   // helper function that checks and returns whether the way is clear between source and target.
+   int column_delta_step;
+   int line_delta_step;
+   int column_delta;
+   int line_delta;
+   int column;
+   int line;
+   line_delta = target_line - source_line;
+   line_delta_step = (line_delta != 0 ? line_delta / abs (line_delta) : 0);
+   column_delta = target_column - source_column;
+   column_delta_step = (column_delta != 0 ? column_delta / abs (column_delta) : 0);
+   // for each square that's between source and target...
+   for (line = source_line + line_delta_step, column = source_column + column_delta_step;
+        IS_VALID (line, column) && (line != target_line || column != target_column);
+        line += line_delta_step, column += column_delta_step)
+      if ((line == target_line) && (column == target_column))
+         break; // don't verify the target position's square
+      else if (move->slots[line][column].part != PART_NONE)
+         return (false); // there's something in the way...
+   if (!IS_VALID (line, column))
+      return (false); // we've gotten off board...
+   return (true); // the way looks clear between source and target
+}
 static void AddPossibleMove (boardmove_t **possiblemoves, int *possiblemove_count, int color, int part, int source_line, int source_column, int target_line, int target_column, int promotion_type, bool has_captured, bool is_enpassant)
+{

Subversion Repositories Games.Chess Giants

Games.Chess Giants//move.cpp – Rev 44 → 74