Subversion Repositories Games.Chess Giants

/*

    Texel - A UCI chess engine.

    Copyright (C) 2012-2014  Peter Österlund, peterosterlund2@gmail.com

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

/*

 * moveGen.hpp

 *

 *  Created on: Feb 25, 2012

 *      Author: petero

 */

#ifndef MOVEGEN_HPP_

#define MOVEGEN_HPP_

#include "move.hpp"

#include "position.hpp"

#include "util/util.hpp"

#include <cassert>

//#define MOVELIST_DEBUG

#ifdef MOVELIST_DEBUG

# include <set>

# include "textio.hpp"

#endif

/** A stack-allocated move list object. */

class MoveList {

public:

    MoveList();

    void clear();

          Move& operator[](int i);

    const Move& operator[](int i) const;

    void addMove(int from, int to, int promoteTo);

    /** Remove all moves that are not included in searchMoves. */

    void filter(const std::vector<Move>& searchMoves);

    int size;

private:

    static const int MAX_MOVES = 256;

    int buf[sizeof(Move[MAX_MOVES])/sizeof(int)];

};

/**

 * Generates move lists (pseudo-legal, legal, check evasions, captures).

 */

class MoveGen {

public:

    MoveGen() = delete;

    /**

     * Generate and return a list of pseudo-legal moves.

     * Pseudo-legal means that the moves don't necessarily defend from check threats.

     */

    template <bool wtm>

    static void pseudoLegalMoves(const Position& pos, MoveList& moveList);

    static void pseudoLegalMoves(const Position& pos, MoveList& moveList);

    /**

     * Generate and return a list of pseudo-legal check evasion moves.

     * Pseudo-legal means that the moves don't necessarily defend from check threats.

     */

    template <bool wtm>

    static void checkEvasions(const Position& pos, MoveList& moveList);

    static void checkEvasions(const Position& pos, MoveList& moveList);

    /** Generate captures, checks, and possibly some other moves that are too hard to filter out. */

    template <bool wtm>

    static void pseudoLegalCapturesAndChecks(const Position& pos, MoveList& moveList);

    static void pseudoLegalCapturesAndChecks(const Position& pos, MoveList& moveList);

    /** Generate and return a list of pseudo-legal capture moves. */

    template <bool wtm>

    static void pseudoLegalCaptures(const Position& pos, MoveList& moveList);

    static void pseudoLegalCaptures(const Position& pos, MoveList& moveList);

    /** Return true if the side to move is in check. */

    static bool inCheck(const Position& pos);

    /** Return true if making a move delivers check to the opponent */

    static bool givesCheck(const Position& pos, const Move& m);

    /** Return true if the side to move can take the opponents king. */

    static bool canTakeKing(Position& pos);

    /** Return true if a square is attacked by the opposite side. */

    static bool sqAttacked(const Position& pos, int sq);

    static bool sqAttacked(const Position& pos, int sq, U64 occupied);

    template <bool wtm> static bool sqAttacked(const Position& pos, int sq, U64 occupied);

    /**

     * Remove all illegal moves from moveList.

     * "moveList" is assumed to be a list of pseudo-legal moves.

     * This function removes the moves that don't defend from check threats.

     */

    static void removeIllegal(Position& pos, MoveList& moveList);

    /** Return true if the pseudo-legal move "move" is legal is position "pos".

     * isInCheck must be equal to inCheck(pos). */

    static bool isLegal(Position& pos, const Move& move, bool isInCheck);

private:

    /** Return the next piece in a given direction, starting from sq. */

    static int nextPiece(const Position& pos, int sq, int delta);

    /** Like nextPiece(), but handles board edges. */

    static int nextPieceSafe(const Position& pos, int sq, int delta);

    template <bool wtm>

    static void addPawnMovesByMask(MoveList& moveList, U64 mask, int delta, bool allPromotions);

    static void addPawnDoubleMovesByMask(MoveList& moveList, U64 mask, int delta);

    static void addMovesByMask(MoveList& moveList, int sq0, U64 mask);

};

inline

MoveList::MoveList()

    : size(0) {

}

inline void

MoveList::clear() {

    size = 0;

}

inline Move&

MoveList::operator[](int i) {

    return ((Move*)&buf[0])[i];

}

inline const Move&

MoveList::operator[](int i) const {

    return ((Move*)&buf[0])[i];

}

inline void

MoveList::addMove(int from, int to, int promoteTo) {

    Move& m = (*this)[size++];

    new (&m) Move(from, to, promoteTo, 0);

}

inline void

MoveGen::pseudoLegalMoves(const Position& pos, MoveList& moveList) {

    if (pos.isWhiteMove())

        pseudoLegalMoves<true>(pos, moveList);

    else

        pseudoLegalMoves<false>(pos, moveList);

}

inline void

MoveGen::checkEvasions(const Position& pos, MoveList& moveList) {

    if (pos.isWhiteMove())

        checkEvasions<true>(pos, moveList);

    else

        checkEvasions<false>(pos, moveList);

}

inline void

MoveGen::pseudoLegalCapturesAndChecks(const Position& pos, MoveList& moveList) {

    if (pos.isWhiteMove())

        pseudoLegalCapturesAndChecks<true>(pos, moveList);

    else

        pseudoLegalCapturesAndChecks<false>(pos, moveList);

}

