src/attack.cpp

   1 /* Copyright (C) 2007-2012 Vincent Ollivier
   2  *
   3  * Purple Haze is free software: you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation, either version 3 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * Purple Haze is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  15  */
  16
  17 #include <cassert>
  18
  19 #include "game.h"
  20
  21 /*
  22  * Return true if the square s is attacked by one of the c color's pieces.
  23  */
  24 bool Board::is_attacked_by(const Color c, const Square s,
  25                            const Pieces& pieces) const
  26 {
  27     for (const PieceType& t : NOT_PAWN_TYPES) {
  28         for (int i = 0, n = pieces.count(c, t); i < n; ++i) {
  29             const Square from = pieces.position(c, t, i);
  30             if (!can_attack(t, from, s)) {
  31                 continue;
  32             }
  33             if (t == KNIGHT || t == KING) {
  34                 return true;
  35             }
  36             const Direction d = direction_to(from, s);
  37             Square to = static_cast<Square>(from + d);
  38             while (to != s && is_empty(to)) {
  39                 to = static_cast<Square>(to + d);
  40             }
  41             if (to == s) {
  42                 return true;
  43             }
  44         }
  45     }
  46
  47     // Specific code for pawns
  48     for (const Direction &d : PAWN_CAPTURE_DIRS[!c]) {
  49         const Square from = static_cast<Square>(s + d);
  50         if (board[from].is(c, PAWN)) {
  51             return true;
  52         }
  53     }
  54
  55     return false;
  56 }
  57
  58 /*
  59  * Return 'true' if a piece 'p' can do a capture or a quiet move from
  60  * square 'from' to square 'to' on the board. This function does not
  61  * say if the move is legal.
  62  */
  63 bool Board::can_go(const Piece p, const Square from, const Square to) const
  64 {
  65     const Color c = p.color();
  66
  67     // A piece cannot capture another piece of the same color
  68     if (!is_empty(to) && board[to].is(c)) {
  69         return false;
  70     }
  71
  72     Direction d;
  73     Square s;
  74     const PieceType t = p.type();
  75     switch (t) {
  76     case PAWN:
  77         d = PAWN_PUSH_DIRS[c];
  78         s = static_cast<Square>(from + d);
  79         if (!is_empty(to)) { // Capture
  80             if (to == static_cast<Square>(s + LEFT)) {
  81                 return true;
  82             }
  83             if (to == static_cast<Square>(s + RIGHT)) {
  84                 return true;
  85             }
  86         } else { // Pawn push (and double push)
  87             if (to == s) {
  88                 return true;
  89             }
  90             if (to == static_cast<Square>(s + d)) {
  91                 if (is_empty(s) && is_pawn_begin(c, from)) {
  92                     return true;
  93                 }
  94             }
  95         }
  96         break;
  97     default:
  98         if (!can_attack(t, from, to)) {
  99             return false;
 100         }
 101         if (t == KNIGHT || t == KING) {
 102             return true;
 103         }
 104         d = direction_to(from, to);
 105         s = static_cast<Square>(from + d);
 106         while (s != to && is_empty(s)) { // Search for a blocker
 107             s = static_cast<Square>(s + d);
 108             assert(!is_out(s));
 109         }
 110         if (s == to) {
 111             return true;
 112         }
 113         break;
 114     }
 115     return false;
 116 }