Permalink
Join GitHub today
GitHub is home to over 28 million developers working together to host and review code, manage projects, and build software together.
Sign up
Fetching contributors…
Cannot retrieve contributors at this time.
Cannot retrieve contributors at this time
| /* GNU Chess 5.0 - common.h - common symbolic definitions | |
| Copyright (c) 1999-2002 Free Software Foundation, Inc. | |
| GNU Chess is based on the two research programs | |
| Cobalt by Chua Kong-Sian and Gazebo by Stuart Cracraft. | |
| GNU Chess 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, or (at your option) | |
| any later version. | |
| GNU Chess 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 GNU Chess; see the file COPYING. If not, write to | |
| the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| Boston, MA 02111-1307, USA. | |
| Contact Info: | |
| bug-gnu-chess@gnu.org | |
| cracraft@ai.mit.edu, cracraft@stanfordalumni.org, cracraft@earthlink.net | |
| */ | |
| #ifndef COMMON_H | |
| #define COMMON_H | |
| #include <config.h> | |
| #ifndef __GNUC__ | |
| # define __attribute__(x) | |
| #endif | |
| /* | |
| * Include "uint64_t" and similar types using the ac_need_stdint_h ac macro | |
| */ | |
| #include "GCint.h" | |
| #include <stdio.h> | |
| #include <sys/types.h> | |
| /* | |
| * Define time structures to get timeval for Timer | |
| */ | |
| #include <sys/time.h> | |
| /* | |
| * Define macro for declaring 64bit constants for compilers not using ULL | |
| */ | |
| #ifdef _MSC_VER | |
| #define ULL(x) ((uint64_t)(x)) | |
| #else | |
| #define ULL(x) x ## ULL | |
| #endif | |
| /* | |
| * BitBoard is a key data type. It is a 64-bit value, in which each | |
| * bit represents a square on the board as defined by "enum Square". | |
| * Thus, bit position 0 represents a fact about square a1, and bit | |
| * position 63 represents a fact about square h8. For example, the | |
| * bitboard representing "white rook" positions will have a bit set | |
| * for every position occupied on the board by a white rook. | |
| */ | |
| typedef uint64_t BitBoard; | |
| typedef uint64_t HashType; | |
| typedef uint32_t KeyType; | |
| /* | |
| * Board represents an entire board's state, and is structured to | |
| * simplify analysis: | |
| */ | |
| typedef struct | |
| { | |
| BitBoard b[2][7]; /* piece/pawn positions by side (0=white, 1=black) | |
| and then by piece (1=pawn..6=king). For example, | |
| b[white][knight] has bits set for every board | |
| position occupied by a White Knight. */ | |
| BitBoard friends[2]; /* Friendly (this side's) pieces */ | |
| BitBoard blocker; | |
| BitBoard blockerr90; /* rotated 90 degrees */ | |
| BitBoard blockerr45; /* rotated 45 degrees */ | |
| BitBoard blockerr315; /* rotated 315 degrees */ | |
| short ep; /* Location of en passant square */ | |
| short flag; /* Flags related to castle privileges */ | |
| short side; /* Color of side on move: 0=white, 1=black */ | |
| short material[2]; /* Total material by side not inc. king */ | |
| short pmaterial[2]; /* Total pawn material by side not inc. king */ | |
| short castled[2]; /* True (1) if side is castled */ | |
| short king[2]; /* Location of king 0 - a1 .. 63 - h8 */ | |
| } Board; | |
| /* leaf describes a leaf-level analysis result */ | |
| typedef struct | |
| { | |
| int move; /* the move that produced this particular board */ | |
| int score; /* the scored value of this leaf */ | |
| } leaf; | |
| /* | |
| * GameRec records an individual move made in the game; an entire | |
| * Game is a set of GameRec's: | |
| */ | |
| #define SANSZ 8 /* longest move is "exf8=Q+" so 7+1 */ | |
| typedef struct | |
| { | |
| int move; /* The actual move made; this is NOT the move count! */ | |
| short epsq; /* en passant square */ | |
| short bflag; /* Flags for castle privs, see Board.flag */ | |
| short Game50; /* The last value of GameCnt (a count of half-moves) | |
| that castled, captured, or moved a pawn */ | |
| short mvboard; | |
| float et; /* elapsed time */ | |
| HashType hashkey; | |
| HashType phashkey; | |
| char SANmv[SANSZ]; /* The move in SAN notation */ | |
| char *comments; | |
| } GameRec; | |
| typedef struct | |
| { | |
| HashType key; /* Full 64 bit hash */ | |
| int move; /* Best move */ | |
| int score; /* Estimated score, may be lower or upper bound */ | |
| uint8_t flag; /* Is this alpha, beta, quiescent or exact? */ | |
| uint8_t depth; /* Search depth */ | |
| } HashSlot; | |
| typedef struct | |
| { | |
| KeyType pkey; | |
| BitBoard passed; | |
| BitBoard weaked; | |
| int score; | |
| int phase; | |
| } PawnSlot; | |
| /* MACRO definitions */ | |
| #ifndef MAX | |
| #define MAX(a,b) ((a) > (b) ? (a) : (b)) | |
| #endif | |
| #ifndef MIN | |
| #define MIN(a,b) ((a) < (b) ? (a) : (b)) | |
| #endif | |
| #define SET(a,b) \ | |
| do { \ | |
| (a) |= (b); \ | |
| } while (0) | |
| #define CLEAR(a,b) \ | |
| do { \ | |
| (a) &= ~(b); \ | |
| } while (0) | |
| /* Draw score can be used to penalise draws if desired */ | |
| #define DRAWSCORE 0 | |
| #define MATERIAL (board.material[side] - board.material[1^side]) | |
| #define PHASE (8 - (board.material[white]+board.material[black]) / 1150) | |
| #define KEY(a) (a >> 32) | |
| /* Attack MACROS */ | |
| #define BishopAttack(sq) \ | |
| (Bishop45Atak[sq][(board.blockerr45 >> Shift45[sq]) & Mask45[sq]] | \ | |
| Bishop315Atak[sq][(board.blockerr315 >> Shift315[sq]) & Mask315[sq]]) | |
| #define RookAttack(sq) \ | |
| (Rook00Atak[sq][(board.blocker >> Shift00[sq]) & 0xFF] | \ | |
| Rook90Atak[sq][(board.blockerr90 >> Shift90[sq]) & 0xFF]) | |
| #define QueenAttack(sq) \ | |
| (BishopAttack(sq) | RookAttack(sq)) | |
| /* Some bit macros */ | |
| /* | |
| * gcc 2.95.4 completely screws up the macros with lookup tables | |
| * with -O2 on PPC, maybe this check has to be refined. (I don't know | |
| * whether other architectures also suffer from this gcc bug.) However, | |
| * with gcc 3.0, the lookup tables are _much_ faster than this direct | |
| * calculation. | |
| */ | |
| #if defined(__GNUC__) && defined(__PPC__) && __GNUC__ < 3 | |
| # define SETBIT(b,i) ((b) |= ((ULL(1)<<63)>>(i))) | |
| # define CLEARBIT(b,i) ((b) &= ~((ULL(1)<<63)>>(i))) | |
| #else | |
| # define SETBIT(b,i) ((b) |= BitPosArray[i]) | |
| # define CLEARBIT(b,i) ((b) &= NotBitPosArray[i]) | |
| #endif | |
| #define RANK(i) ((i) >> 3) | |
| #define ROW(i) ((i) & 7) | |
| #define trailz(b) (leadz ((b) & ((~b) + 1))) | |
| /* Move Descriptions (moves) are represented internally as integers. | |
| * The lowest 6 bits define the destination ("TO") square, and | |
| * the next lowest 6 bits define the source ("FROM") square, | |
| * using the values defined by "enum Square" (0=a1, 63=h8). | |
| * Upper bits are used to identify other move information such as | |
| * a promotion (and to what), a capture (and of what), | |
| * CASTLING moves, and ENPASSANT moves; see the "constants for | |
| * move description" below for more information on these upper bits. | |
| */ | |
| #define PROMOTEPIECE(a) ((a >> 12) & 0x0007) | |
| #define CAPTUREPIECE(a) ((a >> 15) & 0x0007) | |
| #define TOSQ(a) ((a) & 0x003F) | |
| #define FROMSQ(a) ((a >> 6) & 0x003F) | |
| #define MOVE(a,b) (((a) << 6) | (b)) | |
| /* constants for move description */ | |
| #define KNIGHTPRM 0x00002000 | |
| #define BISHOPPRM 0x00003000 | |
| #define ROOKPRM 0x00004000 | |
| #define QUEENPRM 0x00005000 | |
| #define PROMOTION 0x00007000 | |
| #define PAWNCAP 0x00008000 | |
| #define KNIGHTCAP 0x00010000 | |
| #define BISHOPCAP 0x00018000 | |
| #define ROOKCAP 0x00020000 | |
| #define QUEENCAP 0x00028000 | |
| #define CAPTURE 0x00038000 | |
| #define NULLMOVE 0x00100000 | |
| #define CASTLING 0x00200000 | |
| #define ENPASSANT 0x00400000 | |
| #define MOVEMASK (CASTLING | ENPASSANT | PROMOTION | 0x0FFF) | |
| #define white 0 | |
| #define black 1 | |
| #define false 0 | |
| #define true 1 | |
| #define ks 0 | |
| #define qs 1 | |
| #define INFINITY 32767 | |
| #define MATE 32767 | |
| #define MATESCORE(a) ((a) > MATE-255 || (a) < -MATE+255) | |
| /* constants for Board */ | |
| #define WKINGCASTLE 0x0001 | |
| #define WQUEENCASTLE 0x0002 | |
| #define BKINGCASTLE 0x0004 | |
| #define BQUEENCASTLE 0x0008 | |
| #define WCASTLE (WKINGCASTLE | WQUEENCASTLE) | |
| #define BCASTLE (BKINGCASTLE | BQUEENCASTLE) | |
| /* Material values */ | |
| #define ValueP 100 | |
| #define ValueN 350 | |
| #define ValueB 350 | |
| #define ValueR 550 | |
| #define ValueQ 1100 | |
| #define ValueK 2000 | |
| /* Some special BitBoards */ | |
| #define NULLBITBOARD ( ULL(0x0000000000000000)) | |
| #define WHITESQUARES ( ULL(0x55AA55AA55AA55AA)) | |
| #define BLACKSQUARES ( ULL(0xAA55AA55AA55AA55)) | |
| #define CENTRESQUARES ( ULL(0x0000001818000000)) | |
| #define COMPUTERHALF ( ULL(0xFFFFFFFF00000000)) | |
| #define OPPONENTHALF ( ULL(0x00000000FFFFFFFF)) | |
| /* Game flags */ | |
| #define QUIT 0x0001 | |
| #define TESTT 0x0002 | |
| #define THINK 0x0004 | |
| #define MANUAL 0x0008 | |
| #define TIMEOUT 0x0010 | |
| #define SPARE1 0x0020 | |
| #define ENDED 0x0040 | |
| #define USEHASH 0x0080 | |
| #define SOLVE 0x0100 | |
| #define USENULL 0x0200 | |
| #define XBOARD 0x0400 | |
| #define TIMECTL 0x0800 | |
| #define POST 0x1000 | |
| #define PONDER 0x2000 /* We are in pondering (during search) */ | |
| #define HARD 0x4000 /* Pondering is turned on */ | |
| #define ANALYZE 0x8000 /* In ANALYZE mode */ | |
| /* Node types */ | |
| #define PV 0 | |
| #define ALL 1 | |
| #define CUT 2 | |
| /* Transposition table flags */ | |
| #define EXACTSCORE 1 | |
| #define LOWERBOUND 2 | |
| #define UPPERBOUND 3 | |
| #define POORDRAFT 4 | |
| #define QUIESCENT 5 | |
| #define STICKY 8 | |
| /* Book modes */ | |
| #define BOOKOFF 0 | |
| #define BOOKRAND 1 | |
| #define BOOKBEST 2 | |
| #define BOOKWORST 3 | |
| #define BOOKPREFER 4 | |
| /* The various phases during move selection */ | |
| #define PICKHASH 1 | |
| #define PICKGEN1 2 | |
| #define PICKCAPT 3 | |
| #define PICKKILL1 4 | |
| #define PICKKILL2 5 | |
| #define PICKGEN2 6 | |
| #define PICKHIST 7 | |
| #define PICKREST 8 | |
| #define PICKCOUNTER 9 | |
| #define MAXTREEDEPTH 2000 | |
| #define MAXPLYDEPTH 65 | |
| #define MAXGAMEDEPTH 600 | |
| /* | |
| Smaller HASHSLOT defaults 20011017 to improve blitz play | |
| and make it easier to run on old machines | |
| */ | |
| #define HASHSLOTS 1024 | |
| #define PAWNSLOTS 512 | |
| extern short distance[64][64]; | |
| extern short taxicab[64][64]; | |
| extern unsigned char lzArray[65536]; | |
| extern short Shift00[64]; | |
| extern short Shift90[64]; | |
| extern short Shift45[64]; | |
| extern short Shift315[64]; | |
| extern BitBoard DistMap[64][8]; | |
| extern BitBoard BitPosArray[64]; | |
| extern BitBoard NotBitPosArray[64]; | |
| extern BitBoard MoveArray[8][64]; | |
| extern BitBoard Ray[64][8]; | |
| extern BitBoard FromToRay[64][64]; | |
| extern BitBoard RankBit[8]; | |
| extern BitBoard FileBit[8]; | |
| extern BitBoard Ataks[2][7]; | |
| extern BitBoard PassedPawnMask[2][64]; | |
| extern BitBoard IsolaniMask[8]; | |
| extern BitBoard SquarePawnMask[2][64]; | |
| extern BitBoard Rook00Atak[64][256]; | |
| extern BitBoard Rook90Atak[64][256]; | |
| extern BitBoard Bishop45Atak[64][256]; | |
| extern BitBoard Bishop315Atak[64][256]; | |
| extern BitBoard pinned; | |
| extern BitBoard rings[4]; | |
| extern BitBoard boxes[2]; | |
| extern BitBoard stonewall[2]; | |
| extern BitBoard pieces[2]; | |
| extern BitBoard mask_kr_trapped_w[3]; | |
| extern BitBoard mask_kr_trapped_b[3]; | |
| extern BitBoard mask_qr_trapped_w[3]; | |
| extern BitBoard mask_qr_trapped_b[3]; | |
| extern BitBoard boardhalf[2]; | |
| extern BitBoard boardside[2]; | |
| extern short directions[64][64]; | |
| extern unsigned char BitCount[65536]; | |
| extern leaf Tree[MAXTREEDEPTH]; | |
| extern leaf *TreePtr[MAXPLYDEPTH]; | |
| extern int RootPV; | |
| extern GameRec Game[MAXGAMEDEPTH]; | |
| extern int RealGameCnt; | |
| extern short RealSide; | |
| extern int GameCnt; | |
| extern int computer; | |
| extern volatile unsigned int flags; | |
| extern unsigned int preanalyze_flags; | |
| extern Board board; | |
| extern int cboard[64]; | |
| extern int Mvboard[64]; | |
| extern HashType hashcode[2][7][64]; | |
| extern HashType ephash[64]; | |
| extern HashType WKCastlehash; | |
| extern HashType WQCastlehash; | |
| extern HashType BKCastlehash; | |
| extern HashType BQCastlehash; | |
| extern HashType Sidehash; | |
| extern HashType HashKey; | |
| extern HashType PawnHashKey; | |
| extern HashSlot *HashTab[2]; | |
| extern PawnSlot *PawnTab[2]; | |
| extern int Idepth; | |
| extern int SxDec; | |
| extern int Game50; | |
| extern int lazyscore[2]; | |
| extern int maxposnscore[2]; | |
| extern int rootscore; | |
| extern int lastrootscore; | |
| extern unsigned long GenCnt; | |
| extern unsigned long NodeCnt; | |
| extern unsigned long QuiesCnt; | |
| extern unsigned long EvalCnt; | |
| extern unsigned long EvalCall; | |
| extern unsigned long ChkExtCnt; | |
| extern unsigned long OneRepCnt; | |
| extern unsigned long RcpExtCnt; | |
| extern unsigned long PawnExtCnt; | |
| extern unsigned long HorzExtCnt; | |
| extern unsigned long ThrtExtCnt; | |
| extern unsigned long KingExtCnt; | |
| extern unsigned long NullCutCnt; | |
| extern unsigned long FutlCutCnt; | |
| extern unsigned long RazrCutCnt; | |
| extern unsigned long TotalGetHashCnt; | |
| extern unsigned long GoodGetHashCnt; | |
| extern unsigned long TotalPutHashCnt; | |
| extern unsigned long CollHashCnt; | |
| extern unsigned long TotalPawnHashCnt; | |
| extern unsigned long GoodPawnHashCnt; | |
| extern unsigned long RepeatCnt; | |
| extern unsigned HashSize; | |
| extern unsigned long TTHashMask; | |
| extern unsigned long PHashMask; | |
| extern int slider[8]; | |
| extern int Value[7]; | |
| extern char SANmv[SANSZ]; | |
| extern unsigned long history[2][4096]; | |
| extern int killer1[MAXPLYDEPTH]; | |
| extern int killer2[MAXPLYDEPTH]; | |
| extern int ChkCnt[MAXPLYDEPTH]; | |
| extern int ThrtCnt[MAXPLYDEPTH]; | |
| extern char id[32]; | |
| extern char solution[64]; | |
| extern float SearchTime; | |
| extern int SearchDepth; | |
| extern int MoveLimit[2]; | |
| extern float TimeLimit[2]; | |
| extern int TCMove; | |
| extern int TCinc; | |
| extern float TCTime; | |
| extern int hunged[2]; | |
| extern int phase; | |
| extern int Hashmv[MAXPLYDEPTH]; | |
| extern short RootPieces; | |
| extern short RootPawns; | |
| extern short RootMaterial; | |
| extern short RootAlpha; | |
| extern short RootBeta; | |
| extern short pickphase[MAXPLYDEPTH]; | |
| extern short InChk[MAXPLYDEPTH]; | |
| extern short KingThrt[2][MAXPLYDEPTH]; | |
| extern short KingSafety[2]; | |
| extern short pscore[64]; | |
| extern short bookmode; | |
| extern short bookfirstlast; | |
| extern int range[8]; | |
| extern int ptype[2]; | |
| extern char algbr[64][3]; | |
| extern char algbrfile[9]; | |
| extern char algbrrank[9]; | |
| extern char notation[8]; | |
| extern char lnotation[8]; | |
| extern int r90[64]; | |
| extern int r45[64]; | |
| extern int r315[64]; | |
| extern int Mask45[64]; | |
| extern int Mask315[64]; | |
| extern int rank6[2]; | |
| extern int rank7[2]; | |
| extern int rank8[2]; | |
| extern char *progname; | |
| extern FILE *ofp; | |
| extern int myrating, opprating, suddendeath; | |
| #define MAXNAMESZ 50 | |
| extern char name[MAXNAMESZ]; | |
| extern int computerplays; | |
| extern int wasbookmove; | |
| extern int nmovesfrombook; | |
| extern float maxtime; | |
| extern int n; /* Last mobility returned by CTL */ | |
| extern int ExchCnt[2]; | |
| extern int newpos, existpos; /* For book statistics */ | |
| extern int bookloaded; | |
| enum Piece { empty, pawn, knight, bishop, rook, queen, king, bpawn }; | |
| enum Square { A1, B1, C1, D1, E1, F1, G1, H1, | |
| A2, B2, C2, D2, E2, F2, G2, H2, | |
| A3, B3, C3, D3, E3, F3, G3, H3, | |
| A4, B4, C4, D4, E4, F4, G4, H4, | |
| A5, B5, C5, D5, E5, F5, G5, H5, | |
| A6, B6, C6, D6, E6, F6, G6, H6, | |
| A7, B7, C7, D7, E7, F7, G7, H7, | |
| A8, B8, C8, D8, E8, F8, G8, H8 }; | |
| enum File { A_FILE, B_FILE, C_FILE, D_FILE, E_FILE, F_FILE, G_FILE, H_FILE }; | |
| /**************************************************************************** | |
| * | |
| * The various function prototypes. They are group into the *.c files | |
| * in which they are defined. | |
| * | |
| ****************************************************************************/ | |
| /* | |
| * Explanation of the #ifdef NO_INLINE conditionals: | |
| * | |
| * Define NO_INLINE only if you really must, implementations will be | |
| * provided by the corresponding *.c files. The better solution is to | |
| * not define it, in which case inlines.h will be included which | |
| * provides static inline version of these functions. | |
| */ | |
| /* The initialization routines */ | |
| void Initialize (void); | |
| void InitLzArray (void); | |
| void InitBitPosArray (void); | |
| void InitMoveArray (void); | |
| void InitRay (void); | |
| void InitFromToRay (void); | |
| void InitRankFileBit (void); | |
| void InitBitCount (void); | |
| void InitPassedPawnMask (void); | |
| void InitIsolaniMask (void); | |
| void InitSquarePawnMask (void); | |
| void InitRandomMasks (void); | |
| void InitRotAtak (void); | |
| void InitDistance (void); | |
| void InitVars (void); | |
| void InitHashCode (void); | |
| void InitHashTable (void); | |
| void CalcHashSize (int); | |
| void NewPosition (void); | |
| void InitFICS (void); | |
| void InitInput (void); | |
| /* Cleanup routines */ | |
| void CleanupInput(void); | |
| /* The book routines */ | |
| int BookQuery (int); | |
| int BookBuilderOpen(void); | |
| int BookBuilder (short result, uint8_t side); | |
| int BookBuilderClose(void); | |
| /* | |
| * Return values (errorcodes) for the book routines, | |
| * maybe one should have a global enum of errorcodes | |
| */ | |
| enum { | |
| BOOK_SUCCESS, | |
| BOOK_EFORMAT, /* Wrong format (e.g. produced by older version) */ | |
| BOOK_EMIDGAME, /* Move is past the opening book's move limit */ | |
| BOOK_EIO, /* I/O error, e.g. caused by wrong permissions */ | |
| BOOK_EFULL, /* Book hash is full, new position was not added. */ | |
| BOOK_ENOBOOK, /* No book present */ | |
| BOOK_ENOMOVES, /* No moves found (in BookQuery() only) */ | |
| BOOK_ENOMEM /* Memory allocation failed */ | |
| }; | |
| /* The move generation routines */ | |
| void GenMoves (short); | |
| void GenCaptures (short); | |
| void GenNonCaptures (short); | |
| void GenCheckEscapes (short); | |
| void FilterIllegalMoves (short); | |
| /* The move routines */ | |
| void MakeMove (int, int *); | |
| void UnmakeMove (int, int *); | |
| void MakeNullMove (int); | |
| void UnmakeNullMove (int); | |
| void SANMove (int, int); | |
| leaf *ValidateMove (char *); | |
| leaf *IsInMoveList (int, int, int, char); | |
| int IsLegalMove (int); | |
| char *AlgbrMove (int); | |
| /* The attack routines */ | |
| short SqAtakd (short sq, short side); | |
| void GenAtaks (void); | |
| BitBoard AttackTo (int, int); | |
| BitBoard AttackXTo (int, int); | |
| BitBoard AttackFrom (int, int, int); | |
| BitBoard AttackXFrom (int, int); | |
| int PinnedOnKing (int, int); | |
| void FindPins (BitBoard *); | |
| int MateScan (int); | |
| /* The swap routines */ | |
| int SwapOff (int); | |
| void AddXrayPiece (int, int, int, BitBoard *, BitBoard *); | |
| /* The EPD routines */ | |
| short ReadEPDFile (const char *, short); | |
| int ParseEPD (char *); | |
| void LoadEPD (char *); | |
| void SaveEPD (char *); | |
| /* Error codes for ParseEPD */ | |
| enum { | |
| EPD_SUCCESS, | |
| EPD_ERROR | |
| }; | |
| void UpdateFriends (void); | |
| void UpdateCBoard (void); | |
| void UpdateMvboard (void); | |
| void EndSearch (int); | |
| short ValidateBoard (void); | |
| /* PGN routines */ | |
| void PGNSaveToFile (const char *, const char *); | |
| void PGNReadFromFile (const char *); | |
| void BookPGNReadFromFile (const char *); | |
| int IsTrustedPlayer(const char *name); | |
| /* The hash routines */ | |
| void CalcHashKey (void); | |
| void ShowHashKey (HashType); | |
| /* The evaluation routines */ | |
| int ScoreP (short); | |
| int ScoreN (short); | |
| int ScoreB (short); | |
| int ScoreR (short); | |
| int ScoreQ (short); | |
| int ScoreK (short); | |
| int ScoreDev (short); | |
| int Evaluate (int, int); | |
| short EvaluateDraw (void); | |
| /* Hung routines */ | |
| int EvalHung (int); | |
| /* The search routines */ | |
| void Iterate (void); | |
| int Search (uint8_t ply, short depth, int alpha, int beta, short nodetype); | |
| int SearchRoot (short depth, int alpha, int beta); | |
| int Quiesce (uint8_t ply, int alpha, int beta); | |
| void pick (leaf *, short); | |
| short Repeat (void); | |
| void ShowLine (int, int, char); | |
| /* | |
| * Set up a timer by first calling StartTiming(), saving | |
| * the return value and feeding it to GetElapsed() for | |
| * timings in seconds. | |
| */ | |
| typedef struct timeval Timer; | |
| extern double ElapsedTime; | |
| extern Timer StartTime; | |
| Timer StartTiming (void); | |
| double GetElapsed (Timer start); | |
| /* The transposition table routies */ | |
| void TTPut (uint8_t side, uint8_t depth, uint8_t ply, | |
| int alpha, int beta, int score, int move); | |
| /* Returns flag if it finds an entry, 0 otherwise */ | |
| uint8_t TTGet (uint8_t side, uint8_t depth, uint8_t ply, | |
| int *score, int *move); | |
| short TTGetPV (uint8_t side, uint8_t ply, int score, int *move); | |
| void TTClear (void); | |
| void PTClear (void); | |
| /* Sorting routines */ | |
| void SortCaptures (int); | |
| void SortMoves (int); | |
| void SortRoot (void); | |
| int PhasePick (leaf **, int); | |
| int PhasePick1 (leaf **, int); | |
| /* Some output routines */ | |
| void ShowMoveList (int); | |
| void ShowSmallBoard (void); | |
| void ShowBoard (void); | |
| void ShowBitBoard (BitBoard *); | |
| void ShowCBoard (void); | |
| void ShowMvboard (void); | |
| void ShowGame (void); | |
| void ShowTime (void); | |
| /* Random numbers routines */ | |
| uint32_t Rand32 (void); | |
| HashType Rand64 (void); | |
| /* Solver routines */ | |
| void Solve (char *); | |
| /* Test routines */ | |
| void TestMoveGenSpeed (void); | |
| void TestNonCaptureGenSpeed (void); | |
| void TestCaptureGenSpeed (void); | |
| void TestMoveList (void); | |
| void TestNonCaptureList (void); | |
| void TestCaptureList (void); | |
| void TestEvalSpeed (void); | |
| void TestEval (void); | |
| /* Player database */ | |
| void DBSortPlayer (const char *style); | |
| void DBListPlayer (const char *style); | |
| void DBReadPlayer (void); | |
| void DBWritePlayer (void); | |
| int DBSearchPlayer (const char *player); | |
| void DBUpdatePlayer (const char *player, const char *resultstr); | |
| void DBTest (void); | |
| /* Input thread and thread function */ | |
| #include <pthread.h> | |
| extern pthread_t input_thread; | |
| void *input_func(void *); | |
| /* | |
| * Status variable used by the input thread to signal | |
| * pending input. Thought about using flags for this | |
| * but this can be refined and is conceptually different | |
| * from flags. | |
| */ | |
| enum { | |
| INPUT_NONE, | |
| INPUT_AVAILABLE | |
| }; | |
| extern volatile int input_status; | |
| /* | |
| * Function to wake up the input thread, should be called after | |
| * input has been parsed. | |
| */ | |
| void input_wakeup(void); | |
| /* Wait for input. */ | |
| void wait_for_input(void); | |
| /* | |
| * Input routine, initialized to one of the specific | |
| * input routines. The given argument is the prompt. | |
| */ | |
| void (*get_line) (char *); | |
| #define MAXSTR 128 | |
| extern char inputstr[MAXSTR]; | |
| /* Input parser */ | |
| void parse_input(void); | |
| /* Check Board to avoid analysis of incorrectly input positions */ | |
| void check_board(void); | |
| /* Pondering */ | |
| void ponder(void); | |
| /* The command subroutines */ | |
| void ShowCmd (char *); | |
| void BookCmd (char *); | |
| void TestCmd (char *); | |
| /* Commands from the input engine */ | |
| void cmd_accepted(void); | |
| void cmd_activate(void); | |
| void cmd_analyze(void); | |
| void cmd_bk(void); | |
| void cmd_black(void); | |
| void cmd_book(void); | |
| void cmd_computer(void); | |
| void cmd_depth(void); | |
| void cmd_draw(void); | |
| void cmd_easy(void); | |
| void cmd_edit(void); | |
| void cmd_epd(void); | |
| void cmd_exit(void); | |
| void cmd_force(void); | |
| void cmd_go(void); | |
| void cmd_hard(void); | |
| void cmd_hash(void); | |
| void cmd_hashsize(void); | |
| void cmd_help (void); | |
| void cmd_hint(void); | |
| void cmd_level(void); | |
| void cmd_list(void); | |
| void cmd_load(void); | |
| void cmd_manual(void); | |
| void cmd_movenow(void); | |
| void cmd_memory(void); | |
| void cmd_name(void); | |
| void cmd_new(void); | |
| void cmd_nopost(void); | |
| void cmd_null(void); | |
| void cmd_otim(void); | |
| void cmd_pgnload(void); | |
| void cmd_pgnsave(void); | |
| void cmd_ping(void); | |
| void cmd_post(void); | |
| void cmd_protover(void); | |
| void cmd_quit(void); | |
| void cmd_random(void); | |
| void cmd_rating(void); | |
| void cmd_rejected(void); | |
| void cmd_remove(void); | |
| void cmd_result(void); | |
| void cmd_save(void); | |
| void cmd_setboard(void); | |
| void cmd_show (void); | |
| void cmd_solve(void); | |
| void cmd_st(void); | |
| void cmd_switch(void); | |
| void cmd_test (void); | |
| void cmd_time(void); | |
| void cmd_undo(void); | |
| void cmd_usage(void); | |
| void cmd_variant(void); | |
| void cmd_version(void); | |
| void cmd_white(void); | |
| void cmd_xboard(void); | |
| /* | |
| * Define NO_INLINE only if you really must, implementations will be | |
| * provided by the corresponding *.c files. The better solution is to | |
| * not define it, in which case inlines.h will be included which | |
| * provides static inline version of these functions. | |
| */ | |
| /* Some utility routines */ | |
| #ifdef NO_INLINE | |
| unsigned char leadz (BitBoard); | |
| unsigned char nbits (BitBoard); | |
| #else | |
| # include "inlines.h" | |
| #endif | |
| #endif /* !COMMON_H */ |