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/>.

*/

/*

 * evaluate.hpp

 *

 *  Created on: Feb 25, 2012

 *      Author: petero

 */

#ifndef EVALUATE_HPP_

#define EVALUATE_HPP_

#include "parameters.hpp"

#include "piece.hpp"

#include "position.hpp"

#include "util/alignedAlloc.hpp"

class EvaluateTest;

/** Position evaluation routines. */

class Evaluate {

    friend class EvaluateTest;

private:

    struct PawnHashData {

        PawnHashData();

        U64 key;

        S16 current;        // For hash replacement policy

        S16 score;          // Positive score means good for white

        S16 passedBonusW;

        S16 passedBonusB;

        U64 passedPawns;    // The most advanced passed pawns for each file

                            // Contains both white and black pawns

        U64 outPostsW;      // Possible outpost squares for white

        U64 outPostsB;

        U64 stalePawns;     // Pawns that can not be used for "pawn breaks"

    };

    struct MaterialHashData {

        MaterialHashData();

        int id;

        int score;

        S16 wPawnIPF, bPawnIPF;

        S16 wKnightIPF, bKnightIPF;

        S16 castleIPF, queenIPF;

        S16 wPassedPawnIPF, bPassedPawnIPF;

        S16 kingSafetyIPF;

        S16 diffColorBishopIPF;

        S16 wKnightOutPostIPF, bKnightOutPostIPF;

        U8 endGame;

    };

    struct KingSafetyHashData {

        KingSafetyHashData();

        U64 key;

        int score;

        S16 current;        // For hash replacement policy

    };

public:

    struct EvalHashTables {

        EvalHashTables();

        std::vector<PawnHashData> pawnHash;

        std::vector<MaterialHashData> materialHash;

        vector_aligned<KingSafetyHashData> kingSafetyHash;

    };

    /** Constructor. */

    Evaluate(EvalHashTables& et);

    static int pieceValueOrder[Piece::nPieceTypes];

    static const int* psTab1[Piece::nPieceTypes];

    static const int* psTab2[Piece::nPieceTypes];

    /** Get evaluation hash tables. */

    static std::shared_ptr<EvalHashTables> getEvalHashTables();

    /**

     * Static evaluation of a position.

     * @param pos The position to evaluate.

     * @return The evaluation score, measured in centipawns.

     *         Positive values are good for the side to make the next move.

     */

    int evalPos(const Position& pos);

    int evalPosPrint(const Position& pos);

    /** Compute "swindle" score corresponding to an evaluation score when

     * the position is a known TB draw. */

    static int swindleScore(int evalScore);

    /**

     * Interpolate between (x1,y1) and (x2,y2).

     * If x < x1, return y1, if x > x2 return y2. Otherwise, use linear interpolation.

     */

    static int interpolate(int x, int x1, int y1, int x2, int y2);

    static const int IPOLMAX = 1024;

    /** Compute v1 + (v2-v1)*k/IPOLMAX */

    static int interpolate(int v1, int v2, int k);

    static void staticInitialize();

    static void updateEvalParams();

private:

    template <bool print> int evalPos(const Position& pos);

    /** Compute score based on piece square tables. Positive values are good for white. */

    int pieceSquareEval(const Position& pos);

    /** Get material score */

    int materialScore(const Position& pos, bool print);

    /** Compute material score. */

    void computeMaterialScore(const Position& pos, MaterialHashData& mhd, bool print) const;

    /** Implement the "when ahead trade pieces, when behind trade pawns" rule. */

    int tradeBonus(const Position& pos, int wCorr, int bCorr) const;

    /** Score castling ability. */

    int castleBonus(const Position& pos);

    PawnHashData& getPawnHashEntry(std::vector<PawnHashData>& pawnHash, U64 key);

    int pawnBonus(const Position& pos);

    /** Compute set of pawns that can not participate in "pawn breaks". */

    static U64 computeStalePawns(const Position& pos);

    /** Compute pawn hash data for pos. */

    void computePawnHashData(const Position& pos, PawnHashData& ph);

    /** Compute rook bonus. Rook on open/half-open file. */

    int rookBonus(const Position& pos);

    /** Compute bishop evaluation. */

    int bishopEval(const Position& pos, int oldScore);

    /** Compute knight evaluation. */

    int knightEval(const Position& pos);

    /** Bonus for threatening opponent pieces. */

    int threatBonus(const Position& pos);

