old_board.h

Go to the documentation of this file.

#pragma once 

#include "board.h"

#define OB_EMPTY_SQUARE 0x0U
#define OB_EMPTY 0x0U
#define OB_OFF_BOARD_SQUARE 0x9FU
//#define OFF_BOARD 0x18U
#define OB_GOLD 0x10U
#define OB_SILVER 0x8U
#define OB_PIECE_OFF_BOARD 0x7U
#define OB_PIECE_ELEPHANT 0x6U
#define OB_PIECE_CAMEL 0x5U
#define OB_PIECE_HORSE 0x4U
#define OB_PIECE_DOG 0x3U
#define OB_PIECE_CAT 0x2U
#define OB_PIECE_RABBIT 0x1U
#define OB_PIECE_EMPTY 0x0U
#define OB_PIECE_MASK 0x7U
#define OB_OWNER_MASK 0x18U
#define OB_NORTH 10
#define OB_SOUTH -10
#define OB_EAST 1
#define OB_WEST -1

#define TOP_ROW 8
#define BOTTOM_ROW 1
#define LEFT_COL 1 
#define RIGHT_COL 8

#define OB_OWNER(square) (square & OB_OWNER_MASK) 
#define OB_PIECE(square) (square & OB_PIECE_MASK) 
#define OB_OPP(player) ((16 - player) + 8)
//#define OB_OPP(player) (player == OB_GOLD ? OB_SILVER : OB_GOLD )


//OB_GOLD ~ 0, OB_SILVER ~ 1
#define PLAYER_TO_INDEX(player) (player == OB_GOLD ? 0 : 1 )
#define INDEX_TO_PLAYER(index)  (uint) (16-8*index)     

#define OB_SQUARE_DISTANCE(s1, s2) (abs(s1/10 - s2/10) + abs(s1%10 - s2%10))

#define OB_IS_TRAP(index) (index == 33 || index == 36 || index == 63 || index == 66 ) 
#define OB_IS_PLAYER(square) (OB_OWNER(square) == OB_GOLD || OB_OWNER(square) == OB_SILVER )

#define OB_PIECE_NUM     7
#define OB_SQUARE_NUM    100

extern const int direction[4];
extern const int rabbitForward[2];
extern const int rabbitWinRow[2];
extern const int trap[4];

typedef uint ob_player_t;
typedef int  ob_square_t;
typedef uint ob_piece_t;                
typedef int FlagBoard[OB_SQUARE_NUM];
typedef uint board_t[OB_SQUARE_NUM];

typedef pair<ob_player_t, ob_piece_t> PiecePair;

#define FLAG_BOARD_EMPTY -1

class PieceArray
{ 
  public: 
    PieceArray();

    void add(coord_t);

    void del(coord_t);

    void clear();

    uint getLen() const;
    coord_t operator[](uint) const;

    string toString() const;
    
    coord_t getRandom() const;

  private:
    coord_t elems[MAX_PIECES];      
    uint len;
};

class OB_Board
{
  public:
    OB_Board();

    void initNewGame();

    bool  initFromRecord(const char* fn); 

    bool  initFromPosition(const char* fn); 

    bool  initFromPositionCompactString(const string& s); 

                Step findMCstep();

    void findMCmoveAndMake(); 
    
                bool operator== (const OB_Board& board) const;
    
    //TODO from here till private: restructuralize in .cpp
    
                bool makeStepTryCommitMove(const Step&);

                void makeMove(const string& move);

                void makeMoveNoCommit(const Move& move);

                void makeMove(const Move& move);

                void commitMove();

    void updateWinner();



    bool quickGoalCheck(ob_player_t player, int stepLimit, Move* move=NULL) const;

     bool quickGoalCheck(Move* move=NULL) const;

     Move tracebackFlagBoard(const FlagBoard& flagBoard, int win_square, ob_player_t player) const;

    int filterRepetitions(StepArray&, int ) const;

    bool  isSetupPhase() const;

    ob_player_t  getPlayerToMove() const;

