CPW-Engine stdafx h

Home * Engines * CPW-Engine * stdafx.h

#pragma once

#include <iostream>
#include <xmmintrin.h>

#define INF 10000
#define INVALID 32767


#define U64 unsigned __int64
#define U32 unsigned __int32
#define U16 unsigned __int16
#define U8  unsigned __int8
#define S64 signed   __int64
#define S32 signed   __int32
#define S16 signed   __int16
#define S8  signed   __int8



/* Move ordering compiler switches and constants */

#define USE_HASHMOVE
#define USE_HISTORY
#define USE_KILLERS

#define SORT_KING 400000000   
#define SORT_HASH 200000000
#define SORT_CAPT 100000000
#define SORT_PROM  90000000
#define SORT_KILL  80000000

#define STARTFEN "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"

#define VERSION_STRING "1.1"
#define COMPILE_STRING " compiled 30.12.2014"

#define BOOK_NONE 0
#define BOOK_NARROW 1
#define BOOK_BROAD 2

enum epiece {
  KING,
  QUEEN,
  ROOK,
  BISHOP,
  KNIGHT,
  PAWN,
  PIECE_EMPTY
};

enum ecolor {
  WHITE,
  BLACK,
  COLOR_EMPTY
};

enum esqare {
  A1 = 0, B1, C1, D1, E1, F1, G1, H1,
  A2 = 16, B2, C2, D2, E2, F2, G2, H2,
  A3 = 32, B3, C3, D3, E3, F3, G3, H3,
  A4 = 48, B4, C4, D4, E4, F4, G4, H4,
  A5 = 64, B5, C5, D5, E5, F5, G5, H5,
  A6 = 80, B6, C6, D6, E6, F6, G6, H6,
  A7 = 96, B7, C7, D7, E7, F7, G7, H7,
  A8 = 112, B8, C8, D8, E8, F8, G8, H8
};

enum ecastle {
  CASTLE_WK = 1,
  CASTLE_WQ = 2,
  CASTLE_BK = 4,
  CASTLE_BQ = 8
};

enum emflag {
  MFLAG_NORMAL = 0,
  MFLAG_CAPTURE = 1,
  MFLAG_EPCAPTURE = 2,
  MFLAG_CASTLE = 4,
  MFLAG_EP = 8,
  MFLAG_PROMOTION = 16,
  MFLAG_NULLMOVE = 32
};

struct sboard {
  U8	 pieces[128];
  U8	 color[128];
  char stm;        // side to move: 0 = white,  1 = black
  char castle;     // 1 = shortW, 2 = longW, 4 = shortB, 8 = longB
  char ep;         // en passant square
  U8   ply;
  U64  hash;
  U64	 phash;
  int  rep_index;
  U64  rep_stack[1024];
  S8   KingLoc[2];
  int  PcsqMg[2];
  int  PcsqEg[2];
  int PieceMaterial[2];
  int PawnMaterial[2];
  U8 PieceCount[2][6];
};
extern sboard b;


struct smove {
  char id;
  char from;
  char to;
  U8 piece_from;
  U8 piece_to;
  U8 piece_cap;
  char flags;
  char castle;
  char ply;
  char ep;
  int score;
};


struct sSearchDriver {
  int myside;
  U8 depth;
  int history[128][128];
  smove killers[1024][2];
  U64 nodes;
  S32 movetime;
  U64 q_nodes;
  unsigned long starttime;
} extern sd;

enum etimef {
  FTIME = 1,
  FINC = 2,
  FMOVESTOGO = 4,
  FDEPTH = 8,
  FNODES = 16,
  FMATE = 32,
  FMOVETIME = 64,
  FINFINITE = 128
};

struct stime {
  int time[2];
  int inc[2];
  int movestogo;
  int depth;
  int nodes;
  int mate;
  int movetime;
  U8 flags;
} extern chronos;



struct s_eval_data {