    /** Bonus for own pieces protected by pawns. */

    int protectBonus(const Position& pos);

    /** Compute king safety for both kings. */

    int kingSafety(const Position& pos);

    KingSafetyHashData& getKingSafetyHashEntry(vector_aligned<KingSafetyHashData>& ksHash, U64 key);

    int kingSafetyKPPart(const Position& pos);

    static int castleMaskFactor[256];

    static int knightMobScoreA[64][9];

    static U64 knightKingProtectPattern[64];

    static U64 bishopKingProtectPattern[64];

    std::vector<PawnHashData>& pawnHash;

    const PawnHashData* phd;

    std::vector<MaterialHashData>& materialHash;

    const MaterialHashData* mhd;

    vector_aligned<KingSafetyHashData>& kingSafetyHash;

     // King safety variables

    U64 wKingZone, bKingZone;       // Squares close to king that are worth attacking

    int wKingAttacks, bKingAttacks; // Number of attacks close to white/black king

    U64 wAttacksBB, bAttacksBB;

    U64 wPawnAttacks, bPawnAttacks; // Squares attacked by white/black pawns

};

inline

Evaluate::PawnHashData::PawnHashData()

    : key((U64)-1), // Non-zero to avoid collision for positions with no pawns

      current(0), score(0),

      passedBonusW(0),

      passedBonusB(0),

      passedPawns(0) {

}

inline

Evaluate::MaterialHashData::MaterialHashData()

    : id(-1), score(0) {

}

inline

Evaluate::KingSafetyHashData::KingSafetyHashData()

    : key((U64)-1), score(0), current(0) {

}

inline

Evaluate::EvalHashTables::EvalHashTables() {

    pawnHash.resize(1<<16);

    kingSafetyHash.resize(1 << 15);

    materialHash.resize(1 << 14);

}

inline int

Evaluate::interpolate(int x, int x1, int y1, int x2, int y2) {

    if (x > x2) {

        return y2;

    } else if (x < x1) {

        return y1;

    } else {

        return (x - x1) * (y2 - y1) / (x2 - x1) + y1;

    }

}

inline int

Evaluate::interpolate(int v1, int v2, int k) {

    return v1 + (v2 - v1) * k / IPOLMAX;

}

inline int

Evaluate::materialScore(const Position& pos, bool print) {

    int mId = pos.materialId();

    int key = (mId >> 16) * 40507 + mId;

    MaterialHashData& newMhd = materialHash[key & (materialHash.size() - 1)];

    if ((newMhd.id != mId) || print)

        computeMaterialScore(pos, newMhd, print);

    mhd = &newMhd;

    return newMhd.score;

}

inline Evaluate::PawnHashData&

Evaluate::getPawnHashEntry(std::vector<Evaluate::PawnHashData>& pawnHash, U64 key) {

    int e0 = (int)key & (pawnHash.size() - 2);

    int e1 = e0 + 1;

    if (pawnHash[e0].key == key) {

        pawnHash[e0].current = 1;

        pawnHash[e1].current = 0;

        return pawnHash[e0];

    }

    if (pawnHash[e1].key == key) {

        pawnHash[e1].current = 1;

        pawnHash[e0].current = 0;

        return pawnHash[e1];

    }

    if (pawnHash[e0].current) {

        pawnHash[e1].current = 1;

        pawnHash[e0].current = 0;

        return pawnHash[e1];

    } else {

        pawnHash[e0].current = 1;

        pawnHash[e1].current = 0;

        return pawnHash[e0];

    }

}

inline Evaluate::KingSafetyHashData&

Evaluate::getKingSafetyHashEntry(vector_aligned<Evaluate::KingSafetyHashData>& ksHash, U64 key) {

    int e0 = (int)key & (ksHash.size() - 2);

    int e1 = e0 + 1;

    if (ksHash[e0].key == key) {

        ksHash[e0].current = 1;

        ksHash[e1].current = 0;

        return ksHash[e0];

    }

    if (ksHash[e1].key == key) {

        ksHash[e1].current = 1;

        ksHash[e0].current = 0;

        return ksHash[e1];

    }

    if (ksHash[e0].current) {

        ksHash[e1].current = 1;

        ksHash[e0].current = 0;

        return ksHash[e1];

    } else {

        ksHash[e0].current = 1;

        ksHash[e1].current = 0;

        return ksHash[e0];

    }

}

#endif /* EVALUATE_HPP_ */