    ob_player_t  getPlayerToMoveAfterStep(const Step& step) const;

                string toString() const;

    string MovetoStringWithKills(const Move& m) const;

    bool checkKillForward(ob_square_t from, ob_square_t to, KillInfo* killInfo=NULL) const;

    u64 calcAfterStepSignature(const Step& step) const;

                int generateAllStepsNoPass(ob_player_t, StepArray&) const;

                int generateAllSteps(ob_player_t, StepArray&) const;

    void generateStepsForPiece(
              ob_square_t square, StepArray& steps, uint& stepsNum) const;

    void getHeuristics(const StepArray& steps, uint stepsNum, HeurArray& heurs) const;

    u64       getSignature() const;
    ob_player_t getWinner() const;

    ob_player_t gameOver() const; 

    bool canContinue(const Move& move) const;

    bool canPass() const;

    Step lastStep() const;

  private:
    void  init(bool newGame=false);

    bool  initFromPositionStream(istream& ss); 

    void afterPositionLoad();

    ob_player_t sideCharToPlayer(char side) const; 

    recordAction_e  parseRecordActionToken(const string& token, ob_player_t& player, 
                                           ob_piece_t& piece, ob_square_t& from, ob_square_t& to); 

    PiecePair parsePieceChar(char pieceChar); 

    void  initZobrist() const;

    void  makeSignature();

                void makeStep(const Step& step);

                bool findRandomStep(Step&) const;

    //TODO move evaluation methods to eval ???
    
    Step chooseStepWithKnowledge(StepArray& steps, uint stepsNum) const;

    float evaluateStep(const Step& step) const;

    bool checkKill(ob_square_t square);

    void performKill(ob_square_t trapPos);

    bool stepIsVirtualPass( Step& ) const;

    bool stepIsThirdRepetition(const Step& ) const;

                bool hasFriend(ob_square_t) const;

                inline bool hasFriend(ob_square_t, ob_player_t owner) const;

                bool hasTwoFriends(ob_square_t, ob_player_t) const;

                bool hasStrongerEnemy(ob_square_t) const;

                inline bool hasStrongerEnemy(ob_square_t, ob_player_t owner, ob_piece_t piece) const;

                bool isFrozen(ob_square_t) const;

                uint                    getStepCount() const;
    u64       getPreMoveSignature() const;
                
    void setSquare(ob_square_t, ob_player_t, ob_piece_t);

    void clearSquare(ob_square_t);

                string allStepsToString() const;
                void dumpAllSteps() const;
    void dump() const;

    //Attributes

    static bool       classInit;
    static ThirdRep*  thirdRep_;

                board_t                                 board_;                                 //actual pieces are stored here 
                bool                                    frozenBoard_[OB_SQUARE_NUM];                    //keep information on frozen pieces, false == notfrozen, true == frozen

    PieceArray    pieceArray[2];  
    uint          rabbitsNum[2];        //kept number of rabbits for each player - for quick check on rabbitsNum != 0 
  
    StepArray     stepArray;
    uint          stepArrayLen;

    u64           signature_;            //position signature - for hash tables, corectness checks, etc. 
    u64           preMoveSignature_;     //signature of position from when the current move started

    Step lastStep_;
                // move consists of up to 4 steps ( push/pull  counting for 2 ),
    uint  moveCount_;

                // step is either pass or single piece step or push/pull step,
                // thus stepCount_ takes values 0 - 4 
    uint  stepCount_;

    ob_player_t toMove_;
    uint     toMoveIndex_;    //0 == OB_GOLD, 1 == OB_SILVER
                ob_player_t winner_;

    friend class Eval;

};


class OB_SimplePlayout
{
        public:
                OB_SimplePlayout(OB_Board*, uint maxPlayoutLength, uint evalAfterLength);

                void doPlayout();       

                uint getPlayoutLength();  

  protected:
    void playOne();     

    bool hasWinner();

    OB_SimplePlayout();

    OB_Board*           board_;
    uint        playoutLength_;
    uint        maxPlayoutLength_;
    uint        evalAfterLength_;

};

---