  int PIECE_VALUE[6];
  int SORT_VALUE[6];
  int START_MATERIAL;

  /* Piece-square tables - we use size of the board representation,
  not 0..63, to avoid re-indexing. Initialization routine, however,
  uses 0..63 format for clarity */
  int mgPst[6][2][128];
  int egPst[6][2][128];

  /* piece-square tables for pawn structure */

  int weak_pawn[2][128]; // isolated and backward pawns are scored in the same way
  int passed_pawn[2][128];
  int protected_passer[2][128];

  int sqNearK[2][128][128];

  /* single values - letter p before a name signifies a penalty */

  int BISHOP_PAIR;
  int P_KNIGHT_PAIR;
  int P_ROOK_PAIR;
  int ROOK_OPEN;
  int ROOK_HALF;
  int P_BISHOP_TRAPPED_A7;
  int P_BISHOP_TRAPPED_A6;
  int P_KNIGHT_TRAPPED_A8;
  int P_KNIGHT_TRAPPED_A7;
  int P_BLOCK_CENTRAL_PAWN;
  int P_KING_BLOCKS_ROOK;

  int SHIELD_1;
  int SHIELD_2;
  int P_NO_SHIELD;

  int RETURNING_BISHOP;
  int P_C3_KNIGHT;
  int P_NO_FIANCHETTO;
  int FIANCHETTO;
  int TEMPO;
  int ENDGAME_MAT;
};
extern s_eval_data e;

extern char vector[5][8];
extern bool slide[5];
extern char vectors[5];

void board_display();
void clearBoard();
void fillSq(U8 color, U8 piece, S8 sq);
void clearSq(S8 sq);
int board_loadFromFen(char * fen);


int com_send(char * command);
int com_sendmove(smove m);
int com_uci(char * command);
int com_xboard(char * command);
int com_nothing(char * command);
int com();
int com_init();
int com_ismove(char * command);



U8 movegen(smove * moves, U8 tt_move, bool captures = false);
U8 movegen_qs(smove * moves);
void movegen_sort(U8 movecount, smove * m, U8 current);


void convert_0x88_a(S8 sq, char * a);
U8 convert_a_0x88(char * a);
char * algebraic_writemove(smove m, char * a);
int algebraic_moves(char * a);


int move_make(smove move);
int move_unmake(smove move);
int move_makeNull();
int move_unmakeNull(char ep);

// the next couple of functions respond to questions about moves or move lists

int move_iscapt(smove m);
int move_isprom(smove m);
int move_canSimplify(smove m);
int move_countLegal();
int move_isLegal(smove m);


smove strToMove(char * a);

// subsidiary functions used to initialize opening book are hidden in book.h
void initBook();
int getBookMove(int book_type);


void search_run(); // interface of the search functions
void clearHistoryTable();


void setDefaultEval();
void setBasicValues();
void setSquaresNearKing();
void setPcsq();
void correctValues();
void readIniFile();
void processIniString(char line[250]);


int eval(int alpha, int beta, int use_hash);
int isPiece(U8 color, U8 piece, S8 sq);
void printEval();
void printEvalFactor(int wh, int bl);


int Quiesce(int alpha, int beta);
int badCapture(smove move);
int pawnRecapture(U8 capturers_color, char sq);

int isAttacked(char byColor, S8 sq);
int leaperAttack(char byColor, S8 sq, char byPiece);
int straightAttack(char byColor, S8 sq, int vect);
int diagAttack(int btColor, S8 sq, int vect);

void perft_start(char * command);
U64 perft(U8 depth);

void util_bench(char * command);
int util_pv(char * pv);

unsigned int gettime();
int time_uci_ponderhit();
void time_uci_go(char * command);
void time_xboard_go();
void time_nothing_go();
void time_calc_movetime();
bool time_stop_root();
bool time_stop();

int isRepetition();

int isDraw();

void printWelcome();
void printHelp();
void printStats();
void printSearchHeader();

Up one Level