inline void

MoveGen::pseudoLegalCaptures(const Position& pos, MoveList& moveList) {

    if (pos.isWhiteMove())

        pseudoLegalCaptures<true>(pos, moveList);

    else

        pseudoLegalCaptures<false>(pos, moveList);

}

inline bool

MoveGen::inCheck(const Position& pos) {

    int kingSq = pos.getKingSq(pos.isWhiteMove());

    return sqAttacked(pos, kingSq);

}

inline bool

MoveGen::canTakeKing(Position& pos) {

    pos.setWhiteMove(!pos.isWhiteMove());

    bool ret = inCheck(pos);

    pos.setWhiteMove(!pos.isWhiteMove());

    return ret;

}

inline bool

MoveGen::sqAttacked(const Position& pos, int sq) {

    const U64 occupied = pos.occupiedBB();

    return sqAttacked(pos, sq, occupied);

}

inline bool

MoveGen::sqAttacked(const Position& pos, int sq, U64 occupied) {

    return pos.isWhiteMove() ? sqAttacked<true>(pos, sq, occupied)

                             : sqAttacked<false>(pos, sq, occupied);

}

template <bool wtm>

inline bool

MoveGen::sqAttacked(const Position& pos, int sq, U64 occupied) {

    using OtherColor = ColorTraits<!wtm>;

    if ((BitBoard::knightAttacks[sq] & pos.pieceTypeBB(OtherColor::KNIGHT)) != 0)

        return true;

    if ((BitBoard::kingAttacks[sq] & pos.pieceTypeBB(OtherColor::KING)) != 0)

        return true;

    if (wtm) {

        if ((BitBoard::wPawnAttacks[sq] & pos.pieceTypeBB(OtherColor::PAWN)) != 0)

            return true;

    } else {

        if ((BitBoard::bPawnAttacks[sq] & pos.pieceTypeBB(OtherColor::PAWN)) != 0)

            return true;

    }

    U64 bbQueen = pos.pieceTypeBB(OtherColor::QUEEN);

    if ((BitBoard::bishopAttacks(sq, occupied) & (pos.pieceTypeBB(OtherColor::BISHOP) | bbQueen)) != 0)

        return true;

    if ((BitBoard::rookAttacks(sq, occupied) & (pos.pieceTypeBB(OtherColor::ROOK) | bbQueen)) != 0)

        return true;

    return false;

}

inline int

MoveGen::nextPiece(const Position& pos, int sq, int delta) {

    while (true) {

        sq += delta;

        int p = pos.getPiece(sq);

        if (p != Piece::EMPTY)

            return p;

    }

    assert(false);

    return -1;

}

inline int

MoveGen::nextPieceSafe(const Position& pos, int sq, int delta) {

    int dx = 0, dy = 0;

    switch (delta) {

    case 1: dx=1; dy=0; break;

    case 9: dx=1; dy=1; break;

    case 8: dx=0; dy=1; break;

    case 7: dx=-1; dy=1; break;

    case -1: dx=-1; dy=0; break;

    case -9: dx=-1; dy=-1; break;

    case -8: dx=0; dy=-1; break;

    case -7: dx=1; dy=-1; break;

    }

    int x = Position::getX(sq);

    int y = Position::getY(sq);

    while (true) {

        x += dx;

        y += dy;

        if ((x < 0) || (x > 7) || (y < 0) || (y > 7)) {

            return Piece::EMPTY;

        }

        int p = pos.getPiece(Position::getSquare(x, y));

        if (p != Piece::EMPTY)

            return p;

    }

    assert(false);

    return -1;

}

template <bool wtm>

inline void

MoveGen::addPawnMovesByMask(MoveList& moveList, U64 mask, int delta, bool allPromotions) {

    using MyColor = ColorTraits<wtm>;

    if (mask == 0)

        return;

    U64 promMask = mask & BitBoard::maskRow1Row8;

    mask &= ~promMask;

    while (promMask != 0) {

        int sq = BitBoard::extractSquare(promMask);

        int sq0 = sq + delta;

        moveList.addMove(sq0, sq, MyColor::QUEEN);

        moveList.addMove(sq0, sq, MyColor::KNIGHT);

        if (allPromotions) {

            moveList.addMove(sq0, sq, MyColor::ROOK);

            moveList.addMove(sq0, sq, MyColor::BISHOP);

        }

    }

    while (mask != 0) {

        int sq = BitBoard::extractSquare(mask);

        moveList.addMove(sq + delta, sq, Piece::EMPTY);

    }

}

inline void

MoveGen::addPawnDoubleMovesByMask(MoveList& moveList, U64 mask, int delta) {

    while (mask != 0) {

        int sq = BitBoard::extractSquare(mask);

        moveList.addMove(sq + delta, sq, Piece::EMPTY);

    }

}

inline void

MoveGen::addMovesByMask(MoveList& moveList, int sq0, U64 mask) {

    while (mask != 0) {

        int sq = BitBoard::extractSquare(mask);

        moveList.addMove(sq0, sq, Piece::EMPTY);

    }

}

#endif /* MOVEGEN_HPP_ */