eval.h

Go to the documentation of this file.

#pragma once

#include "board.h"

#define RING0  0x0000001818000000ULL   /* same as small center */
#define RING1  0x00003c24243c0000ULL   
#define RING2  0x007e424242427e00ULL
#define RING3  0xff818181818181ffULL   

//TODO change ! 
#define TRAP_TO_INDEX(trap) (trap < 32 ? (trap == 18 ? 0 : 1) : trap ==  42 ? 2 : 3)

//game stages num
#define GS_NUM 3 

enum gameStage_e {GS_BEGIN, GS_MIDDLE, GS_LATE};

extern u64 adv[8][2];

enum trapType_e { TT_UNSAFE, TT_HALF_SAFE, TT_SAFE, TT_ACTIVE};

class Eval;
class Values;

class ValueItem { 
  public: 
    ValueItem() {};
    ValueItem(string name, itemType_e type, void* item, int num);

    bool isSingleValue() const;

  private:
    string name_;
    itemType_e type_;
    void* item_;
    int num_;
    friend class Values;
};

typedef list <ValueItem> ValueList;

class Values 
{
  public:

    virtual ~Values(){};

    virtual void init() = 0;

    //virtual ~Values(); 

    string toString() const;
    
  protected: 
    ValueList values;

    bool loadFromString(string);

};


class EvaluationValues:public Values
{
  public: 
    EvaluationValues(string config);

    EvaluationValues();

    void init();

  private:
    friend class Eval;

    void mirrorPiecePositions();

    static void baseMirrorIndexes(int & player, int & coord);

    int pieceValue[PIECE_NUM + 1];

    int rabbitPenalty[RABBITS_NUM + 1]; 

    float frozenPenaltyRatio;

    int trapSoleVal;  
    int trapMoreThanOneVal;
    int trapSafeVal;  
    int trapActiveVal;
    int trapPotVal;

    int activeTrapBlockedPenalty;
    float framePenaltyRatio;  
    int camelHostagePenalty;
    int elephantBlockadePenalty;

    float pinnedPenaltyRatio;  

    int piecePos[GS_NUM][2][PIECE_NUM + 1][BIT_LEN];
};

class StepKnowledgeValues: public Values{
  public:
    StepKnowledgeValues(string config);

    StepKnowledgeValues();

    void init();

  private:
    float passPenalty;
    float inverseStepPenalty;
    float elephantStepVal;
    float camelStepVal;
    float horseStepVal;
    float pushPullVal;
    float leaveBuddyInTrapPenalty;
    float suicidePenalty;
    float stepInDangerousTrapPenalty;
    float pushPullToTrapVal;
    float killVal;
    float rabbitStepBeginVal;
    float rabbitStepMiddleVal;
    float rabbitStepLateVal;
    float localityVal;
    int localityReach;
    
    friend class Eval;
};

class Eval
{
        public:
    Eval();

    Eval(const Board* board);
    
    void init();

    int evaluate(const Board*) const;

    int evaluateDailey(const Board*) const;

    float evaluateInPercent(const Board*) const;

    float getPieceValue(piece_t piece) const;

    float evaluateStep(const Board*, const Step& step) const;

  private: 

    gameStage_e determineGameStage(const Bitboard& bitboard) const;
    
    bool blocked(player_t player, piece_t piece, coord_t coord, const Board* b) const;
    
    static string trapTypeToStr(trapType_e trapType);

    EvalTT * evalTT_;

    EvaluationValues * vals_;
    StepKnowledgeValues * skvals_;

    double eval_max_;

};

---