Wikispaces : chessprogramming - items matching description

CPW-Engine_0x88_math

GerdIsenberg — Tue, 30 Dec 2014 18:33:23 GMT

Home * Engines * CPW-Engine * 0x88_math

/* row identifiers */
 
#define ROW_1   ( A1 >> 4 )
#define ROW_2   ( A2 >> 4 )
#define ROW_3   ( A3 >> 4 )
#define ROW_4   ( A4 >> 4 )
#define ROW_5   ( A5 >> 4 )
#define ROW_6   ( A6 >> 4 )
#define ROW_7   ( A7 >> 4 )
#define ROW_8   ( A8 >> 4 )
 
/* column identifiers */
 
#define COL_A  ( A1 & 7 )
#define COL_B  ( B1 & 7 )
#define COL_C  ( C1 & 7 )
#define COL_D  ( D1 & 7 )
#define COL_E  ( E1 & 7 )
#define COL_F  ( F1 & 7 )
#define COL_G  ( G1 & 7 )
#define COL_H  ( H1 & 7 )
 
/* vectors */
 
#define NORTH  16
#define NN    ( NORTH + NORTH )
#define SOUTH  -16
#define SS    ( SOUTH + SOUTH )
#define EAST  1
#define WEST  -1
#define NE    17
#define SW    -17
#define NW    15
#define SE    -15
 
/* geberate square number from row and column */
#define SET_SQ(row,col) (row * 16 + col)
 
/* does a given number represent a square on the board? */
#define IS_SQ(x)  ( (x) & 0x88 ) ? (0) : (1)
 
/* get board column that a square is part of */
#define COL(sq)  ( (sq) & 7 )
 
/* get board row that a square is part of */
#define ROW(sq)  ( (sq) >> 4 )
 
/* determine if two squares lie on the same column */
#define SAME_COL(sq1,sq2) ( ( COL(sq1) == COL(sq2) ) ? (1) : (0) )
 
/* determine if two squares lie in the same row */
#define SAME_ROW(sq1,sq2) ( ( ROW(sq1) == ROW(sq2) ) ? (1) : (0) )

What links here?

Page	Date Edited
0x88	Nov 28, 2016
CPW-Engine	Dec 31, 2014
CPW-Engine_0x88_math	Dec 30, 2014
CPW-Engine_constants	Jun 13, 2011

Up one Level

CPW-Engine_algebraic

GerdIsenberg — Sun, 15 May 2011 18:24:50 GMT

Description

Code

int convert_0x88_a(sq, a)

int convert_a_0x88(a)

int algebraic_moves(a)

What links here?

Home * Engines * CPW-Engine * Algebraic

Description

When communicating with the GUI, the Engine is supposed to use the algebraic game notation. The code on this page is used to translate the positions in the engine native form to the GUI friendly representation and back again.

The algebraic game notation first has 2 characters representing the square the piece comes from (eg.: "e2"). Then 2 characters to indicate the square the piece moves to (eg.: "e4"). And finally, in case of a promotion, the piece the pawn is promoted to ( q | r | b | n ). So a possible starting move for white could be "e2e4". And a possible promotion move could be "a7a8n".

Code

int convert_0x88_a(sq, a)

int convert_0x88_a(int sq, char * a) {
    a[0] = COL(sq) + 'a';
    a[1] = ROW(sq) + '1';
    a[2] = 0;
    return 0;
}

int convert_a_0x88(a)

int convert_a_0x88(char * a) {
    int sq = 0;
    sq = a[0] - 'a';
    sq += (a[1] - '1') * 16;
 
    return sq;
}

int algebraic_moves(a)

int algebraic_moves(char * a) {
 
    smoves m;
 
    while ((a[0] >= 'a') && (a[0] <= 'h')) {
 
        m.from = convert_a_0x88(a);
        m.to = convert_a_0x88(a+2);
 
        m.piece_from = b.pieces[m.from];
        m.piece_to = b.pieces[m.from];
        m.piece_cap = b.pieces[m.to];
 
        m.flags = 0;
        m.castle = 0;
        m.ep = 0;
        m.ply = 0;
        m.score = 0;
 
        switch (a[4]) {
        case 'q': m.piece_to = PIECE_QUEEN; a++; break;
        case 'r': m.piece_to = PIECE_ROOK; a++; break;
        case 'b': m.piece_to = PIECE_BISHOP; a++; break;
        case 'n': m.piece_to = PIECE_KNIGHT; a++; break;
        }
 
        //castling
        if ((m.piece_from == PIECE_KING) &&
            ((m.from == E1 && (m.to == G1 || m.to == C1)) ||
            (m.from == E8 && (m.to == G8 || m.to == C8)))) {
                m.flags = MFLAG_CASTLE;
        }
 
        /*ep
            if the moving-piece is a Pawn, the square it moves to is empty and
            it was a diagonal move it has to be an en-passant capture.
        */
        if ((m.piece_from == PIECE_PAWN) &&
            (m.piece_cap == PIECE_EMPTY) &&
            ((abs(m.from-m.to)==15)||(abs(m.from-m.to)==17))) {
                m.flags = MFLAG_EPCAPTURE;
        }
 
        move_make(m);
 
        a += 4;
 
        while (a[0]==' ') a++;
 
    }
 
    return 0;
}

What links here?

Page	Date Edited
Algebraic Chess Notation	Sep 25, 2017
CPW-Engine	Dec 31, 2014
CPW-Engine_algebraic	May 15, 2011
Entering Moves	Sep 7, 2017

Up one Level

CPW-Engine_attacks

GerdIsenberg — Tue, 30 Dec 2014 18:39:57 GMT

Home * Engines * CPW-Engine * Attacks

This page holds the functions responsible for detecting if a given square is attacked by a given player.

isAttacked

#include "stdafx.h"
#include "0x88_math.h"
 
int isAttacked( char byColor, S8 sq ) {
/* pawns */
if ( byColor == WHITE ) {
   if ( IS_SQ( sq + SE ) &&
        isPiece( WHITE, PAWN, sq + SE )
      )
      return 1;
   if ( IS_SQ( sq + SW ) &&
        isPiece( WHITE, PAWN, sq + SW )
      )
      return 1;
}
else {
   if ( IS_SQ( sq + NE ) &&
        isPiece( BLACK, PAWN, sq + NE )
      )
      return 1;
   if ( IS_SQ( sq + NW ) &&
        isPiece( BLACK, PAWN, sq + NW )
      )
      return 1;
}
 
/* knights */
if ( leaperAttack( byColor, sq, KNIGHT ) )
   return 1;
 
 /* kings */
if ( leaperAttack( byColor, sq, KING ) )
   return 1;
 
 /* straight line sliders */
    if ( straightAttack( byColor, sq, NORTH ) ||
         straightAttack( byColor, sq, SOUTH ) ||
         straightAttack( byColor, sq, EAST  ) ||
         straightAttack( byColor, sq, WEST  )
       )
       return 1;
 
 /* diagonal sliders */
    if ( diagAttack( byColor, sq, NE ) ||
         diagAttack( byColor, sq, SE ) ||
         diagAttack( byColor, sq, NW ) ||
         diagAttack( byColor, sq, SW )
       )
       return 1;
 
    return 0;
}

leaperAttack

int leaperAttack( char byColor, S8 sq, char byPiece ) {
    S8 nextSq;
    for ( int dir = 0; dir < 8; dir++ ) {
        nextSq = sq + vector[byPiece][dir];
        if ( IS_SQ(nextSq) &&
             isPiece( byColor, byPiece, nextSq )
           )
           return 1;
    }
    return 0;
}

straightAttack

int straightAttack(char byColor, S8 sq, int vect) {
    int nextSq = sq + vect;
 
    while ( IS_SQ(nextSq) ) {
       if (b.color[nextSq] != COLOR_EMPTY ) {
           if ( ( b.color[nextSq] == byColor ) &&
                ( b.pieces[nextSq] == ROOK || b.pieces[nextSq] == QUEEN )
              )
              return 1;
           return 0;
          }
       nextSq = nextSq + vect;
    }
     return 0;
}

diagAttack

int diagAttack(int byColor, S8 sq, int vect) {
    int nextSq = sq + vect;
 
    while ( IS_SQ( nextSq ) ) {
       if (b.color[ nextSq ] != COLOR_EMPTY ) {
           if ( ( b.color[nextSq] == byColor ) &&
                ( b.pieces[nextSq] == BISHOP || b.pieces[nextSq] == QUEEN )
              )
              return 1;
           return 0;
          }
       nextSq = nextSq + vect;
    }
    return 0;
}

Up one Level

CPW-Engine_board(0x88)

Pawel_Koziol — Tue, 30 Dec 2014 19:03:35 GMT

Home * Engines * CPW-Engine * Board (0x88)

 
#include "stdafx.h"
#include "0x88_math.h"
#include "transposition.h"
 
sboard b;
 
 
void clearBoard() {
 
    //reset b struct
 
    for (int i=0;i<128;i++) {
        b.pieces[i] = PIECE_EMPTY;
        b.color[i] = COLOR_EMPTY;
    }
    b.castle = 0;
    b.ep     = -1;
    b.ply    = 0;
    b.hash   = 0;
    b.phash  = 0;
    b.stm    = 0;
    b.rep_index=0;
 
    // reset perceived values
 
    b.PieceMaterial[WHITE] = 0;
    b.PieceMaterial[BLACK] = 0;
    b.PawnMaterial[WHITE]  = 0;
    b.PawnMaterial[BLACK]  = 0;
    b.PcsqMg[WHITE] = 0;
    b.PcsqMg[BLACK] = 0;
    b.PcsqEg[WHITE] = 0;
    b.PcsqEg[BLACK] = 0;
 
 
    // reset counters
 
    for (int i=0;i<6;i++) {
        b.PieceCount[ WHITE ] [ i ] = 0;
        b.PieceCount[ BLACK ] [ i ] = 0;
    }
}
 
/********************************************************************
* fillSq() and clearSq(), beside placing a piece on a given square  *
* or erasing it, must take care for all the incrementally  updated  *
* stuff: hash keys, piece counters, material and pcsq values, king  *
* location.                                                         *
********************************************************************/
 
void fillSq(U8 color, U8 piece, S8 sq) {
 
    // place a piece on the board
    b.pieces[sq] = piece;
    b.color[sq] = color;
 
    // update king location
    if (piece == KING)
        b.KingLoc[color] = sq;
 
    if ( piece == PAWN ) { 
        // update pawn material
        b.PawnMaterial[color] += e.PIECE_VALUE[piece];
 
        // update pawn hashkey - please note conversion to a 32-bit integer
        b.phash ^= zobrist.piecesquare[piece][color][sq];
    }
    else {
        // update piece material
        b.PieceMaterial[color] += e.PIECE_VALUE[piece];
    }
 
    // update piece counter
    b.PieceCount[color][piece]++;
 
    // update piece-square value
    b.PcsqMg[color] += e.mgPst[piece][color][sq];
    b.PcsqEg[color] += e.egPst[piece][color][sq];
 
    // update hash key
    b.hash ^= zobrist.piecesquare[piece][color][sq];
}
 
 
void clearSq(S8 sq) {
 
    // set intermediate variables, then do the same 
    // as in fillSq(), only backwards
 
    U8 color = b.color[sq];
    U8 piece = b.pieces[sq];
 
    b.hash ^= zobrist.piecesquare[piece][color][sq];
 
    if ( piece == PAWN ) { 
        b.PawnMaterial[color] -= e.PIECE_VALUE[piece];
        b.phash ^= zobrist.piecesquare[piece][color][sq];
    }
    else 
        b.PieceMaterial[color] -= e.PIECE_VALUE[piece];
 
    b.PcsqMg[color] -= e.mgPst[piece][color][sq];
    b.PcsqEg[color] -= e.egPst[piece][color][sq];
 
    b.PieceCount[color][piece]--;
 
    b.pieces[sq] = PIECE_EMPTY;
    b.color[sq] = COLOR_EMPTY;
}
 
 
int board_loadFromFen(char * fen) {
 
    clearBoard();
    clearHistoryTable();
 
    char * f = fen;
 
    char col = 0;
    char row = 7;
 
    do {
        switch( f[0] ) {
        case 'K': fillSq(WHITE, KING, SET_SQ(row, col));   col++; break;
        case 'Q': fillSq(WHITE, QUEEN, SET_SQ(row, col));  col++; break;
        case 'R': fillSq(WHITE, ROOK, SET_SQ(row, col));   col++; break;
        case 'B': fillSq(WHITE, BISHOP, SET_SQ(row, col)); col++; break;
        case 'N': fillSq(WHITE, KNIGHT, SET_SQ(row, col)); col++; break;
        case 'P': fillSq(WHITE, PAWN, SET_SQ(row, col));   col++; break;
        case 'k': fillSq(BLACK, KING, SET_SQ(row, col));   col++; break;
        case 'q': fillSq(BLACK, QUEEN, SET_SQ(row, col));  col++; break;
        case 'r': fillSq(BLACK, ROOK, SET_SQ(row, col));   col++; break;
        case 'b': fillSq(BLACK, BISHOP, SET_SQ(row, col)); col++; break;
        case 'n': fillSq(BLACK, KNIGHT, SET_SQ(row, col)); col++; break;
        case 'p': fillSq(BLACK, PAWN, SET_SQ(row, col));   col++; break;
        case '/': row--; col=0; break;
        case '1': col+=1; break;
        case '2': col+=2; break;
        case '3': col+=3; break;
        case '4': col+=4; break;
        case '5': col+=5; break;
        case '6': col+=6; break;
        case '7': col+=7; break;
        case '8': col+=8; break;
        };
 
        f++;
    } while ( f[0] != ' ' );
 
    f++;
 
    if (f[0]=='w') { 
        b.stm = WHITE;
    } else { 
        b.stm = BLACK; 
        b.hash ^= zobrist.color;
    }
 
    f+=2;
 
    do {
        switch( f[0] ) {
        case 'K': b.castle |= CASTLE_WK; break;
        case 'Q': b.castle |= CASTLE_WQ; break;
        case 'k': b.castle |= CASTLE_BK; break;
        case 'q': b.castle |= CASTLE_BQ; break;
        }
 
        f++;
    } while (f[0] != ' ' );
 
    b.hash ^= zobrist.castling[b.castle];
 
    f++;
 
    if (f[0] != '-') {
        b.ep = convert_a_0x88(f);
        b.hash ^= zobrist.ep[b.ep];
    }
 
    do { f++; } while (f[0] != ' ' );
    f++;
 
    sscanf(f, "%d", &b.ply);
 
    b.rep_index = 0;
    b.rep_stack[b.rep_index] = b.hash;
 
    return 0;
}
 
 
void board_display() {
 
    S8 sq;
 
    char parray[3][7] = { {'K','Q','R','B','N','P'},
                          {'k','q','r','b','n','p'},
                          { 0 , 0 , 0 , 0 , 0,  0, '.'}
                        };
 
    printf("   a b c d e f g h\n\n");
 
    for (S8 row=7; row>=0; row--) {
 
        printf("%d ", row+1);
 
        for (S8 col=0; col<8; col++) {
            sq = SET_SQ(row, col);
            printf(" %c",parray[b.color[sq]][b.pieces[sq]] );
        }
 
        printf("  %d\n", row+1);
 
    }
 
    printf("\n   a b c d e f g h\n\n");
}

What links here?

Page	Date Edited
0x88	Nov 28, 2016
CPW-Engine	Dec 31, 2014
CPW-Engine_board(0x88)	Dec 30, 2014
CPW-Engine_move(0x88)	Dec 30, 2014

Up one Level

CPW-Engine_book

GerdIsenberg — Mon, 08 May 2017 16:07:08 GMT

Home * Engines * CPW-Engine * Book

This is the opening book module of the CPW-Engine. Is responsibilities are:

reading opening book in the text format (e2e4 a7a6-d2d4 b7b5 a2a4 c8b7 b1d2, where "-" means that preceeding move is not to be played
filtering out illegal moves from the text file and warning user about them
choosing the opening move out of possible alternatives (either completely randomly or based on frequency)

Obviously, initializing a book takes some time (a couple of seconds in case of 15.000 moves) and really efficiten method would be to read and write opening book in the internal format. However, even it this case the code presented here, after some modification, would be useful for feeding moves into the opening book.

See also CPW-Engine_book_h

#include "stdafx.h"
#include "book.h"
 
#define BOOK_SIZE 36000
#define EXCLUDED -1
 
U64 start_hash;
int book_index;
int book_move_count;
 
struct sBook {
  U64 hash;
  smove move;
  int freq;
};
 
sBook book[BOOK_SIZE];
 
enum eproto {
    PROTO_NOTHING,
    PROTO_XBOARD,
    PROTO_UCI
} extern mode;
 
void initBook() {
 
    book_index = 0;
    book_move_count = 0;
 
    // if we want to have internal book even though the book file is missing,
    // we might add a couple of lines like that
 
    book_loadInternal();
    readBookFile();
    board_loadFromFen(STARTFEN);
}
 
void readBookFile() {
      FILE *cpw_book; 
      char line[256];
      int line_no = 0;
 
      /* if the book file does not exist, then exit */
 
      if ( (cpw_book = fopen("cpw_book.txt", "r")) == NULL ) {
          printf("Cannot open cpw_book.txt, only small internal book will be used \n");
         return;
      }
 
      /* process book file line by line */
 
      while ( fgets(line, 250, cpw_book) ) {
            ++line_no;
            if(line[0] == ';') continue; // don't process comment lines
            book_addline( line_no, line );
      }
 
      printf("Loaded %d book moves\n", book_move_count);
 }
 
void book_addline( int line_no, char * movestring ) {
     char local_string[5];
 
     board_loadFromFen( STARTFEN );
     int limit = (int) strlen( movestring );
 
     for (int i = 0; i < limit / 5 + 1; i++) {
 
     local_string[0] = movestring[5*i];
     local_string[1] = movestring[5*i+1];
     local_string[2] = movestring[5*i+2];
     local_string[3] = movestring[5*i+3];
     local_string[4] = movestring[5*i+4];
 
     /*********************************************
     * On finding an illegal move in a book file, *
     * report line number and move sequence.      *
     *********************************************/
 
     if ( com_ismove( local_string ) ) {
         if ( !book_add( local_string ) ) { 
             printf("book file error in line %d: ", line_no);
             printf(movestring); 
             printf("\n"); 
         };
     }
     else
        return;  
     }
}
 
int book_add( char * movestring ) {
 
    /************************************************************** 
    *  Don't record anything if a move has been already recorded. *
    *  Make a move, because a new one is likely to be a couple    *
    *  of steps further down the path, and exit.                  *
    **************************************************************/
 
    if ( book_present( movestring ) ) {
        move_make( strToMove( movestring ) );
        return 1;
    }
 
    smove curr_move = strToMove( movestring );
 
    if ( move_isLegal( curr_move ) ) {
 
       book[book_index].hash = b.hash;
       book[book_index].move = curr_move;
       ++book_move_count;
 
       if (movestring[4] == '-') 
          book[book_index].freq = EXCLUDED;
       else
          book[book_index].freq = 1;
 
       ++book_index;
 
       move_make( strToMove( movestring ) ); 
       return 1;
    } 
    else
        return 0;
}
 
int book_present( char * movestring ) {
    U64 curr_hash = b.hash;
    smove curr_move = strToMove( movestring );
 
    for (int i = 0; i < book_index; i++) {
 
        if ( book[i].hash == curr_hash && 
             book[i].move.from == curr_move.from &&
             book[i].move.to   == curr_move.to ) {
 
            /* see whether a move has been marked as excluded */
            if ( movestring[4] == '-' ) 
                book[i].freq = EXCLUDED;
            else {
                if ( book[i].freq > EXCLUDED )
                   ++book[i].freq; 
            }
 
            return 1;
        }
 
    }
 
    return 0;
}
 
int book_getMaxFreq() {
    int result = 0;
 
    for (int i = 0; i < BOOK_SIZE; i++) {
        if ( book[i].hash == b.hash ) {
            if ( book[i].freq > result )
                result = book[i].freq;
        }
    }
 
    return result;
}
 
int getBookMove( int book_type ) {
    int result = 0;
    int priority = EXCLUDED;
    int temp;
    smove book_move;
    char move_string[6];
    int max_freq = book_getMaxFreq();
 
    if ( book_type == BOOK_NONE ) return 0;
 
    srand( gettime() );
 
    for (int i = 0; i < BOOK_SIZE; i++) {
        if ( book[i].hash == b.hash ) {
 
            /****************************************************
            * Debug code, showing possible choices as well as   *
            * move frequencies (console mode only)              *
            ****************************************************/
 
            if ( mode == PROTO_NOTHING ) {
 
               convert_0x88_a( book[i].move.from, move_string );
               convert_0x88_a( book[i].move.to  , move_string+2 );
               printf( move_string );
 
               if ( book[i].freq == EXCLUDED ) 
                   printf("?");
               else
                   printf("(%d)", book[i].freq);
 
               printf(" ");
            }
 
            /****************************************************
            * Get the value used to decide which move to  play. *
            * If book is meant to be broad, it will be a random *
            * value, distributed evenly between moves that  are *
            * not  excluded. When using narrow book,  frequency *
            * of a move will be taken into account.             *
            ****************************************************/
 
            if ( book_type == BOOK_NARROW )
               temp = ( abs( rand() ) / max_freq ) * ( book[i].freq );
            else
               temp = abs( rand() );
 
            /****************************************************
            * If new move is backed up by a greater number,     *
            * it replaces the old one.                          *
            ****************************************************/
 
            if ( ( temp > priority ) && 
                 ( book[i].freq != EXCLUDED ) 
               ) {
                priority = temp;
                book_move = book[i].move;
                result = 1;
            }
        }
    }
 
    printf("\n");
    if (result) com_sendmove( book_move );
 
    return result;
}
 
void book_loadInternal() {
 
    // Four knights
 
    book_addline(0,"e2e4 e7e5 b1c3 g8f6 g1f3 b8c6 f1b5 f8b4 e1g1 e8g8 d2d3 d7d6 c1g5 b4c3 b2c3 d8e7 f1e1 c6d8 d3d4 d8e6");
 
    // Italian
 
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1c4 f8c5 c2c3 g8f6 d2d4 e5d4 c3d4 c5b4 c1d2 b4d2 b1d2 d7d5");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1c4 f8c5 c2c3 g8f6 d2d3 d7d6 b2b4 c5b6 a2a4 a7a5 b4b5 c6e7");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1c4 f8c5 d2d3 g8f6 c2c3");
 
    // Two knights
 
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1c4 g8f6 f3g5 d7d5 e4d5 c6a5 c4b5 c7c6 d5c6 b7c6 b5e2 h7h6 g5f3 e5e4 f3e5 f8d6 f2f4 e4f3 e5f3 e8g8 d2d4 c6c5");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1c4 g8f6 d2d4 e5d4 e1g1 f6e4 f1e1 d7d5 c4d5 d8d5 b1c3 d5h5 c3e4 c8e6");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1c4 g8f6 d2d3 f8e7 e1g1 e8g8 c2c3 d7d6 c4b3");
 
    // Scotch
 
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 d2d4 e5d4 f3d4 g8f6 d4c6 b7c6 e4e5 d8e7 d1e2 f6d5 c2c4 c8a6 g2g3 g7g6 b2b3 f8g7 c1b2 e8g8 f1g2 a8e8 e1g1 ");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 d2d4 e5d4 f3d4 f8c5 c1e3 d8f6 c2c3 g8e7 g2g3 e8g8 f1g2");
 
    // Ruy Lopez
 
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1b5 a7a6 b5a4 g8f6 e1g1 f8e7 f1e1 b7b5 a4b3 d7d6 c2c3 e8g8 h2h3 c6a5 b3c2 c7c5 d2d4 d8c7");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1b5 f8c5 c2c3 g8f6 e1g1 e8g8 d2d4 c5b6 f1e1 d7d6 h2h3 c6e7 b1d2");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1b5 g8f6 e1g1 f8c5 f3e5 c6e5 d2d4 c7c6 d4e5 f6e4 b5d3 d7d5 e5d6 e4f6 f1e1");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1b5 g8f6 e1g1 f6e4 d2d4 f8e7 d1e2 e4d6 b5c6 b7c6 d4e5 d6b7 b1c3 e8g8 f3d4");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1b5 a7a6 b5a4 g8f6 e1g1 f6e4 d2d4 b7b5 a4b3 d7d5 d4e5 c8e6 c2c3 e4c5 b3c2 e6g4");
    book_addline(0,"e2e4 e7e5 g1f3 b8c6 f1b5 a7a6 b5a4 g8f6 e1g1 f8e7 f1e1 b7b5 a4b3 d7d6 c2c3 e8g8 h2h3 c8b7 d2d4 f8e8 b1d2 e7f8 a2a3 h7h6 b3c2 c6b8 b2b4 b8d7 c1b2 g7g6");
 
    // Petroff
 
    book_addline(0,"e2e4 e7e5 g1f3 g8f6 f3e5 d7d6 e5f3 f6e4 d2d4 d6d5 f1d3 b8c6 e1g1 c8g4 c2c4 e4f6");
    book_addline(0,"e2e4 e7e5 g1f3 g8f6 f3e5 d7d6 e5f3 f6e4 d2d4 d6d5 f1d3 b8c6 e1g1 f8e7 c2c4 c6b4");
    book_addline(0, "e2e4 e7e5 g1f3 g8f6 f3e5 d7d6 e5f3 f6e4 b1c3 e4c3 d2c3");
    book_addline(0,"e2e4 e7e5 g1f3 g8f6 d2d4 f6e4 f1d3 d7d5 f3e5 b8d7 e5d7 c8d7 e1g1 f8d6 c2c4 c7c6 b1c3 e4c3 b2c3");
 
    // Sicilian
 
    book_addline(0,"e2e4 c7c5 c2c3 d7d5 e4d5 d8d5 d2d4 e7e6");
    book_addline(0,"e2e4 c7c5 c2c3 g8f6 e4e5 f6d5 d2d4 c5d4 g1f3 e7e6 c3d4 b7b6 b1c3 d5c3 b2c3 d8c7");
    book_addline(0,"e2e4 c7c5 g1f3 d7d6 d2d4 c5d4 f3d4 g8f6 b1c3 a7a6 f1e2 e7e5 d4b3 f8e7 e1g1 e8g8 a2a4 b7b6");
    book_addline(0,"e2e4 c7c5 b1c3 b8c6 g2g3 g7g6 f1g2 f8g7 d2d3 e7e6 c1e3 d7d6 g1e2 c6d4 d1d2");
    book_addline(0,"e2e4 c7c5 g1f3 d7d6 d2d4 c5d4 f3d4 g8f6 b1c3 a7a6 c1g5 e7e6 d1d2 f8e7 e1c1 e8g8");
    book_addline(0,"e2e4 c7c5 g1f3 d7d6 d2d4 c5d4 f3d4 g8f6 b1c3 a7a6 g2g3 e7e5 d4e2 b7b5 f1g2 c8b7 e1g1 b8d7");
    book_addline(0,"e2e4 c7c5 g1f3 b8c6 d2d4 c5d4 f3d4 g7g6 b1c3 f8g7 c1e3 g8f6 f1c4 e8g8");
    book_addline(0,"e2e4 c7c5 g1f3 b8c6 d2d4 c5d4 f3d4 g8f6 b1c3 d7d6 f1e2 e7e5 d4b3 f8e7 e1g1 e8g8 c1e3 c8e6");
    book_addline(0,"e2e4 c7c5 g1f3 b8c6 d2d4 c5d4 f3d4 g8f6 b1c3 d7d6 f1e2 g7g6 c1e3 f8g7 e1g1 e8g8 d4b3 c8e6");
 
    // French
 
    book_addline(0,"e2e4 e7e6 d2d4 d7d5 e4e5 c7c5 c2c3 b8c6 g1f3 d8b6 a2a3 c5c4");
    book_addline(0,"e2e4 e7e6 d2d4 d7d5 b1c3 g8f6 c1g5 f8e7 e4e5 f6d7 g5e7 d8e7 f2f4 e8g8 d1d2 c7c5 g1f3 b8c6 e1c1 c5c4");
    book_addline(0,"e2e4 e7e6 d2d4 d7d5 b1c3 d5e4 c3e4 b8d7 g1f3 g8f6 e4f6 d7f6 f1d3 b7b6 d1e2 c8b7? c1g5 f8e7");
    book_addline(0,"e2e4 e7e6 d2d4 d7d5 b1c3 f8b4 e4e5 g8e7 a2a3 b4c3 b2c3 c7c5 g1f3 b8c6 a3a4 d8a5 d1d2 c8d7");
    book_addline(0,"e2e4 e7e6 d2d4 d7d5 b1c3 f8b4 e4e5 g8e7 a2a3 b4c3 b2c3 c7c5 a3a4 b8c6 g1f3 d8a5 c1d2 c8d7");
    book_addline(0,"e2e4 e7e6 d2d4 d7d5 b1c3 f8b4 e4e5 c7c5 a2a3 b4c3 b2c3 g8e7 d1g4 d8c7 g4g7 h8g8 g7h7 c5d4 g1e2 b8c6 f2f4 c8d7");
    book_addline(0,"e2e4 e7e6 d2d4 d7d5 b1d2 c7c5 e4d5 e6d5 g1f3 b8c6 f1b5 f8d6 d4c5 d6c5 e1g1 g8e7");
    book_addline(0,"e2e4 e7e6 d2d4 d7d5 b1d2 c7c5 g1f3 g8f6 e4d5 e6d5 f1b5 c8d7 b5d7 b8d7 e1g1 f8e7");
    book_addline(0,"e2e4 e7e6 d2d4 d7d5 b1d2 g8f6 e4e5 f6d7 f1d3 c7c5 c2c3 b8c6 g1e2 c5d4 c3d4 f7f6 e5f6 d7f6 e1g1 f8d6");
 
    // Caro-Kann
 
    book_addline(0,"e2e4 c7c6 d2d4 d7d5 b1c3 d5e4 c3e4 b8d7 g1f3 g8f6 e4f6 d7f6 f3e5");
    book_addline(0,"e2e4 c7c6 b1c3 d7d5 d2d4 d5e4 c3e4 b8d7 f1c4 g8f6 e4g5 e7e6 d1e2 d7b6");
    book_addline(0,"e2e4 c7c6 b1c3 d7d5 d2d4 d5e4 c3e4 b8d7 e4g5 g8f6 f1d3 e7e6");
    book_addline(0,"e2e4 c7c6 d2d4 d7d5 b1c3 d5e4 c3e4 c8f5 e4g3 f5g6 h2h4 h7h6 g1f3 g8f6-f3e5 g6h7 f1d3 b8d7 d3h7");
    book_addline(0,"e2e4 c7c6 d2d4 d7d5 b1c3 d5e4 c3e4 c8f5 e4g3 f5g6 h2h4 h7h6 g1f3 b8d7 h4h5 g6h7 f1d3 h7d3 d1d3 g8f6 c1d2 e7e6 e1c1");
    book_addline(0,"e2e4 c7c6 d2d4 d7d5 b1c3 d5e4 c3e4 c8f5 e4g3 f5g6 h2h4 h7h6 g1f3 b8d7 h4h5 g6h7 f1d3 h7d3 d1d3 e7e6 c1d2 g8f6 e1c1");
    book_addline(0,"e2e4 c7c6 d2d4 d7d5 b1c3 d5e4 c3e4 c8f5 e4g3 f5g6 g1f3 b8d7 h2h4 h7h6 f1d3 g6d3 d1d3 e7e6 c1d2 g8f6 e1c1");
    book_addline(0,"e2e4 c7c6 d2d4 d7d5 b1d2 d5e4 d2e4");
    book_addline(0,"e2e4 c7c6 d2d4 d7d5 e4d5 c6d5 c2c4 g8f6 b1c3 e7e6 g1f3");
    book_addline(0,"e2e4 c7c6 d2d4 d7d5 e4d5 c6d5 c2c4 g8f6 b1c3 b8c6 c1g5 e7e6 c4c5 f8e7 f1b5 e8g8 g1f3 f6e4");
    book_addline(0,"e2e4 c7c6 d2d4 d7d5 e4e5 c8f5 f1d3 f5d3 d1d3 e7e6 b1c3 d8b6");
    book_addline(0,"e2e4 c7c6 b1c3 d7d5 g1f3 c8g4 h2h3 g4f3 d1f3 e7e6 d2d4 g8f6 f1d3 d5e4 c3e4 d8d4 c2c3 d4d8");
 
    // Pirc and modern
 
    book_addline(0,"d2d4 d7d6 e2e4 g8f6 b1c3 g7g6 f1c4 c7c6 d1e2 f8g7 g1f3 e8g8 c1g5 b7b5 c4d3 d8c7");
    book_addline(0,"e2e4 d7d6 d2d4 g8f6 b1c3 g7g6 c1g5 f8g7 d1d2 b8d7 e1c1 e7e5 d4e5 d6e5 g1f3 h7h6 g5h4 g6g5 h4g3 d8e7");
 
    // QGA
 
    book_addline(0,"d2d4 d7d5 c2c4 d5c4 g1f3 g8f6 e2e3 e7e6 f1c4 c7c5 e1g1 a7a6 d1e2 b7b5 c4d3 c5d4 e3d4 b8c6");
 
    // QGD
 
    book_addline(0,"d2d4 d7d5 c2c4 e7e6 b1c3 f8e7 g1f3 g8f6 c4d5 e6d5");
    book_addline(0,"c2c4 e7e6 d2d4 d7d5 b1c3 c7c5 c4d5 e6d5 g1f3 b8c6 g2g3 g8f6 f1g2 f8e7 e1g1 e8g8");
    book_addline(0,"c2c4 e7e6 b1c3 d7d5 d2d4 g8f6 c1g5 f8e7 e2e3 e8g8 g1f3 b8d7 a1c1 c7c6");
    book_addline(0,"d2d4 d7d5 c2c4 e7e6 b1c3 g8f6 c1g5 b8d7 c4d5 e6d5 e2e3 c7c6 f1d3 f8e7 d1c2 e8g8 g1e2 f8e8");
    book_addline(0,"d2d4 d7d5 c2c4 e7e6 b1c3 g8f6 c1g5 b8d7 e2e3 c7c6 g1f3 d8a5 f3d2 f8b4 d1c2 e8g8 g5h4 c6c5");
    book_addline(0,"d2d4 d7d5 c2c4 e7e6 b1c3 g8f6 g1f3 f8e7 c4d5 e6d5 c1g5 e8g8");
 
    // Slav
 
    book_addline(0,"d2d4 d7d5 c2c4 c7c6 b1c3 g8f6 g1f3 d5c4 a2a4 c8f5 f3e5 e7e6 f2f3 f8b4 c1g5 h7h6 g5f6 d8f6 e2e4 f5h7");
    book_addline(0,"d2d4 d7d5 c2c4 c7c6 g1f3 g8f6 b1c3 e7e6 e2e3 b8d7 f1d3 f8d6");
 
    // Catalan
 
    book_addline(0,"d2d4 e7e6 c2c4 d7d5 g2g3 g8f6 g1f3 f8e7 f1g2 e8g8 e1g1 f6d7 d1c2 c7c6 b1d2 b7b6 e2e4 c8b7");
 
    // Nimzo-Indian
 
    book_addline(0,"d2d4 g8f6 c2c4 e7e6 b1c3 f8b4 d1c2 c7c5 d4c5 e8g8 a2a3 b4c5 g1f3 b7b6");
    book_addline(0,"d2d4 g8f6 c2c4 e7e6 b1c3 f8b4 d1c2 e8g8 a2a3 b4c3 c2c3 b7b6 c1g5 c8b7");
    book_addline(0,"d2d4 g8f6 c2c4 e7e6 b1c3 f8b4 g1f3 b7b6 g2g3 c8b7 f1g2");
    book_addline(0,"d2d4 g8f6 c2c4 e7e6 b1c3 f8b4 a2a3 b4c3 b2c3 e8g8 f2f3 d7d5 c4d5 e6d5 e2e3 c8f5 g1e2 b8d7 e2g3 f5g6");
    book_addline(0,"d2d4 g8f6 c2c4 e7e6 b1c3 f8b4 c1d2 e8g8 e2e3 d7d5 g1f3 c7c5 a2a3 b4c3 d2c3 f6e4 a1c1 e4c3 c1c3 c5d4");
    book_addline(0,"d2d4 g8f6 c2c4 e7e6 b1c3 f8b4 e2e3 e8g8 f1d3 d7d5 g1f3 c7c5 e1g1 b8c6 a2a3 b4c3 b2c3 d5c4 d3c4 d8c7");
    book_addline(0,"d2d4 g8f6 c2c4 e7e6 b1c3 f8b4 d1c2 d7d5 a2a3 b4c3 c2c3 b8c6 g1f3 f6e4 c3b3 c6a5 b3a4 c7c6");
 
    // Queen's Indian
 
    book_addline(0,"d2d4 g8f6 c2c4 e7e6 g1f3 b7b6 g2g3 c8b7 f1g2 f8e7 e1g1 e8g8 b1c3 f6e4 d1c2 e4c3 c2c3");
    book_addline(0,"d2d4 g8f6 c2c4 e7e6 g1f3 b7b6 e2e3 c8b7 f1d3 f8e7 b1c3 d7d5 e1g1 e8g8 d1e2 b8d7");
 
    // King's Indian
 
    book_addline(0,"d2d4 g8f6 c2c4 g7g6 b1c3 f8g7 e2e4 d7d6 f2f3 e8g8 c1e3 e7e5 d4d5 f6h5 d1d2 f7f5 e1c1 b8d7");
    book_addline(0,"d2d4 g8f6 c2c4 g7g6 b1c3 f8g7 e2e4 d7d6 g1f3 e8g8 f1e2 e7e5 d4d5 a7a5");
    book_addline(0,"d2d4 g8f6 c2c4 g7g6 g2g3 f8g7 f1g2 e8g8 b1c3 d7d6 g1f3 b8d7 e1g1 e7e5 e2e4 c7c6 h2h3 d8b6");
    book_addline(0,"d2d4 g8f6 c2c4 g7g6 b1c3 f8g7 e2e4 d7d6 f2f4 c7c5 g1f3 e8g8 d4d5 e7e6 f1d3 e6d5 c4d5 d8b6");
    book_addline(0,"d2d4 g8f6 c2c4 g7g6 b1c3 f8g7 e2e4 d7d6 g1f3 e8g8 f1e2 e7e5 e1g1 b8c6 d4d5 c6e7 f3e1 f6e8 f2f3 f7f5");
    book_addline(0,"d2d4 g8f6 c2c4 g7g6 b1c3 f8g7 g1f3 e8g8 c1f4 d7d6 h2h3 b8d7 e2e3 c7c6");
 
    // Grunfeld
 
    book_addline(0,"d2d4 g8f6 c2c4 g7g6 b1c3 d7d5 c1f4 f8g7");
    book_addline(0,"d2d4 g8f6 c2c4 g7g6 b1c3 d7d5 c4d5 f6d5 e2e4 d5c3 b2c3 c7c5 f1c4 f8g7 g1e2 e8g8 e1g1 c5d4 c3d4 b8c6");
    book_addline(0,"d2d4 g8f6 c2c4 g7g6 b1c3 d7d5 g1f3 f8g7 d1b3 d5c4 b3c4 e8g8 e2e4 c8g4 c1e3 f6d7 e1c1 b8c6");
 
    // Benoni
 
    book_addline(0,"d2d4 g8f6 c2c4 c7c5 d4d5 e7e6 b1c3 e6d5 c4d5 d7d6 e2e4 g7g6 f1d3 f8g7 g1e2 e8g8 e1g1 a7a6 a2a4 d8c7");
 
    // Dutch
 
    book_addline(0,"d2d4 f7f5 g2g3 e7e6 f1g2 g8f6 g1f3 f8e7 e1g1 e8g8 c2c4 d7d6 b1c3 d8e8 d1c2 e8h5 b2b3 b8c6 c1a3 a7a5");
 
    // Queen's Pawn
 
    book_addline(0,"d2d4 d7d5 g1f3 g8f6 c1f4 c7c5 e2e3 b8c6 c2c3 d8b6 d1c1 c8f5 d4c5 b6c5 b1d2 a8c8 f3d4 c6d4 e3d4 c5b6");
 
    // English
 
    book_addline(0,"c2c4 e7e5 b1c3 g8f6 g1f3 b8c6 e2e4 f8b4 d2d3 d7d6 f1e2 e8g8 e1g1 b4c3 b2c3 d8e7");
    book_addline(0,"c2c4 e7e5 b1c3 g8f6 g1f3 b8c6 g2g3 d7d5 c4d5 f6d5 f1g2 d5b6 e1g1 f8e7 d2d3 e8g8 c1e3 f7f5");                                                     
    book_addline(0,"c2c4 g8f6 b1c3 d7d5 c4d5 f6d5 e2e4 d5f4 f1c4 c8e6 c4e6 f7e6");
    book_addline(0,"c2c4 g8f6 b1c3 e7e5 g1f3 b8c6 g2g3 f8c5 f1g2 d7d6 e1g1 e8g8 d2d3 h7h6");
    book_addline(0,"c2c4 g8f6 b1c3 e7e5 g1f3 b8c6 g2g3 f8b4 f1g2 e8g8 e1g1 e5e4 f3e1 b4c3 d2c3 h7h6 e1c2 b7b6");
 
    book_addline(0,"c2c4 c7c5 g1f3 b8c6 b1c3 g8f6 g2g3 g7g6 f1g2 f8g7 e1g1 e8g8 d2d4 c5d4 f3d4 c6d4 d1d4 d7d6 d4d3");
 
    // Reti
    book_addline(0,"g1f3 d7d5 g2g3 g8f6 f1g2 g7g6 e1g1 f8g7 d2d3 e8g8 b1d2 b8c6 e2e4 e7e5 c2c3 a7a5 f1e1 d5e4 d3e4");
    book_addline(0,"g1f3 d7d5 c2c4 e7e6 g2g3 g8f6 f1g2 f8e7 e1g1 e8g8 b2b3 c7c5 c4d5 f6d5 c1b2 b8c6 d2d4 b7b6 b1c3 d5c3");
    book_addline(0,"g1f3 d7d5 c2c4 d5c4 e2e3 c7c5 f1c4 e7e6 e1g1 g8f6 b2b3 b8c6 c1b2 a7a6 a2a4 f8e7");
}

What links here?

Page	Date Edited
CPW-Engine	Dec 31, 2014
CPW-Engine_book	May 8, 2017
CPW-Engine_book_h	Sep 27, 2008
Opening Book	Feb 26, 2018
Pseudorandom number generator	May 11, 2017

Up one Level

CPW-Engine_book_h

GerdIsenberg — Sat, 27 Sep 2008 14:05:15 GMT

Home * Engines * CPW-Engine * Book.h

This is the header file for CPW-Engine_book

void readBookFile();
void book_addline( int line_no, char * movestring);
int book_add( char * movestring);
int book_present( char * movestring );
int book_getMaxFreq();
void book_loadInternal();

Up one Level

CPW-Engine_chronos

Pawel_Koziol — Tue, 30 Dec 2014 18:38:57 GMT

Home * Engines * CPW-Engine * Chronos

 
 
#include "stdafx.h"
 
enum etask {
    TASK_NOTHING,
    TASK_SEARCH,
    TASK_PONDER
} extern task;
 
stime chronos;
 
extern sSearchDriver sd;
 
extern bool time_over;
 
#define TIMEBUFFER 500
#define MOVESTOGO 24
 
 
#if defined(_MSC_VER) || defined(_WINDOWS_)
    #include <Windows.h>
 
    unsigned int gettime() {
        FILETIME ft;
        GetSystemTimeAsFileTime(&ft);    
        return (unsigned int) ((((U64)ft.dwHighDateTime << 32) | ft.dwLowDateTime) / 10000);
    }
#else
    #include <sys/time.h>
 
    unsigned int gettime() {
        timeval t;
        gettimeofday(&t, 0);
        return t.tv_usec;
    }
#endif
 
 
void time_uci_go(char * command) {
 
    time_over = false;
    task = TASK_SEARCH;
 
    chronos.flags = 0;
 
    if (strstr(command, "infinite")) {chronos.flags |= FINFINITE;}
    if (strstr(command, "ponder")) {chronos.flags |= FINFINITE; task = TASK_PONDER;}
 
    //not implemented (do an infinite search instead)
    if (strstr(command, "searchmoves")) {chronos.flags |= FINFINITE;}
 
    if (strstr(command, "wtime")) {chronos.flags |= FTIME; sscanf(strstr(command, "wtime"), "wtime %d", &chronos.time[WHITE]);}
    if (strstr(command, "btime")) {chronos.flags |= FTIME; sscanf(strstr(command, "btime"), "%*s %d", &chronos.time[BLACK]);}
    if (strstr(command, "winc")) {chronos.flags |= FINC; sscanf(strstr(command, "winc"), "%*s %d", &chronos.inc[WHITE]);}
    if (strstr(command, "binc")) {chronos.flags |= FINC; sscanf(strstr(command, "binc"), "%*s %d", &chronos.inc[BLACK]);}
    if (strstr(command, "movestogo")) {chronos.flags |= FMOVESTOGO; sscanf(strstr(command, "movestogo"), "%*s %d", &chronos.movestogo);}
    if (strstr(command, "depth")) {chronos.flags |= FDEPTH; sscanf(strstr(command, "depth"), "%*s %d", &chronos.depth);}
    if (strstr(command, "nodes")) {chronos.flags |= FNODES; sscanf(strstr(command, "nodes"), "%*s %d", &chronos.nodes);}
 
    //not implemented (do an infinite search instead)
    if (strstr(command, "mate")) {chronos.flags |= FMATE; chronos.flags |= FINFINITE; sscanf(strstr(command, "mate"), "%*s %d", &chronos.mate);}
 
    if (strstr(command, "movetime")) {chronos.flags |= FMOVETIME; sscanf(strstr(command, "movetime"), "%*s %d", &chronos.movetime);}
 
    if (chronos.flags == 0) chronos.flags |= FINFINITE;
}
 
int time_uci_ponderhit() {
    if (task != TASK_PONDER) return 0;
 
    /* switch from pondering mode to normal search */
    chronos.flags &= ~FINFINITE;
    sd.starttime = gettime();
    task = TASK_SEARCH;
 
    return 0;
}
 
void time_xboard_go() {
 
    time_over = false;
    task = TASK_SEARCH;
 
    if (!chronos.flags) chronos.flags = FINFINITE;
}
 
void time_nothing_go() {
 
    time_over = false;
    task = TASK_SEARCH;
}
 
void time_calc_movetime() {
 
    /* no movetime to be calculated in these search types */
 
    if (chronos.flags & (FINFINITE | FDEPTH | FNODES)) return;
 
    /* if the movetime is given */
 
    if (chronos.flags & FMOVETIME) {
        if (chronos.movetime > TIMEBUFFER) {
            sd.movetime = chronos.movetime - TIMEBUFFER;
        } else {
            sd.movetime = -1;
        }
        return;
    }
 
    /* in any other case we are given an ordinary timecontrol 
       (time + opt. movestogo + opt. incremental) 
 
        we take the total time left (chronos.time[sd.myside]), divide it
        by the number of moves that are still to play (chronos.movestogo)
        and we have the allowed time per move.
        If we are given an incremental time control, we consider this 
        here as well.
 
        In case we are not told how many moves we are supposed to play
        with the time left, we assume a constant. This results in a 
        slower play in the beginning and more rapid towards the end.
 
        as a little buffer we always assume that there are more moves
        to be played than we actually have to. This should avoid loosing on time.
    */
 
    sd.movetime = 0;
    int movestogo = MOVESTOGO;
    if (chronos.flags & FMOVESTOGO) movestogo = chronos.movestogo + 2;
 
    if ( chronos.time[sd.myside] < 0 ) chronos.time[sd.myside] = 0;
    if ( chronos.inc[sd.myside]  < 0 ) chronos.inc[sd.myside]  = 0;
 
    if ( chronos.flags & FTIME) sd.movetime += chronos.time[sd.myside] / movestogo;
    if ( chronos.flags & FINC ) sd.movetime += chronos.inc[sd.myside];
 
    if (sd.movetime > TIMEBUFFER) 
        sd.movetime -= TIMEBUFFER;
    else
        sd.movetime = -1;
 
    return;
 
}
 
bool time_stop_root() {
 
    if (time_over) return 1;
 
    /* in the root function we check at the beginning of every iteration, 
       whether we should start calculating another cycle.
    */
 
    /* first check for any new commands (e.g. the stop command, 
        which would set task to TASK_NOTHING)
    */
    com();
    if (task == TASK_NOTHING) return 1;
 
    /* in case we are supposed to search to a certain depth, nodes count, 
        fixed time or infinite, check whether we have finished the task.
    */
 
    if ( chronos.flags & FINFINITE ) return 0;
    if ( chronos.flags & FDEPTH    ) return (sd.depth > chronos.depth);
    if ( chronos.flags & FNODES    ) return (sd.nodes > chronos.nodes);
    if ( chronos.flags & FMOVETIME ) return ((int)(gettime() - sd.starttime) > sd.movetime);
 
    /* none of the other types of search-duration controls were triggered.
        This means we are given an ordinary timecontrol.
 
        Now we ask the question, whether it is worth to search another 
        ply, risk running out of time and having to abort  the search
        or if we should just stop the search now and save the time for
        another move.
 
        based on some tests in average positions (where the hash isn't full yet,
        there are not too many captures - resulting in a longer quiescence search)
        the time for searching a ply is about the duration of the search
        of the previous plies.
 
        So:
        timeused = (gettime() - sd.starttime);
        predictedtime = timeused;
        timeleft = movetime - timeused;
 
        if (predictedtime > timeleft) we stop the search now
 
 
        Simplifying the equations:
        (predictedtime > timeleft)
        ( timeused > (movetime - timeused) )
        ( (timeused * 2) > movetime )
 
    */
 
    return (((int)(gettime() - sd.starttime) * 2) > sd.movetime);
 
}
 
bool time_stop() {
 
    /* time_stop() function is similar to time_stop_root(), only that
        this function is not called every time we reach another ply,
        but every couple thousand nodes. This function is very time
        consuming, so calling it too often will slow down the search.
        Calling it to seldom results in a slower response to input 
        through the console and it might overlook the running out of 
        time in faster games.
    */
 
    if (sd.depth <= 1) return 0;
 
    /* the first few lines are the same as in time_stop_root().
        for more comments see that function
    */
 
    com();
    if (task == TASK_NOTHING) return 1;
 
    if (chronos.flags & FINFINITE) return 0;
    if (chronos.flags & FDEPTH   ) return (sd.depth > chronos.depth);
    if (chronos.flags & FNODES   ) return (sd.nodes > chronos.nodes);
    if (chronos.flags & FMOVETIME) return ((int)(gettime() - sd.starttime) > chronos.movetime );
 
    /* again we are not doing one of the easier to manage time controls
 
        other than the function before we are now already in the middle of
        a search. Actually if our prediction was right, we wouldn't have 
        entered this ply if we weren't able to finish it.
 
        so ( (gettime() - sd.starttime) < movetime ) should always be given.
 
        Anyway there are some situations where our prediction method fails.
        The problem is that should we return true here and stop the search
        a lot of information gathered gets useless, as the different lines
        searched are not verfied.
 
        if possible give in such cases a little overdraft and hope that
        the misprediction was only small
    */
 
    if ((int)(gettime() - sd.starttime) > sd.movetime) {
 
        int movestogo = MOVESTOGO;
        if ( chronos.flags & FMOVESTOGO ) movestogo = chronos.movestogo;
 
        if ( ( movestogo > 5 ) && 
             ( (int)(gettime() - sd.starttime) < (sd.movetime * 2) ) && 
             ( sd.movetime > 5000) ) {
            return 0;
        } else {
            return 1;
        }
 
    }
 
    return 0;
 
}

What links here?

Page	Date Edited
CPW-Engine	Dec 31, 2014
CPW-Engine_chronos	Dec 30, 2014
Time Management	Mar 20, 2018

Up one Level

CPW-Engine_com

Pawel_Koziol — Tue, 30 Dec 2014 18:50:20 GMT

Description

Code

What links here?

Home * Engines * CPW-Engine * com

Description

This part of the engine deals with the communication with the GUI. The supported GUI formats are Xboard and UCI Protocol.

In the initialization process, if the engine is started through a program using one of these protocols, they identify themselves with "xboard" and "uci" respectively. In the com() function the variable mode is then set to store the protocol we communicate with.

com() is always called when the engine wants to check whether there is any new user input. gets(command) copies the input into command and returns true in case there has been a message.

The next step is that the commands get executed. This is now either done in com_xboard() or com_uci() depending on the GUI we are communicating with. Should we be running the engine without any GUI (e.g. through the command window for debugging), that means mode is set to 0, some basic commands get executed in the com() function.

Code

 
#include "stdafx.h"
#include "transposition.h"
 
#include <windows.h>
 
 
enum etask {
    TASK_NOTHING,
    TASK_SEARCH,
    TASK_PONDER
} task = TASK_NOTHING;
 
 
enum eproto {
    PROTO_NOTHING,
    PROTO_XBOARD,
    PROTO_UCI
} mode = PROTO_NOTHING;
 
int debug = 0;
 
int pipe;
HANDLE hstdin;
 
int com_init() {
 
    unsigned long dw;
    hstdin = GetStdHandle(STD_INPUT_HANDLE);
    pipe = !GetConsoleMode(hstdin, &dw);
 
    if (!pipe) {
        SetConsoleMode(hstdin,dw&~(ENABLE_MOUSE_INPUT|ENABLE_WINDOW_INPUT));
        FlushConsoleInputBuffer(hstdin);
    } else {
        setvbuf(stdin,NULL,_IONBF,0);
        setvbuf(stdout,NULL,_IONBF,0);
    }
 
    /* default search settings */
    chronos.movetime = 5000;    
    chronos.flags = FMOVETIME;
 
    printWelcome();
 
    return 0;
}
 
int input() {
 
    unsigned long dw=0;
 
    if (task == TASK_NOTHING) return 1;
 
    if (stdin->_cnt > 0) return 1;
 
    if (pipe) {
        if (!PeekNamedPipe(hstdin, 0, 0, 0, &dw, 0)) return 1;
        return dw;
    } else {
        GetNumberOfConsoleInputEvents(hstdin, &dw);
        if (dw > 1) task = TASK_NOTHING;
    }
 
    return 0;
}
 
 
int com() {
 
    char command[65536];
 
    if (!input()) return 0;
 
    /* unwind the search-stack first */
    if (task == TASK_SEARCH) {
        task = TASK_NOTHING;
        return 0;
    }
 
    gets(command);
 
    switch (mode) {
    case PROTO_XBOARD :    com_xboard(command);  break;
    case PROTO_UCI    :    com_uci(command);     break;
    case PROTO_NOTHING: com_nothing(command); break;
    }
 
    return 0;
}
 
int com_nothing(char * command) {
 
    if (!strcmp(command, "xboard"))                com_xboard(command);
        else if (!strcmp(command, "uci"))        com_uci(command);
        else if (!strncmp(command,"perft", 5))    perft_start(command);
        else if (!strncmp(command,"bench", 5))    util_bench(command);
        else if (!strcmp(command, "eval"))      printEval();
        else if (!strcmp(command, "stat"))      printStats();
        else if (!strcmp(command, "d"))            board_display();
        else if (!strcmp(command, "new"))        board_loadFromFen(STARTFEN);
        else if (!strncmp(command, "pos", 3))    board_loadFromFen(command+4);
        else if (!strcmp(command, "go"))        time_nothing_go();
        else if (!strcmp(command, "quit"))        exit(0);
        else if (!strcmp(command, "help"))        printHelp();
        else if (com_ismove(command) ) {
                if ( algebraic_moves(command) ) 
                   time_nothing_go();
                else
                    printf("Sorry, this is not a legal move\n");
        }
                else if (!strncmp(command, "st", 2)) {
        sscanf(command, "st %d", &chronos.movetime);
        chronos.movetime *= 1000;
        chronos.flags = FMOVETIME;
        }
        else if (!strncmp(command, "sd", 2)) {
        sscanf(command, "sd %d", &chronos.depth);
        chronos.flags = FDEPTH;
        }
        else if (command[0] == '\n')            {}
        else {
            strcat(command, " - UNKNOWN COMMAND (type 'help' for a list of commands)");
            com_send(command);
        }
 
    return 0;
}
 
int com_xboard(char * command) {
 
    if (!strcmp(command, "xboard"))
        mode = PROTO_XBOARD;
 
    if (!strcmp(command, "new"))
        board_loadFromFen(STARTFEN);
 
    else if (!strcmp(command, "force"))
        task = TASK_NOTHING;
 
    else if (!strcmp(command, "white"))
        sd.myside = WHITE;
 
    else if (!strcmp(command, "black"))
        sd.myside = BLACK;
 
    else if (!strncmp(command, "st", 2)) {
        sscanf(command, "st %d", &chronos.movetime);
        chronos.movetime *= 1000;
        chronos.flags = FMOVETIME;
    }
 
    else if (!strncmp(command, "sd", 2)) {
        sscanf(command, "sd %d", &chronos.depth);
        chronos.flags = FDEPTH;
    }
 
    else if (!strncmp(command, "time", 4)) {
        sscanf(command, "time %d", &chronos.time[sd.myside]);
        chronos.flags = FTIME;
    }
 
    else if (!strncmp(command, "otim", 4)) {
        sscanf(command, "otim %d", &chronos.time[!sd.myside]);
        chronos.flags = FTIME;
    }
 
    else if (!strcmp(command, "go"))
        time_xboard_go();
 
    else if (!strcmp(command, "hint")) {
        // hint
    }
 
    else if (!strcmp(command, "undo")) {
        // undo
    }
 
    else if (!strcmp(command, "remove")) {
        // remove
    }
 
    else if (!strcmp(command, "post")) {
        // post
    }
 
    else if (!strcmp(command, "nopost")) {
        // nopost
    }
 
    else if (!strcmp(command, "quit")) {
        exit(0);
    }
 
    else if (com_ismove(command)) {
        algebraic_moves(command);
        time_xboard_go();
    }
 
    return 0;
}
 
 
int com_uci(char * command) {
 
    if (!strcmp(command, "uci")) {
        mode = PROTO_UCI;
 
        com_send("id name CPW-Engine 1.1");
        com_send("id author Computer Chess Wiki");
 
        printf("option name Hash type spin default 64 min 1 max 1024\n");
        // send options
 
        com_send("uciok");
    }
 
    if (!strcmp(command, "isready")) 
        com_send("readyok");
 
    if (!strncmp(command, "setoption", 9)) {
        char name[256];
        char value[256];
 
        sscanf(command, "setoption name %s value %s", &name, &value);
 
        if (!strcmp(name, "Hash")) {
            int val;
            sscanf(value, "%d", &val);
            tt_setsize(val<<20);
            ttpawn_setsize(val<<18);
        }
    }
 
    if (!strcmp(command, "ucinewgame")) {}
 
    if (!strncmp(command, "position", 8)) {
        //position [fen | startpos] [moves ...]
 
        if (!strncmp(command,"position fen",12)) {
            board_loadFromFen(command + 13);
        } else {
            board_loadFromFen("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1");
        }
 
        char * moves = strstr(command, "moves");
        if (moves) algebraic_moves(moves+6);
    }
 
    if (!strncmp(command, "go", 2)) 
        time_uci_go(command);
 
    if (!strncmp(command, "debug", 5)) 
        debug = strcmp(command,"debug off");
 
    if (!strcmp(command, "ponderhit"))
        time_uci_ponderhit();
 
    if (!strcmp(command, "stop"))
        task = TASK_NOTHING;
 
    if (!strcmp(command, "quit"))
        exit(0);
 
    return 0;
}
 
 
int com_send(char * command) {
    printf("%s\n",command);
    return 0;
}
 
int com_sendmove(smove m) {
 
    int promotion = 0;
    char parray[5] = {0,'q','r','b','n'};
 
    char command[20];
    char move[6];
 
    switch (mode) {
    case PROTO_XBOARD: strcpy(command,"move "); break;
    case PROTO_UCI:    strcpy(command,"bestmove "); break;
    default: strcpy(command,"CPW: ");
    }
 
    convert_0x88_a(m.from, move);
    convert_0x88_a(m.to, move+2);
 
    //Promotion piece
    if (m.piece_to != m.piece_from) {
        promotion = m.piece_to;
    }
    move[4] = parray[promotion];
    move[5] = 0;
 
    strcat(command, move);
 
    com_send(command);
 
    /* in xboard and nothing actually do the move on the board */
    if (mode == PROTO_XBOARD || mode == PROTO_NOTHING)
        move_make(m);
 
    return 0;
}
 
int com_ismove(char * command) {
    return (command[0] >= 'a' && command[0] <= 'h' &&
            command[1] >= '1' && command[1] <= '8' &&
            command[2] >= 'a' && command[2] <= 'h' &&
            command[3] >= '1' && command[3] <= '8' &&
            ( command[4] == ' ' || command[4] == '\n' || command[4] == 0 || 
              command[4] == '-' || 
              command[4] == 'q' || command[4] == 'r' || command[4] == 'b' || command[4] == 'n'));
 
 /*************************************************************** 
 *  command[4] might be:                                        *
 *                                                              *
 *  (a) any kind of a blank space                               *
 *    (b) '-' or any other mark used in opening book processing   *
 *    (c) first letter of a name of a promoted piece              *
 ***************************************************************/
}

What links here?

Page	Date Edited
Chess Engine Communication Protocol	Mar 4, 2018
CLI	Jan 20, 2018
CPW-Engine	Dec 31, 2014
CPW-Engine_com	Dec 30, 2014
CPW-Engine_main	Jun 13, 2011
GUI	Mar 16, 2018
UCI	Mar 4, 2018
WinBoard	Mar 4, 2018
XBoard	Jan 21, 2018

Up one Level

CPW-Engine_console_ui

Pawel_Koziol — Tue, 30 Dec 2014 18:39:56 GMT

Home * Engines * CPW-Engine * Console UI

#include "stdafx.h"
 
void printWelcome() {
     printf(" CPW chess engine ");
     printf( VERSION_STRING );
     printf( "\n");
     printf( COMPILE_STRING );
     printf("\n");
     printf(" created by some members of Chessprogramming Wiki \n");
     printf(" http://chessprogramming.wikispaces.com/ \n\n");
     printf(" type 'help' for a list of commands \n\n");
}
 
void printHelp() {
printf("------------------------------------------ \n");
printf("d        =  display current board position \n");
printf("bench n  =  test search speed to depth n \n");
printf("perft n  =  test perft numbers up to depth n \n");
printf("eval     =  display evaluation details \n");
printf("stat     =  display search statistics \n");
printf("go       =  play for the side to move \n");
printf("new      =  start a new game \n");
printf("sd n     =  set search depth to n plies \n");
printf("st n     =  set search time to n seconds \n");
printf("quit     =  exit CPW engine \n");
printf("\n");
printf("Please enter moves in algebraic notation (e2e4 d7d5 e4d5 d8d5 ... b7b8q) \n");
printf("or better use a GUI compliant with the UCI protocol \n");
printf("------------------------------------------ \n");
}
 
void printStats() {
    U64 nodes = sd.nodes + (sd.nodes == 0);
 
    printf("-----------------------------\n");
    printf("Nodes       : %d \n", sd.nodes);
    printf("Quiesc nodes: %d \n", sd.q_nodes);
    printf("Ratio       : %d %\n", sd.q_nodes * 100 / nodes);
    printf("-----------------------------\n");
}
 
void printSearchHeader() {
       printf("-------------------------------------------------------\n");
     printf( "ply      nodes   time score pv\n");
     printf("-------------------------------------------------------\n");
}

What links here?

Page	Date Edited
CPW-Engine	Dec 31, 2014
CPW-Engine_console_ui	Dec 30, 2014

Up one Level

CPW-Engine_eval

neurocore — Wed, 27 Jul 2016 04:38:57 GMT

Description

Code

What links here?

Home * Engines * CPW-Engine * Eval

Description

Using this evaluation function CPW-Engine should be aware of the following principles:
1) develop the pieces
2) castle if possible
3) need some minimal level of assistance to disrupt its own castling position
4) care for doubled, weak and passed pawns
5) know a thing or two about the changes of piece values as pawns dissappear
6) try to attack squares around enemy king

For function definitions, see CPW-Engine_eval_h

Code

#include "stdafx.h"
#include "0x88_math.h"
#include "eval.h"
#include "transposition.h"
 
/* adjustements of piece value based on the number of own pawns */
int knight_adj[9] = { -20, -16, -12, -8, -4,  0,  4,  8, 12};
int rook_adj[9] =   {  15,  12,   9,  6,  3,  0, -3, -6, -9};
 
static const int SafetyTable[100] = {
    0,  0,   1,   2,   3,   5,   7,   9,  12,  15,
  18,  22,  26,  30,  35,  39,  44,  50,  56,  62,
  68,  75,  82,  85,  89,  97, 105, 113, 122, 131,
 140, 150, 169, 180, 191, 202, 213, 225, 237, 248,
 260, 272, 283, 295, 307, 319, 330, 342, 354, 366,
 377, 389, 401, 412, 424, 436, 448, 459, 471, 483,
 494, 500, 500, 500, 500, 500, 500, 500, 500, 500,
 500, 500, 500, 500, 500, 500, 500, 500, 500, 500,
 500, 500, 500, 500, 500, 500, 500, 500, 500, 500,
 500, 500, 500, 500, 500, 500, 500, 500, 500, 500
};
 
/*******************************************************************
*  This struct holds data about certain aspects of evaluation,     *
*  which allows program to print them if desired.                  *
*******************************************************************/
 
struct eval_vector {
int gamePhase;
int mgMob[2];
int egMob[2];
int attCnt[2];
int attWeight[2];
int kingShield[2];
int MaterialAdjustement[2];
int Blockages[2];
int PositionalThemes[2];
} v;
 
int eval( int alpha, int beta, int use_hash ) {
    int result = 0, mgScore = 0, egScore = 0;
    int stronger, weaker;
 
    /***********************************************************
    /  Probe the evaluatinon hashtable, unless we call eval()  /
    /  only in order to display detailed result                /
    ***********************************************************/
 
    int probeval = tteval_probe();
    if (probeval != INVALID && use_hash)
        return probeval;
 
    /***********************************************************
    /  Clear all eval data                                     /
    ***********************************************************/
 
    v.gamePhase = 0;
    v.mgMob[WHITE] = 0;      v.mgMob[BLACK] = 0;
    v.egMob[WHITE] = 0;      v.egMob[BLACK] = 0;
    v.attCnt[WHITE] = 0;     v.attCnt[BLACK] = 0;
    v.attWeight[WHITE] = 0;  v.attWeight[BLACK] = 0;
    v.MaterialAdjustement[WHITE] = 0; v.MaterialAdjustement[BLACK] = 0;
    v.Blockages[WHITE] = 0; v.Blockages[BLACK] = 0;
    v.PositionalThemes[WHITE] = 0; v.PositionalThemes[BLACK] = 0;
    v.kingShield[WHITE] = 0; v.kingShield[BLACK] = 0;
 
    /* sum the incrementally counted material and pcsq values */
    mgScore = b.PieceMaterial[WHITE] + b.PawnMaterial[WHITE] + b.PcsqMg[WHITE]
            - b.PieceMaterial[BLACK] - b.PawnMaterial[BLACK] - b.PcsqMg[BLACK];
    egScore = b.PieceMaterial[WHITE] + b.PawnMaterial[WHITE] + b.PcsqEg[WHITE]
            - b.PieceMaterial[BLACK] - b.PawnMaterial[BLACK] - b.PcsqEg[BLACK];
 
    /* add king's pawn shield score and evaluate part of piece blockage score
    (the rest of the latter will be done via piece eval) */
    v.kingShield[WHITE] = wKingShield();
    v.kingShield[BLACK] = bKingShield();
    blockedPieces();
    mgScore += (v.kingShield[WHITE] - v.kingShield[BLACK]);
 
    /* tempo bonus */
    if ( b.stm == WHITE ) result += e.TEMPO;
    else                  result -= e.TEMPO;
 
    /*******************************************************************
    * Adjusting material value for the various combinations of pieces. *
    * Currently it scores bishop, knight and rook pairs. The first one *
    * gets a bonus, the latter two - a penalty. Please also note that  *
    * adjustements of knight and rook value based on the number of own *
    * pawns on the board are done within the piece-specific routines.  *
    *******************************************************************/
 
     if ( b.PieceCount[WHITE][BISHOP] > 1 ) result += e.BISHOP_PAIR;
     if ( b.PieceCount[BLACK][BISHOP] > 1 ) result -= e.BISHOP_PAIR;
     if ( b.PieceCount[WHITE][KNIGHT] > 1 ) result -= e.P_KNIGHT_PAIR;
     if ( b.PieceCount[BLACK][KNIGHT] > 1 ) result += e.P_KNIGHT_PAIR;
     if ( b.PieceCount[WHITE]  [ROOK] > 1 ) result -= e.P_ROOK_PAIR;
     if ( b.PieceCount[BLACK]  [ROOK] > 1 ) result += e.P_ROOK_PAIR;
 
     result += getPawnScore();
 
    /*******************************************************************
    *  Evaluate pieces                                                 *
    *******************************************************************/
 
   for (U8 row=0; row < 8; row++)
   for (U8 col=0; col < 8; col++) {
 
       S8 sq = SET_SQ(row, col);
 
       if ( b.color[sq] != COLOR_EMPTY ) {
           switch (b.pieces[sq]) {
           case PAWN: // pawns are evaluated separately
           break;
           case KNIGHT:
              EvalKnight(sq, b.color[sq]);
              break;
           case BISHOP:
              EvalBishop(sq, b.color[sq]);
              break;
           case ROOK:
               EvalRook(sq, b.color[sq]);
               break;
           case QUEEN:
               EvalQueen(sq, b.color[sq]);
               break;
           case KING:
               break;
       }
     }
   }
 
   /********************************************************************
   *  Merge midgame and endgame score. We interpolate between these    *
   *  two values, using a gamePhase value, based on remaining piece    *
   *  material on both sides. With less pieces, endgame score beco-    *
   *  mes more influential.                                            *
   ********************************************************************/
 
   mgScore += (v.mgMob[WHITE] - v.mgMob[BLACK]);
   egScore += (v.egMob[WHITE] - v.egMob[BLACK]);
   if (v.gamePhase > 24) v.gamePhase = 24;
   int mgWeight = v.gamePhase;
   int egWeight = 24 - mgWeight;
   result += ( (mgScore * mgWeight) + (egScore * egWeight) ) / 24;
 
   /********************************************************************
   *  Add phase-independent score components.                          *
   ********************************************************************/
 
   result += (v.Blockages[WHITE] - v.Blockages[BLACK]);
   result += (v.PositionalThemes[WHITE] - v.PositionalThemes[BLACK]);
   result += (v.MaterialAdjustement[WHITE] - v.MaterialAdjustement[BLACK]);
 
   /********************************************************************
    *  Merge king attack score. We don't apply this value if there are *
    *  less than two attackers or if the attacker has no queen.        *
    *******************************************************************/
 
   if (v.attCnt[WHITE] < 2 || b.PieceCount[WHITE][QUEEN] == 0) v.attWeight[WHITE] = 0;
   if (v.attCnt[BLACK] < 2 || b.PieceCount[BLACK][QUEEN] == 0) v.attWeight[BLACK] = 0;
   result += SafetyTable[v.attWeight[WHITE]];
   result -= SafetyTable[v.attWeight[BLACK]];
 
   /********************************************************************
   *  Low material correction - guarding against an illusory material  *
   *  advantage. Full blown program should have more such rules,  but  *
   *  the current set ought to be useful enough. Please note that our  *
   *  code  assumes different material values for bishop and  knight.  *
   *                                                                   *
   *  - a single minor piece cannot win                                *
   *  - two knights cannot checkmate bare king                         *
   *  - bare rook vs minor piece is drawish                            *
   *  - rook and minor vs rook is drawish                              *
   ********************************************************************/
 
   if (result > 0) { stronger = WHITE; weaker = BLACK; }
   else               { stronger = BLACK; weaker = WHITE; }
 
   if (b.PawnMaterial[stronger] == 0) {
 
       if (b.PieceMaterial[stronger] < 400) return 0;
 
       if (b.PawnMaterial[weaker] == 0
           && (b.PieceMaterial[stronger] == 2 * e.PIECE_VALUE[KNIGHT]))
           return 0;
 
       if (b.PieceMaterial[stronger] == e.PIECE_VALUE[ROOK]
           && b.PieceMaterial[weaker] == e.PIECE_VALUE[BISHOP]) result /= 2;
 
       if (b.PieceMaterial[stronger] == e.PIECE_VALUE[ROOK]
           && b.PieceMaterial[weaker] == e.PIECE_VALUE[KNIGHT]) result /= 2;
 
       if (b.PieceMaterial[stronger] == e.PIECE_VALUE[ROOK] + e.PIECE_VALUE[BISHOP]
           && b.PieceMaterial[stronger] == e.PIECE_VALUE[ROOK]) result /= 2;
 
       if (b.PieceMaterial[stronger] == e.PIECE_VALUE[ROOK] + e.PIECE_VALUE[KNIGHT]
           && b.PieceMaterial[stronger] == e.PIECE_VALUE[ROOK]) result /= 2;
   }
 
    /*******************************************************************
    *  Finally return the score relative to the side to move.          *
    *******************************************************************/
 
    if ( b.stm == BLACK ) result = -result;
 
    tteval_save(result);
 
    return result;
}
 
void EvalKnight(S8 sq, S8 side) {
     int att = 0;
     int mob = 0;
     int pos;
      v.gamePhase += 1;
 
     if (side == WHITE) {
         switch (sq) {
         case A8: if (isPiece(BLACK, PAWN, A7) || isPiece(BLACK, PAWN, C7)) v.Blockages[WHITE] -= e.P_KNIGHT_TRAPPED_A8; break;
         case H8: if (isPiece(BLACK, PAWN, H7) || isPiece(BLACK, PAWN, F7)) v.Blockages[WHITE] -= e.P_KNIGHT_TRAPPED_A8; break;
         case A7: if (isPiece(BLACK, PAWN, A6) && isPiece(BLACK, PAWN, B7)) v.Blockages[WHITE] -= e.P_KNIGHT_TRAPPED_A7; break;
         case H7: if (isPiece(BLACK, PAWN, H6) && isPiece(BLACK, PAWN, G7)) v.Blockages[WHITE] -= e.P_KNIGHT_TRAPPED_A7; break;
         case C3: if (isPiece(WHITE, PAWN, C2) && isPiece(WHITE, PAWN, D4) && !isPiece(WHITE, PAWN, E4)) v.Blockages[WHITE] -= e.P_C3_KNIGHT; break;
         }
     }
     else
     {
         switch (sq) {
         case A1: if (isPiece(WHITE, PAWN, A2) || isPiece(WHITE, PAWN, C2)) v.Blockages[BLACK] -= e.P_KNIGHT_TRAPPED_A8; break;
         case H1: if (isPiece(WHITE, PAWN, H2) || isPiece(WHITE, PAWN, F2)) v.Blockages[BLACK] -= e.P_KNIGHT_TRAPPED_A8; break;
         case A2: if (isPiece(WHITE, PAWN, A3) && isPiece(WHITE, PAWN, B2)) v.Blockages[BLACK] -= e.P_KNIGHT_TRAPPED_A7; break;
         case H2: if (isPiece(WHITE, PAWN, H3) && isPiece(WHITE, PAWN, G2)) v.Blockages[BLACK] -= e.P_KNIGHT_TRAPPED_A7; break;
         case C6: if (isPiece(BLACK, PAWN, C7) && isPiece(BLACK, PAWN, D5) && !isPiece(BLACK, PAWN, E5)) v.Blockages[BLACK] -= e.P_C3_KNIGHT; break;
         }
     }
 
     /***************************************************************
     *  Material value adjustement based on the no. of own pawns.   *
     *  Knights lose value as pawns disappear.                      *
     ***************************************************************/
 
     v.MaterialAdjustement[side] += knight_adj[b.PieceCount[side][PAWN]];
 
    /****************************************************************
    *  Collect data about mobility and king attacks. This resembles *
    *  move generation code, except that we are just incrementing   *
    *  the counters instead of adding actual moves.                 *
    ****************************************************************/
 
    for (U8 dir=0;dir<8;dir++) {
        pos = sq + vector[KNIGHT][dir];
        if ( IS_SQ(pos) && b.color[pos] != side ) {
           ++mob;
           if ( e.sqNearK[!side] [b.KingLoc[!side] ] [pos] )
               ++att; // this knight is attacking zone around enemy king
        }
    }
 
    /****************************************************************
    *  Evaluate mobility. We try to do it in such a way             *
    *  that  zero represents average mobility, but  our             *
    *  formula of doing so is a puer guess.                         *
    ****************************************************************/
 
    v.mgMob[side] += 4 * (mob-4);
    v.egMob[side] += 4 * (mob-4);
 
    /****************************************************************
    *  Save data about king attacks                                 *
    ****************************************************************/
 
    if (att) {
       v.attCnt[side]++;
       v.attWeight[side] += 2 * att;
    }
}
 
void EvalBishop(S8 sq, S8 side) {
     int att = 0;
     int mob = 0;
     v.gamePhase += 1;
 
     if (side == WHITE) {
         switch (sq) {
         case A7: if (isPiece(BLACK, PAWN, B6)) v.Blockages[WHITE] -= e.P_BISHOP_TRAPPED_A7; break;
         case H7: if (isPiece(BLACK, PAWN, G6)) v.Blockages[WHITE] -= e.P_BISHOP_TRAPPED_A7; break;
         case B8: if (isPiece(BLACK, PAWN, C7)) v.Blockages[WHITE] -= e.P_BISHOP_TRAPPED_A7; break;
         case G8: if (isPiece(BLACK, PAWN, F7)) v.Blockages[WHITE] -= e.P_BISHOP_TRAPPED_A7; break;
         case A6: if (isPiece(BLACK, PAWN, B5)) v.Blockages[WHITE] -= e.P_BISHOP_TRAPPED_A6; break;
         case H6: if (isPiece(BLACK, PAWN, G5)) v.Blockages[WHITE] -= e.P_BISHOP_TRAPPED_A6; break;
         case F1: if (isPiece(WHITE, KING, G1)) v.PositionalThemes[WHITE] += e.RETURNING_BISHOP; break;
         case C1: if (isPiece(WHITE, KING, B1)) v.PositionalThemes[WHITE] += e.RETURNING_BISHOP; break;
         }
     }
     else {
         switch (sq) {
         case A2: if (isPiece(WHITE, PAWN, B3)) v.Blockages[BLACK] -= e.P_BISHOP_TRAPPED_A7; break;
         case H2: if (isPiece(WHITE, PAWN, G3)) v.Blockages[BLACK] -= e.P_BISHOP_TRAPPED_A7; break;
         case B1: if (isPiece(WHITE, PAWN, C2)) v.Blockages[BLACK] -= e.P_BISHOP_TRAPPED_A7; break;
         case G1: if (isPiece(WHITE, PAWN, F2)) v.Blockages[BLACK] -= e.P_BISHOP_TRAPPED_A7; break;
         case A3: if (isPiece(WHITE, PAWN, B4)) v.Blockages[BLACK] -= e.P_BISHOP_TRAPPED_A6; break;
         case H3: if (isPiece(WHITE, PAWN, G4)) v.Blockages[BLACK] -= e.P_BISHOP_TRAPPED_A6; break;
         case F8: if (isPiece(BLACK, KING, G8)) v.PositionalThemes[BLACK] += e.RETURNING_BISHOP; break;
         case C8: if (isPiece(BLACK, KING, B8)) v.PositionalThemes[BLACK] += e.RETURNING_BISHOP; break;
         }
     }
 
    /****************************************************************
    *  Collect data about mobility and king attacks                 *
    ****************************************************************/
 
    for (char dir=0;dir<vectors[BISHOP];dir++) {
 
         for (char pos = sq;;) {
 
              pos = pos + vector[BISHOP][dir];
              if (! IS_SQ(pos)) break;
 
              if (b.pieces[pos] == PIECE_EMPTY) {
                 mob++;
                 if ( e.sqNearK[!side] [b.KingLoc[!side] ] [pos] ) ++att;
              }
              else if (b.color[pos] != side) {
                   mob++;
                   if ( e.sqNearK[!side] [b.KingLoc[!side] ] [pos] ) ++att;
                   break;
              }
              else {
                   break;
              }
 
         }
    }
 
    v.mgMob[side] += 3 * (mob-7);
    v.egMob[side] += 3 * (mob-7);
 
    if (att) {
       v.attCnt[side]++;
       v.attWeight[side] += 2*att;
    }
 
 
}
 
void EvalRook(S8 sq, S8 side) {
    int att = 0;
    int mob = 0;
    int ownBlockingPawns = 0;
    int oppBlockingPawns = 0;
    int stepFwd;
    int nextSq;
 
    v.gamePhase += 2;
 
    /***************************************************************
    *  Material value adjustement based on the no. of own pawns.   *
    *  Rooks gain value as pawns disappear.                        *
    ***************************************************************/
 
    v.MaterialAdjustement[side] += rook_adj[b.PieceCount[side][PAWN]];
 
    /***************************************************************
    *  This is an ugly hack to detect open files. Merging it with  *
    *  mobility  eval would have been better, but less  readable,  *
    *  and this is educational program fter all.                   *
    /**************************************************************/
 
    if (side == WHITE) stepFwd = NORTH; else stepFwd = SOUTH;
    nextSq = sq + stepFwd;
 
    while (IS_SQ(nextSq)) {
        if (b.pieces[nextSq] == PAWN) {
            if (b.color[nextSq] == side) {
               ownBlockingPawns++;
               break;
            }
            else
               oppBlockingPawns++;
        }
        nextSq += stepFwd;
    }
 
    /****************************************************************
    *  Evaluate open and half-open files. We merge this bonus with  *
    *  mobility  score.                                             *
    /***************************************************************/
 
    if ( !ownBlockingPawns ) {
 
       if ( !oppBlockingPawns ) {
           v.mgMob[side] += e.ROOK_OPEN;
           v.egMob[side] += e.ROOK_OPEN;
       } else {
           v.mgMob[side] += e.ROOK_HALF;
           v.egMob[side] += e.ROOK_HALF;
       }
    }
 
    /****************************************************************
    *  Collect data about mobility and king attacks                 *
    ****************************************************************/
 
    for (char dir=0; dir<vectors[ROOK]; dir++) {
 
         for (char pos = sq;;) {
 
              pos = pos + vector[ROOK][dir];
              if (! IS_SQ(pos)) break;
 
              if (b.pieces[pos] == PIECE_EMPTY) {
                 mob++;
                 if ( e.sqNearK[!side] [b.KingLoc[!side] ] [pos] ) ++att;
              }
              else if (b.color[pos] != side) {
                   mob++;
                   if ( e.sqNearK[!side] [b.KingLoc[!side] ] [pos] ) ++att;
                   break;
              }
              else {
                   break;
              }
 
         }
    }
 
    v.mgMob[side] += 2 * (mob-7);
    v.egMob[side] += 4 * (mob-7);
 
    if (att) {
       v.attCnt[side]++;
       v.attWeight[side] += 3*att;
    }
 
}
 
void EvalQueen(S8 sq, S8 side) {
    v.gamePhase += 4;
    int att = 0;
    int mob = 0;
 
    /****************************************************************
    *  A queen should not be developed too early                    *
    ****************************************************************/
 
    if (side == WHITE && ROW(sq) > ROW_2) {
        if (isPiece(WHITE, KNIGHT, B1)) v.PositionalThemes[WHITE] -= 2;
        if (isPiece(WHITE, BISHOP, C1)) v.PositionalThemes[WHITE] -= 2;
        if (isPiece(WHITE, BISHOP, F1)) v.PositionalThemes[WHITE] -= 2;
        if (isPiece(WHITE, KNIGHT, G1)) v.PositionalThemes[WHITE] -= 2;
    }
 
    if (side == BLACK && ROW(sq) < ROW_7) {
        if (isPiece(BLACK, KNIGHT, B8)) v.PositionalThemes[BLACK] -= 2;
        if (isPiece(BLACK, BISHOP, C8)) v.PositionalThemes[BLACK] -= 2;
        if (isPiece(BLACK, BISHOP, F8)) v.PositionalThemes[BLACK] -= 2;
        if (isPiece(BLACK, KNIGHT, G8)) v.PositionalThemes[BLACK] -= 2;
    }
 
    /****************************************************************
    *  Collect data about mobility and king attacks                 *
    ****************************************************************/
 
    for (char dir=0;dir<vectors[QUEEN];dir++) {
 
         for (char pos = sq;;) {
 
              pos = pos + vector[QUEEN][dir];
              if (! IS_SQ(pos)) break;
 
              if (b.pieces[pos] == PIECE_EMPTY) {
                 mob++;
                 if ( e.sqNearK[!side] [b.KingLoc[!side] ] [pos] ) ++att;
              }
              else if (b.color[pos] != side) {
                   mob++;
                   if ( e.sqNearK[!side] [b.KingLoc[!side] ] [pos] ) ++att;
                   break;
              }
              else {
                   break;
              }
 
         }
    }
 
    v.mgMob[side] += 1 * (mob-14);
    v.egMob[side] += 2 * (mob-14);
 
    if (att) {
       v.attCnt[side]++;
       v.attWeight[side] += 4*att;
    }
 
}
 
int wKingShield() {
 
    int result = 0;
 
    /* king on the kingside */
    if ( COL(b.KingLoc[WHITE]) > COL_E ) {
 
       if ( isPiece(WHITE, PAWN, F2) )  result += e.SHIELD_1;
       else if ( isPiece(WHITE, PAWN, F3) )  result += e.SHIELD_2;
 
       if ( isPiece(WHITE, PAWN, G2) )  result += e.SHIELD_1;
       else if ( isPiece(WHITE, PAWN, G3) )  result += e.SHIELD_2;
 
       if ( isPiece(WHITE, PAWN, H2) )  result += e.SHIELD_1;
       else if ( isPiece(WHITE, PAWN, H3) )  result += e.SHIELD_2;
   }
 
   /* king on the queenside */
   else if ( COL(b.KingLoc[WHITE]) < COL_D ) {
 
       if ( isPiece(WHITE, PAWN, A2) )  result += e.SHIELD_1;
       else if ( isPiece(WHITE, PAWN, A3) )  result += e.SHIELD_2;
 
       if ( isPiece(WHITE, PAWN, B2) )  result += e.SHIELD_1;
       else if ( isPiece(WHITE, PAWN, B3) )  result += e.SHIELD_2;
 
       if ( isPiece(WHITE, PAWN, C2) )  result += e.SHIELD_1;
       else if ( isPiece(WHITE, PAWN, C3) )  result += e.SHIELD_2;
   }
 
return result;
}
 
int bKingShield() {
    int result = 0;
 
  /* king on the kingside */
  if ( COL(b.KingLoc[BLACK]) > COL_E ) {
        if ( isPiece(BLACK, PAWN, F7) )  result += e.SHIELD_1;
        else if ( isPiece(BLACK, PAWN, F6) )  result += e.SHIELD_2;
 
        if ( isPiece(BLACK, PAWN, G7) )  result += e.SHIELD_1;
        else if ( isPiece(BLACK, PAWN, G6) )  result += e.SHIELD_2;
 
        if ( isPiece(BLACK, PAWN, H7) )  result += e.SHIELD_1;
        else if ( isPiece(BLACK, PAWN, H6) )  result += e.SHIELD_2;
   }
 
   /* king on the queenside */
   else if ( COL(b.KingLoc[BLACK]) < COL_D ) {
       if ( isPiece(BLACK, PAWN, A7) )  result += e.SHIELD_1;
       else if ( isPiece(BLACK, PAWN, A6) )  result += e.SHIELD_2;
 
       if ( isPiece(BLACK, PAWN, B7) )  result += e.SHIELD_1;
       else if ( isPiece(BLACK, PAWN, B6) )  result += e.SHIELD_2;
 
       if ( isPiece(BLACK, PAWN, C7) )  result += e.SHIELD_1;
       else if ( isPiece(BLACK, PAWN, C6) )  result += e.SHIELD_2;
  }
  return result;
}
 
/******************************************************************************
*                            Pawn structure evaluaton                         *
******************************************************************************/
 
int getPawnScore() {
    int result;
 
    /**************************************************************************
    *  This function wraps hashing mechanism around evalPawnStructure().      *
    *  Please note  that since we use the pawn hashtable, evalPawnStructure() *
    *  must not take into account the piece position.  In a more elaborate    *
    *  program, pawn hashtable would contain only the characteristics of pawn *
    *  structure,  and scoring them in conjunction with the piece position    *
    *  would have been done elsewhere.                                        *
    **************************************************************************/
 
    int probeval = ttpawn_probe();
    if (probeval != INVALID)
        return probeval;
 
    result = evalPawnStructure();
 
    ttpawn_save(result);
 
    return result;
}
 
int evalPawnStructure() {
    int result = 0;
 
    for (U8 row = 0; row < 8; row++)
    for (U8 col = 0; col < 8; col++) {
 
       S8 sq = SET_SQ(row, col);
 
       if (b.pieces[sq] == PAWN) {
           if (b.color[sq] == WHITE) result += EvalPawn(sq, WHITE);
           else                      result -= EvalPawn(sq, BLACK);
       }
   }
 
   return result;
}
 
int EvalPawn(S8 sq, S8 side) {
    int result = 0;
    int flagIsPassed = 1; // we will be trying to disprove that
    int flagIsWeak = 1;   // we will be trying to disprove that
    int flagIsOpposed = 0;
 
    int stepFwd, stepBck;
    if (side == WHITE) stepFwd = NORTH; else stepFwd = SOUTH;
    if (side == WHITE) stepBck = SOUTH; else stepBck = NORTH;
    S8 nextSq = sq + stepFwd;
 
    /*************************************************************************
    *   We have only very basic data structures that do not update informa-  *
    *   tion about pawns incrementally, so we have to calculate everything   *
    *   here.  The loop below detects doubled pawns, passed pawns and sets   *
    *   a flag on finding that our pawn is opposed by enemy pawn.            *
    *************************************************************************/
 
    while (IS_SQ(nextSq)) {
 
        if (b.pieces[nextSq] == PAWN) { // either opposed by enemy pawn or doubled
            flagIsPassed = 0;
            if (b.color[nextSq] == side)
                result -= 20;       // doubled pawn penalty
            else
                flagIsOpposed = 1;  // flag our pawn as opposed
        }
 
        if (IS_SQ(nextSq + WEST) && isPiece(!side, PAWN, nextSq + WEST))
            flagIsPassed = 0;
 
        if (IS_SQ(nextSq + EAST) && isPiece(!side, PAWN, nextSq + EAST))
            flagIsPassed = 0;
 
        nextSq += stepFwd;
    }
 
    /*************************************************************************
    *   Another loop, going backwards and checking whether pawn has support. *
    *   Here we can at least break out of it for speed optimization.         *
    *************************************************************************/
 
    nextSq = sq;
    while (IS_SQ(nextSq)) {
 
        if (IS_SQ(nextSq + WEST) && isPiece(side, PAWN, nextSq + WEST)) {
            flagIsWeak = 0;
            break;
        }
 
        if (IS_SQ(nextSq + EAST) && isPiece(side, PAWN, nextSq + EAST)) {
            flagIsWeak = 0;
            break;
        }
 
        nextSq += stepBck;
    }
 
    /*************************************************************************
    *  Evaluate passed pawns, scoring them higher if they are protected      *
    *  or if their advance is supported by friendly pawns                    *
    *************************************************************************/
 
    if ( flagIsPassed ) {
        if ( isPawnSupported(sq, side) ) result += e.protected_passer[side][sq];
        else                             result += e.passed_pawn[side][sq];
    }
 
    /*************************************************************************
    *  Evaluate weak pawns, increasing the penalty if they are situated      *
    *  on a half-open file                                                   *
    *************************************************************************/
 
    if ( flagIsWeak ) {
        result += e.weak_pawn[side][sq];
        if (!flagIsOpposed)
            result -= 4;
    }
 
    return result;
}
 
int isPawnSupported(S8 sq, S8 side) {
    int step;
    if (side == WHITE) step = SOUTH; else step = NORTH;
 
    if ( IS_SQ(sq+WEST) && isPiece(side,PAWN, sq + WEST) ) return 1;
    if ( IS_SQ(sq+EAST) && isPiece(side,PAWN, sq + EAST) ) return 1;
    if ( IS_SQ(sq+step+WEST) && isPiece(side,PAWN, sq + step+WEST ) ) return 1;
    if ( IS_SQ(sq+step+EAST) && isPiece(side,PAWN, sq + step+EAST ) ) return 1;
 
    return 0;
}
 
/******************************************************************************
*                             Pattern detection                               *
******************************************************************************/
 
void blockedPieces() {
 
    // central pawn blocked, bishop hard to develop
    if (isPiece(WHITE, BISHOP, C1) && isPiece(WHITE, PAWN, D2) && b.color[D3] != COLOR_EMPTY)
        v.Blockages[WHITE] -= e.P_BLOCK_CENTRAL_PAWN;
    if (isPiece(WHITE, BISHOP, F1) &&  isPiece(WHITE, PAWN, E2) && b.color[E3] != COLOR_EMPTY)
        v.Blockages[WHITE] -= e.P_BLOCK_CENTRAL_PAWN;
    if (isPiece(BLACK, BISHOP, C8) &&  isPiece(BLACK, PAWN, D7) && b.color[D6] != COLOR_EMPTY)
        v.Blockages[BLACK] -= e.P_BLOCK_CENTRAL_PAWN;
    if (isPiece(BLACK, BISHOP, F8) && isPiece(BLACK, PAWN, E7) && b.color[E6] != COLOR_EMPTY)
        v.Blockages[BLACK] -= e.P_BLOCK_CENTRAL_PAWN;
 
    // uncastled king blocking own rook
    if ( ( isPiece(WHITE, KING, F1) || isPiece(WHITE, KING, G1 ) )&&
         ( isPiece(WHITE, ROOK, H1) || isPiece(WHITE, ROOK, G1 ) )
       )
       v.Blockages[WHITE] -= e.P_KING_BLOCKS_ROOK;
 
    if ( ( isPiece(WHITE, KING, C1) || isPiece(WHITE, KING, B1 ) )&&
         ( isPiece(WHITE, ROOK, A1) || isPiece(WHITE, ROOK, B1 ) )
       )
       v.Blockages[WHITE] -= e.P_KING_BLOCKS_ROOK;
 
    if ( ( isPiece(BLACK, KING, F8) || isPiece(BLACK, KING, G8 ) )&&
         ( isPiece(BLACK, ROOK, H8) || isPiece(BLACK, ROOK, G8 ) )
       )
       v.Blockages[BLACK] -= e.P_KING_BLOCKS_ROOK;
 
    if ( ( isPiece(BLACK, KING, C8) || isPiece(BLACK, KING, B8 ) )&&
         ( isPiece(BLACK, ROOK, A8) || isPiece(BLACK, ROOK, B8 ) )
       )
       v.Blockages[BLACK] -= e.P_KING_BLOCKS_ROOK;
}
 
int isPiece(U8 color, U8 piece, S8 sq) {
    return ( (b.pieces[sq] == piece) && (b.color[sq] == color) );
}
 
/***************************************************************************************
*                             Printing eval results                                    *
***************************************************************************************/
 
void printEval() {
    printf("------------------------------------------\n");
    printf("Total value (for side to move): %d \n", eval(-INF,INF, 0) );
    printf("Material balance    : %d \n", b.PieceMaterial[WHITE] + b.PawnMaterial[WHITE] - b.PieceMaterial[BLACK] - b.PawnMaterial[BLACK] );
    printf("Material adjustement: "); printEvalFactor(v.MaterialAdjustement[WHITE], v.MaterialAdjustement[BLACK]);
    printf("Mg Piece/square tables : "); printEvalFactor(b.PcsqMg[WHITE], b.PcsqMg[BLACK]);
    printf("Eg Piece/square tables : "); printEvalFactor(b.PcsqEg[WHITE], b.PcsqEg[BLACK]);
    printf("Mg Mobility            : "); printEvalFactor(v.mgMob[WHITE], v.mgMob[BLACK]);
    printf("Eg Mobility            : "); printEvalFactor(v.mgMob[WHITE], v.egMob[BLACK]);
    printf("Pawn structure      : %d \n", evalPawnStructure() );
    printf("Blockages           : "); printEvalFactor(v.Blockages[WHITE], v.Blockages[BLACK]);
    printf("Positional themes   : "); printEvalFactor(v.PositionalThemes[WHITE], v.PositionalThemes[BLACK]);
    printf("King Shield         : "); printEvalFactor(v.kingShield[WHITE], v.kingShield[BLACK]);
    printf("Tempo: ");
    if ( b.stm == WHITE ) printf("%d", e.TEMPO); else printf("%d", -e.TEMPO);
    printf("\n");
    printf("------------------------------------------\n");
}
 
void printEvalFactor(int wh, int bl) {
     printf("white %4d, black %4d, total: %4d \n", wh, bl, wh - bl);
}

What links here?

Page	Date Edited
CPW-Engine	Dec 31, 2014
CPW-Engine_eval	Jul 26, 2016
Evaluation	Feb 1, 2018
Evaluation function	Sep 24, 2010
King Safety	Feb 14, 2018
Lazy Evaluation	Sep 1, 2017
Mobility	Jan 17, 2018
Pawn Structure	Oct 2, 2017

Up one Level

CPW-Engine_eval_h

Pawel_Koziol — Tue, 30 Dec 2014 18:56:27 GMT

Home * Engines * CPW-Engine * eval.h

eval.h

 
/* king safety*/
int wKingShield();
int bKingShield();
 
/* pawn structure */
int getPawnScore();
int evalPawnStructure();
int EvalPawn(S8 sq, S8 side);
void EvalKnight(S8 sq, S8 side);
void EvalBishop(S8 sq, S8 side);
void EvalRook(S8 sq, S8 side);
void EvalQueen(S8 sq, S8 side);
int isPawnSupported(S8 sq, S8 side);
int isWPSupported(S8 sq);
int isBPSupported(S8 sq);
 
/* pattern detection */
void blockedPieces();

Up one Level

CPW-Engine_eval_init

Pawel_Koziol — Tue, 30 Dec 2014 18:51:28 GMT

Home * Engines * CPW-Engine * eval_init

Initialization of the evaluation function. This is used once when the program is started and the values are not changed afterwards. Program supports also reading most of the values from a file. Later version might read piece/square tables in the same way, but that is not strictly necessary.

Code

#include "stdafx.h"
#include "0x88_math.h"
 
 
s_eval_data e;
 
// tables used for translating piece/square tables to internal 0x88 representation
 
int index_white[64] = {
    A8, B8, C8, D8, E8, F8, G8, H8,
    A7, B7, C7, D7, E7, F7, G7, H7,
    A6, B6, C6, D6, E6, F6, G6, H6,
    A5, B5, C5, D5, E5, F5, G5, H5,
    A4, B4, C4, D4, E4, F4, G4, H4,
    A3, B3, C3, D3, E3, F3, G3, H3,
    A2, B2, C2, D2, E2, F2, G2, H2,
    A1, B1, C1, D1, E1, F1, G1, H1
};
 
int index_black[64] = {
    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
};
 
int dist_bonus[64][64];
 
/*****************************************************************
*                           PAWN PCSQ                            *
*                                                                *
*  Unlike TSCP, CPW generally doesn't want to advance its pawns  *
*  just for the fun of it. It takes into account the following:  *
*                                                                *
*  - file-dependent component, encouraging program to capture    *
*    towards the center                                          *
*  - small bonus for staying on the 2nd rank                     *
*  - small bonus for standing on a3/h3                           *
*  - penalty for d/e pawns on their initial squares              *
*  - bonus for occupying the center                              *
*****************************************************************/
 
int pawn_pcsq_mg[64] = {
     0,   0,   0,   0,   0,   0,   0,   0,
    -6,  -4,   1,   1,   1,   1,  -4,  -6,
    -6,  -4,   1,   2,   2,   1,  -4,  -6,
    -6,  -4,   2,   8,   8,   2,  -4,  -6,
    -6,  -4,   5,  10,  10,   5,  -4,  -6,
    -4,  -4,   1,   5,   5,   1,  -4,  -4,
    -6,  -4,   1, -24,  -24,  1,  -4,  -6,
     0,   0,   0,   0,   0,   0,   0,   0
};
 
int pawn_pcsq_eg[64] = {
     0,   0,   0,   0,   0,   0,   0,   0,
    -6,  -4,   1,   1,   1,   1,  -4,  -6,
    -6,  -4,   1,   2,   2,   1,  -4,  -6,
    -6,  -4,   2,   8,   8,   2,  -4,  -6,
    -6,  -4,   5,  10,  10,   5,  -4,  -6,
    -4,  -4,   1,   5,   5,   1,  -4,  -4,
    -6,  -4,   1, -24,  -24,  1,  -4,  -6,
     0,   0,   0,   0,   0,   0,   0,   0
};
 
/****************************************************************
*    KNIGHT PCSQ                                                *
*                                                               *
*   - centralization bonus                                      *
*   - penalty for not being developed                           *
****************************************************************/
 
int knight_pcsq_mg[64] = {
    -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,
    -8,   0,   0,   0,   0,   0,   0,  -8,
    -8,   0,   4,   4,   4,   4,   0,  -8,
    -8,   0,   4,   8,   8,   4,   0,  -8,
    -8,   0,   4,   8,   8,   4,   0,  -8,
    -8,   0,   4,   4,   4,   4,   0,  -8,
    -8,   0,   1,   2,   2,   1,   0,  -8,
    -8, -12,  -8,  -8,  -8,  -8, -12,  -8
};
 
int knight_pcsq_eg[64] = {
    -8,  -8,  -8,  -8,  -8,  -8,  -8,  -8,
    -8,   0,   0,   0,   0,   0,   0,  -8,
    -8,   0,   4,   4,   4,   4,   0,  -8,
    -8,   0,   4,   8,   8,   4,   0,  -8,
    -8,   0,   4,   8,   8,   4,   0,  -8,
    -8,   0,   4,   4,   4,   4,   0,  -8,
    -8,   0,   1,   2,   2,   1,   0,  -8,
    -8, -12,  -8,  -8,  -8,  -8, -12,  -8
};
 
 
/****************************************************************
*                BISHOP PCSQ                                    *
*                                                               *
*   - centralization bonus, smaller than for knight             *
*   - penalty for not being developed                           *
*   - good squares on the own half of the board                 *
****************************************************************/
 
int bishop_pcsq_mg[64] = {
    -4,  -4,  -4,  -4,  -4,  -4,  -4,  -4,
    -4,   0,   0,   0,   0,   0,   0,  -4,
    -4,   0,   2,   4,   4,   2,   0,  -4,
    -4,   0,   4,   6,   6,   4,   0,  -4,
    -4,   0,   4,   6,   6,   4,   0,  -4,
    -4,   1,   2,   4,   4,   2,   1,  -4,
    -4,   2,   1,   1,   1,   1,   2,  -4,
    -4,  -4, -12,  -4,  -4, -12,  -4,  -4
};
 
int bishop_pcsq_eg[64] = {
    -4,  -4,  -4,  -4,  -4,  -4,  -4,  -4,
    -4,   0,   0,   0,   0,   0,   0,  -4,
    -4,   0,   2,   4,   4,   2,   0,  -4,
    -4,   0,   4,   6,   6,   4,   0,  -4,
    -4,   0,   4,   6,   6,   4,   0,  -4,
    -4,   1,   2,   4,   4,   2,   1,  -4,
    -4,   2,   1,   1,   1,   1,   2,  -4,
    -4,  -4, -12,  -4,  -4, -12,  -4,  -4
};
 
/****************************************************************
*                        ROOK PCSQ                              *
*                                                               *
*    - bonus for 7th and 8th ranks                              *
*    - penalty for a/h columns                                  *
*    - small centralization bonus                               *
*****************************************************************/
 
int rook_pcsq_mg[64] = {
     5,   5,   5,   5,   5,   5,   5,   5,
    20,  20,  20,  20,  20,  20,  20,  20,
    -5,   0,   0,   0,   0,   0,   0,  -5,
    -5,   0,   0,   0,   0,   0,   0,  -5,
    -5,   0,   0,   0,   0,   0,   0,  -5,
    -5,   0,   0,   0,   0,   0,   0,  -5,
    -5,   0,   0,   0,   0,   0,   0,  -5,
     0,   0,   0,   2,   2,   0,   0,   0
};
 
int rook_pcsq_eg[64] = {
     5,   5,   5,   5,   5,   5,   5,   5,
    20,  20,  20,  20,  20,  20,  20,  20,
    -5,   0,   0,   0,   0,   0,   0,  -5,
    -5,   0,   0,   0,   0,   0,   0,  -5,
    -5,   0,   0,   0,   0,   0,   0,  -5,
    -5,   0,   0,   0,   0,   0,   0,  -5,
    -5,   0,   0,   0,   0,   0,   0,  -5,
     0,   0,   0,   2,   2,   0,   0,   0
};
 
/***************************************************************************
*                     QUEEN PCSQ                                           *
*                                                                          *
* - small bonus for centralization in the endgame                          *
* - penalty for staying on the 1st rank, between rooks in the midgame      *
***************************************************************************/
 
int queen_pcsq_mg[64] = {
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 1, 1, 1, 1, 0, 0,
    0, 0, 1, 2, 2, 1, 0, 0,
    0, 0, 2, 3, 3, 2, 0, 0,
    0, 0, 2, 3, 3, 2, 0, 0,
    0, 0, 1, 2, 2, 1, 0, 0,
    0, 0, 1, 1, 1, 1, 0, 0,
    -5, -5, -5, -5, -5, -5, -5, -5
};
 
int queen_pcsq_eg[64] = {
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 1, 1, 1, 1, 0, 0,
    0, 0, 1, 2, 2, 1, 0, 0,
    0, 0, 2, 3, 3, 2, 0, 0,
    0, 0, 2, 3, 3, 2, 0, 0,
    0, 0, 1, 2, 2, 1, 0, 0,
    0, 0, 1, 1, 1, 1, 0, 0,
    -5, -5, -5, -5, -5, -5, -5, -5
};
 
int king_pcsq_mg[64] = {
    -40, -30, -50, -70, -70, -50, -30, -40,
    -30, -20, -40, -60, -60, -40, -20, -30,
    -20, -10, -30, -50, -50, -30, -10, -20,
    -10,   0, -20, -40, -40, -20,   0, -10,
      0,  10, -10, -30, -30, -10,  10,   0,
     10,  20,   0, -20, -20,   0,  20,  10,
     30,  40,  20,   0,   0,  20,  40,  30,
     40,  50,  30,  10,  10,  30,  50,  40
};
 
int king_pcsq_eg[64] = {
    -72, -48, -36, -24, -24, -36, -48, -72,
    -48, -24, -12,   0,   0, -12, -24, -48,
    -36, -12,   0,  12,  12,   0, -12, -36,
    -24,   0,  12,  24,  24,  12,   0, -24,
    -24,   0,  12,  24,  24,  12,   0, -24,
    -36, -12,   0,  12,  12,   0, -12, -36,
    -48, -24, -12,   0,   0, -12, -24, -48,
    -72, -48, -36, -24, -24, -36, -48, -72
};
 
/*****************************************************************
*                     WEAK PAWNS PCSQ                            *
*                                                                *
*  Current version of CPW-engine does not differentiate between  *
*  isolated  and  backward pawns, using one  generic  cathegory  *
*  of  weak pawns. The penalty is bigger in the center, on  the  *
*  assumption  that  weak  central pawns can be  attacked  from  *
*  many  directions. If the penalty seems too low, please  note  *
*  that being on a semi-open file will come into equation, too.  *
*****************************************************************/
 
int weak_pawn_pcsq[64] = {
      0,   0,   0,   0,   0,   0,   0,   0,
    -10, -12, -14, -16, -16, -14, -12, -10,
    -10, -12, -14, -16, -16, -14, -12, -10,
    -10, -12, -14, -16, -16, -14, -12, -10,
    -10, -12, -14, -16, -16, -14, -12, -10,
     -8, -12, -14, -16, -16, -14, -12, -10,
     -8, -12, -14, -16, -16, -14, -12, -10,
      0,   0,   0,   0,   0,   0,   0,   0
};
 
int passed_pawn_pcsq[64] = {
      0,   0,   0,   0,   0,   0,   0,   0,
    100, 100, 100, 100, 100, 100, 100, 100,
     80,  80,  80,  80,  80,  80,  80,  80,
     60,  60,  60,  60,  60,  60,  60,  60,
     40,  40,  40,  40,  40,  40,  40,  40,
     20,  20,  20,  20,  20,  20,  20,  20,
     20,  20,  20,  20,  20,  20,  20,  20,
      0,   0,   0,   0,   0,   0,   0,   0
};
 
 
void setDefaultEval() {
 
    setBasicValues();
    setSquaresNearKing();
    setPcsq();
    readIniFile();
    correctValues();
}
 
void setBasicValues() {
 
    /********************************************************************************
    *  We use material values by IM Larry Kaufman with additional + 10 for a Bishop *
    *  and only +30 for a Bishop pair                                                 *
    ********************************************************************************/
 
    e.PIECE_VALUE[KING]   = 0;
    e.PIECE_VALUE[QUEEN]  = 975;
    e.PIECE_VALUE[ROOK]   = 500;
    e.PIECE_VALUE[BISHOP] = 335;
    e.PIECE_VALUE[KNIGHT] = 325;
    e.PIECE_VALUE[PAWN]   = 100;
 
    e.BISHOP_PAIR   = 30;
    e.P_KNIGHT_PAIR = 8;
    e.P_ROOK_PAIR   = 16;
 
    /*************************************************
    *  Calculate  the  value  of  piece  material    *
    *  at  the  beginning of  the  game,  which  is  *
    *  used for scaling the king tropism evaluation. *
    *  This  way we don't have to update a constant  *
    *  every time we change material values.         *
    *************************************************/
 
    e.START_MATERIAL = e.PIECE_VALUE[QUEEN]
        + 2 * e.PIECE_VALUE[ROOK]
        + 2 * e.PIECE_VALUE[BISHOP]
        + 2 * e.PIECE_VALUE[KNIGHT];
 
    /*************************************************
    * Values used for sorting captures are the same  *
    * as normal piece values, except for a king.     *
    *************************************************/
 
    for (int i = 0; i < 6; ++i) {
        e.SORT_VALUE[i] = e.PIECE_VALUE[i];
    }
    e.SORT_VALUE[KING] = SORT_KING;
 
    /* trapped and blocked pieces */
 
    e.P_KING_BLOCKS_ROOK   = 24;
    e.P_BLOCK_CENTRAL_PAWN = 24;
    e.P_BISHOP_TRAPPED_A7  = 150;
    e.P_BISHOP_TRAPPED_A6  = 50;
    e.P_KNIGHT_TRAPPED_A8  = 150;
    e.P_KNIGHT_TRAPPED_A7  = 100;
 
    /* minor penalties */
 
    e.P_C3_KNIGHT = 5;
    e.P_NO_FIANCHETTO = 4;
 
    /* king's defence */
    e.SHIELD_1 = 10;
    e.SHIELD_2 = 5;
    e.P_NO_SHIELD = 10;
 
    /* minor bonuses */
 
    e.ROOK_OPEN = 10;
    e.ROOK_HALF = 5;
    e.RETURNING_BISHOP = 20;
    e.FIANCHETTO = 4;
    e.TEMPO = 10;
 
    e.ENDGAME_MAT = 1300;
}
 
void setSquaresNearKing() {
    for (int i = 0; i < 128; ++i)
        for (int j = 0; j < 128; ++j)
        {
 
            e.sqNearK[WHITE][i][j] = 0;
            e.sqNearK[BLACK][i][j] = 0;
 
            if (IS_SQ(i) &&
                IS_SQ(j)) {
 
                // squares constituting the ring around both kings
 
                if (j == i + NORTH || j == i + SOUTH ||
                    j == i + EAST || j == i + WEST ||
                    j == i + NW || j == i + NE ||
                    j == i + SW || j == i + SE) {
 
                    e.sqNearK[WHITE][i][j] = 1;
                    e.sqNearK[BLACK][i][j] = 1;
                }
 
                /* squares in front of the white king ring */
 
                if (j == i + NORTH + NORTH ||
                    j == i + NORTH + NE ||
                    j == i + NORTH + NW)
                    e.sqNearK[WHITE][i][j] = 1;
 
                // squares in front og the black king ring
 
                if (j == i + SOUTH + SOUTH ||
                    j == i + SOUTH + SE ||
                    j == i + SOUTH + SW)
                    e.sqNearK[WHITE][i][j] = 1;
            }
 
        }
}
 
 
void setPcsq() {
 
    for (int i = 0; i < 64; ++i) {
 
        e.weak_pawn[WHITE][index_white[i]] = weak_pawn_pcsq[i];
        e.weak_pawn[BLACK][index_black[i]] = weak_pawn_pcsq[i];
        e.passed_pawn[WHITE][index_white[i]] = passed_pawn_pcsq[i];
        e.passed_pawn[BLACK][index_black[i]] = passed_pawn_pcsq[i];
 
        /* protected passers are considered slightly stronger
        than ordinary passed pawns */
 
        e.protected_passer[WHITE][index_white[i]] = (passed_pawn_pcsq[i] * 10) / 8;
        e.protected_passer[BLACK][index_black[i]] = (passed_pawn_pcsq[i] * 10) / 8;
 
        /* now set the piece/square tables for each color and piece type */
 
        e.mgPst[PAWN][WHITE][index_white[i]] = pawn_pcsq_mg[i];
        e.mgPst[PAWN][BLACK][index_black[i]] = pawn_pcsq_mg[i];
        e.mgPst[KNIGHT][WHITE][index_white[i]] = knight_pcsq_mg[i];
        e.mgPst[KNIGHT][BLACK][index_black[i]] = knight_pcsq_mg[i];
        e.mgPst[BISHOP][WHITE][index_white[i]] = bishop_pcsq_mg[i];
        e.mgPst[BISHOP][BLACK][index_black[i]] = bishop_pcsq_mg[i];
        e.mgPst[ROOK][WHITE][index_white[i]] = rook_pcsq_mg[i];
        e.mgPst[ROOK][BLACK][index_black[i]] = rook_pcsq_mg[i];
        e.mgPst[QUEEN][WHITE][index_white[i]] = queen_pcsq_mg[i];
        e.mgPst[QUEEN][BLACK][index_black[i]] = queen_pcsq_mg[i];
        e.mgPst[KING][WHITE][index_white[i]] = king_pcsq_mg[i];
        e.mgPst[KING][BLACK][index_black[i]] = king_pcsq_mg[i];
 
        e.egPst[PAWN][WHITE][index_white[i]] = pawn_pcsq_eg[i];
        e.egPst[PAWN][BLACK][index_black[i]] = pawn_pcsq_eg[i];
        e.egPst[KNIGHT][WHITE][index_white[i]] = knight_pcsq_eg[i];
        e.egPst[KNIGHT][BLACK][index_black[i]] = knight_pcsq_eg[i];
        e.egPst[BISHOP][WHITE][index_white[i]] = bishop_pcsq_eg[i];
        e.egPst[BISHOP][BLACK][index_black[i]] = bishop_pcsq_eg[i];
        e.egPst[ROOK][WHITE][index_white[i]] = rook_pcsq_eg[i];
        e.egPst[ROOK][BLACK][index_black[i]] = rook_pcsq_eg[i];
        e.egPst[QUEEN][WHITE][index_white[i]] = queen_pcsq_eg[i];
        e.egPst[QUEEN][BLACK][index_black[i]] = queen_pcsq_eg[i];
        e.egPst[KING][WHITE][index_white[i]] = king_pcsq_eg[i];
        e.egPst[KING][BLACK][index_black[i]] = king_pcsq_eg[i];
    }
}
 
/* This function is meant to be used in conjunction with the *.ini file.
Its aim is to make sure that all the assumptions made within the program
are met.  */
 
void correctValues() {
    if (e.PIECE_VALUE[BISHOP] == e.PIECE_VALUE[KNIGHT])
        ++e.PIECE_VALUE[BISHOP];
}
 
void readIniFile() {
    FILE *cpw_init;
    char line[256];
 
    /* if the cpw.ini file does not exist, then exit */
 
    if ((cpw_init = fopen("cpw.ini", "r")) == NULL) {
        printf("Cannot open cpw.ini, default settings will be used \n");
        return;
    }
 
    /* process cpw.ini file line by line */
 
    while (fgets(line, 250, cpw_init)) {
        if (line[0] == ';') continue; // don't process comment lines
        processIniString(line);
    }
}
 
void processIniString(char line[250]) {
 
    /* piece values */
    if (!strncmp(line, "PAWN_VALUE", 10))
        sscanf(line, "PAWN_VALUE %d", &e.PIECE_VALUE[PAWN]);
    else if (!strncmp(line, "KNIGHT_VALUE", 12))
        sscanf(line, "KNIGHT_VALUE %d", &e.PIECE_VALUE[KNIGHT]);
    else if (!strncmp(line, "BISHOP_VALUE", 12))
        sscanf(line, "BISHOP_VALUE %d", &e.PIECE_VALUE[BISHOP]);
    else if (!strncmp(line, "ROOK_VALUE", 10))
        sscanf(line, "ROOK_VALUE %d", &e.PIECE_VALUE[ROOK]);
    else if (!strncmp(line, "QUEEN_VALUE", 11))
        sscanf(line, "QUEEN_VALUE %d", &e.PIECE_VALUE[QUEEN]);
 
    /* piece pairs */
    else if (!strncmp(line, "BISHOP_PAIR", 11))
        sscanf(line, "BISHOP_PAIR %d", &e.BISHOP_PAIR);
    else if (!strncmp(line, "PENALTY_KNIGHT_PAIR", 19))
        sscanf(line, "PENALTY_KNIGHT_PAIR %d", &e.P_KNIGHT_PAIR);
    else if (!strncmp(line, "PENALTY_ROOK_PAIR", 17))
        sscanf(line, "PENALTY_ROOK_PAIR %d", &e.P_KNIGHT_PAIR);
 
    /* pawn shield*/
    else if (!strncmp(line, "SHIELD_1", 8))
        sscanf(line, "SHIELD_1 %d", &e.SHIELD_1);
    else if (!strncmp(line, "SHIELD_2", 8))
        sscanf(line, "SHIELD_2 %d", &e.SHIELD_2);
    else if (!strncmp(line, "PENALTY_NO_SHIELD", 17))
        sscanf(line, "PENALTY_NO_SHIELD %d", &e.P_NO_SHIELD);
 
    /* major penalties */
 
    else if (!strncmp(line, "PENALTY_BISHOP_TRAPPED_A7", 25))
        sscanf(line, "PENALTY_BISHOP_TRAPPED_A7 %d", &e.P_BISHOP_TRAPPED_A7);
    else if (!strncmp(line, "PENALTY_BISHOP_TRAPPED_A6", 25))
        sscanf(line, "PENALTY_BISHOP_TRAPPED_A6 %d", &e.P_BISHOP_TRAPPED_A6);
    else if (!strncmp(line, "PENALTY_KNIGHT_TRAPPED_A8", 25))
        sscanf(line, "PENALTY_KNIGHT_TRAPPED_A8 %d", &e.P_KNIGHT_TRAPPED_A8);
    else if (!strncmp(line, "PENALTY_KNIGHT_TRAPPED_A7", 25))
        sscanf(line, "PENALTY_KNIGHT_TRAPPED_A7 %d", &e.P_KNIGHT_TRAPPED_A7);
    else if (!strncmp(line, "PENALTY_KING_BLOCKS_ROOK", 24))
        sscanf(line, "PENALTY_KNIGHT_TRAPPED_A7 %d", &e.P_KING_BLOCKS_ROOK);
    else if (!strncmp(line, "PENALTY_BLOCKED_CENTRAL_PAWN", 28))
        sscanf(line, "PENALTY_BLOCKED_CENTRAL_PAWN %d", &e.P_BLOCK_CENTRAL_PAWN);
 
    /* minor penalties */
    else if (!strncmp(line, "PENALTY_KNIGHT_BLOCKS_C", 23))
        sscanf(line, "PENALTY_KNIGHT_BLOCKS_C %d", &e.P_C3_KNIGHT);
    else if (!strncmp(line, "PENALTY_NO_FIANCHETTO", 21))
        sscanf(line, "PENALTY_NO_FIANCHETTO %d", &e.P_NO_FIANCHETTO);
 
    /* minor positional bonuses */
 
    else if (!strncmp(line, "ROOK_OPEN", 9))
        sscanf(line, "ROOK_OPEN %d", &e.ROOK_OPEN);
    else if (!strncmp(line, "ROOK_HALF_OPEN", 14))
        sscanf(line, "ROOK_HALF_OPEN %d", &e.ROOK_HALF);
    else if (!strncmp(line, "FIANCHETTO", 10))
        sscanf(line, "FIANCHETTO %d", &e.FIANCHETTO);
    else if (!strncmp(line, "RETURNING_BISHOP", 16))
        sscanf(line, "RETURNING_BISHOP %d", &e.RETURNING_BISHOP);
    else if (!strncmp(line, "TEMPO", 5))
        sscanf(line, "TEMPO %d", &e.TEMPO);
 
    /* variables deciding about inner workings of evaluation function */
 
    else if (!strncmp(line, "ENDGAME_MATERIAL", 16))
        sscanf(line, "ENDGAME_MATERIAL %d", &e.ENDGAME_MAT);
}

Up one Level

CPW-Engine_main

GerdIsenberg — Mon, 13 Jun 2011 18:46:30 GMT

Home * Engines * CPW-Engine * main

The main part of the engine.

Code

header

enum etask {
    TASK_NOTHING,
    TASK_SEARCH
} extern task;

int main()

int main() {
 
    com_init();
 
    while(1) {
 
        if (task == TASK_NOTHING) {
            com();
        } else {
            root();
            task = TASK_NOTHING;
        }
 
    }
 
    return 0;
}

External calls:

What links here?

Page	Date Edited
CPW-Engine	Dec 31, 2014
CPW-Engine_main	Jun 13, 2011

Up one Level

CPW-Engine_move(0x88)

Pawel_Koziol — Tue, 30 Dec 2014 19:09:21 GMT

Home * Engines * CPW-Engine * Move(0x88)

Both move_make and move_unmake call the functions fillSq(color, piece, square) and clearSq(square). They are meant to encapsulate all the incremental updates (material and pcsq calues, hash keys etc.) and can be viewed in CPW-Engine_board(0x88). Ideally this will make both make and unmake functions independent from the board representation. Beside that, incremental update code will be rather long, if not necessarily ugly.

Code

#include "stdafx.h"
#include "transposition.h"
 
int move_makeNull() {
    b.stm = !b.stm;
    b.hash ^= zobrist.color;
    b.ply ++;
    if (b.ep != -1) {
        b.hash ^= zobrist.ep[b.ep];
        b.ep = -1;
    }
    return 0;
}
 
int move_unmakeNull(char ep) {
    b.stm = !b.stm;
    b.hash ^= zobrist.color;
    b.ply --;
    if (ep != -1) {
        b.hash ^= zobrist.ep[ep];
        b.ep = ep;
    }
    return 0;
}
 
int move_make(smove move) {
 
    /* switch the side to move */
    b.stm = !b.stm;
    b.hash ^= zobrist.color;
 
    /* a capture or a pawn move clears b.ply */
    b.ply ++;
    if ( (move.piece_from == PAWN) || move_iscapt(move) )
        b.ply = 0;
 
    /* a piece vacates its initial square */
    clearSq(move.from);
 
    /* in case of a capture, the "to" square must be cleared,
       else incrementally updated stuff gets blown up 
    */
    if ( b.pieces[move.to] != PIECE_EMPTY )
       clearSq(move.to);
 
    /* a piece arrives to its destination square */
    fillSq( !b.stm, move.piece_to, move.to );
 
    /* castle flags
        if either a king or a rook leaves its initial square, the side looses its castling-right.
        The same happens if another piece moves to this square (eg.: captures a rook on its initial square)
    */
    switch (move.from) {
    case H1: b.castle &= ~CASTLE_WK; break;
    case E1: b.castle &= ~(CASTLE_WK|CASTLE_WQ); break;
    case A1: b.castle &= ~CASTLE_WQ; break;
    case H8: b.castle &= ~CASTLE_BK; break;
    case E8: b.castle &= ~(CASTLE_BK|CASTLE_BQ); break;
    case A8: b.castle &= ~CASTLE_BQ; break;
    }
    switch (move.to) {
    case H1: b.castle &= ~CASTLE_WK; break;
    case E1: b.castle &= ~(CASTLE_WK|CASTLE_WQ); break;
    case A1: b.castle &= ~CASTLE_WQ; break;
    case H8: b.castle &= ~CASTLE_BK; break;
    case E8: b.castle &= ~(CASTLE_BK|CASTLE_BQ); break;
    case A8: b.castle &= ~CASTLE_BQ; break;
    }
    b.hash ^= zobrist.castling[move.castle];
    b.hash ^= zobrist.castling[b.castle];
 
    /* castle-move
        in communication with the gui a castling move is represented through 
        the king move. (eg.: e1g1 = White castles short) This king move already
        got executed in the code above with the fillSq() and clearSq() command.
        Whats missing now is the relating rook-move.
    */
    if (move.flags & MFLAG_CASTLE) {
        if (move.to == G1) {
            clearSq(H1);
            fillSq(WHITE,ROOK,F1);
        } 
        else if (move.to == C1) {
            clearSq(A1);
            fillSq(WHITE,ROOK,D1);
        }
        else if (move.to == G8) {
            clearSq(H8);
            fillSq(BLACK,ROOK,F8);
        } 
        else if (move.to == C8) {
            clearSq(A8);
            fillSq(BLACK,ROOK,D8);
        }
    }
 
    /* en-passant flag
        First erase the current state of the ep-flag, then set it again 
        in  case there has been a two square pawn move that allows such
        capture. For example, 1.e4 in the initial position will not set
        the en passant flag, because there are no black pawns on d4 and f4.
        This soluion helps with opening book and increases the number of
        transposition table hits.
    */
    if (b.ep != -1) {
        b.hash ^= zobrist.ep[b.ep];
        b.ep = -1;
    }
    if ( (move.piece_from == PAWN) && ( abs(move.from - move.to) == 32 ) &&
         ( pawnRecapture( !b.stm, (move.from + move.to) / 2 ) ) 
       ) {
        b.ep = (move.from + move.to) / 2;
        b.hash ^= zobrist.ep[b.ep];
    }
 
    /* en-passant capture
        if the move is an en-passant capture, the captured pawn has to be removed manually
    */
    if (move.flags & MFLAG_EPCAPTURE) {
        if (!b.stm == WHITE) {
            clearSq(move.to - 16);
        } else {
            clearSq(move.to + 16);
        }
    }
 
    ++b.rep_index;
    b.rep_stack[b.rep_index] = b.hash;
 
    return 0;
}
 
int move_unmake(smove move) {
 
    b.stm = !b.stm;
    b.hash ^= zobrist.color;
 
    b.ply = move.ply;
 
    /* set en passant square */
    if (b.ep != -1) 
        b.hash ^= zobrist.ep[b.ep];
    if (move.ep != -1) 
        b.hash ^= zobrist.ep[move.ep];
    b.ep = move.ep;
 
    clearSq(move.to);
 
    fillSq(b.stm, move.piece_from, move.from);
 
    /* un-capture
        in case of a capture, put the captured piece back
    */
    if ( move_iscapt(move) )
       fillSq(!b.stm, move.piece_cap, move.to );
 
    /* un-castle
        the king has already been moved, now move the rook
    */
    if (move.flags & MFLAG_CASTLE) {
        if (move.to == G1) {
            clearSq(F1);
            fillSq(WHITE,ROOK,H1);
        } 
        else if (move.to == C1) {
            clearSq(D1);
            fillSq(WHITE,ROOK,A1);
        }
        else if (move.to == G8) {
            clearSq(F8);
            fillSq(BLACK,ROOK,H8);
        } 
        else if (move.to == C8) {
            clearSq(D8);
            fillSq(BLACK,ROOK,A8);
        }
    }
 
    /* adjust castling flags */
    b.hash ^= zobrist.castling[move.castle];
    b.hash ^= zobrist.castling[b.castle];
    b.castle = move.castle;
 
    /* en-passant-uncapture
        put the captured pawn back to its initial square
    */
    if (move.flags & MFLAG_EPCAPTURE) {
        if (b.stm == WHITE) {
            fillSq(BLACK,PAWN,move.to - 16);
        } else {
            fillSq(WHITE,PAWN,move.to + 16);
        }
    }
 
    --b.rep_index;
 
    return 0;
}
 
int move_iscapt(smove m) {
    return (m.piece_cap != PIECE_EMPTY);
}
 
int move_isprom(smove m) {
    return (m.piece_from != m.piece_to);
}
 
int move_canSimplify(smove m) {
    if ( m.piece_cap == PAWN ||
         b.PieceMaterial[!b.stm] - e.PIECE_VALUE[m.piece_cap] > e.ENDGAME_MAT )
        return 0;
    else
        return 1;
}
 
// this function returns number of legal moves in the current position
 
int move_countLegal() {
    smove mlist[256];
    int mcount = movegen(mlist, 0xFF);
    int result = 0;
 
    for (int i = 0; i < mcount; i++) {
 
        // try a move...
        move_make( mlist[i] ); 
 
        // ...then increase the counter if it did not leave us in check
        if ( !isAttacked( b.stm, b.KingLoc[!b.stm] ) ) ++result;
 
        move_unmake(mlist[i]);
    }
 
    return result;
}
 
int move_isLegal(smove m) {
    smove movelist[256];
    int movecount = movegen(movelist, 0xFF);
 
    for (int i = 0; i < movecount; i++) {
        if ( movelist[i].from == m.from && 
             movelist[i].to   == m.to ) {
 
                 int result = 1;
 
                 // test if the move in question leaves us in check
 
                 move_make( movelist[i] );
                 if ( isAttacked( b.stm, b.KingLoc[!b.stm] ) ) result = 0;
                 move_unmake( movelist[i] );
 
                 return result;
           }
    }
 
    return 0;
}

What links here?

Page	Date Edited
0x88	Nov 28, 2016
CPW-Engine	Dec 31, 2014
CPW-Engine_move(0x88)	Dec 30, 2014
CPW-Engine_root	Sep 27, 2008

Up one Level

CPW-Engine_movegen(0x88)

Pawel_Koziol — Tue, 30 Dec 2014 19:07:11 GMT

Home * Engines * CPW-Engine * movegen(0x88)

This page holds the movegenerator of the engine CPW. For function definitions see CPW-Engine_movegen_h.

Current version contains just one move generator with some conditional statements deciding whether we generate a full set of moves, or captures only. This is of course suboptimal, but the speed loss is really small. For that reason we postpone writing a separate capture generator until we are 100% sure about the exact shape of te smove struct, board representation etc.

#include "stdafx.h"
#include "0x88_math.h"
#include "movegen.h"
 
U8 movecount;
 
smove * m;
 
bool slide[5] = { 0, 1, 1, 1, 0 };
char vectors[5] = { 8, 8, 4, 4, 8 };
char vector[5][8] = {
    { SW, SOUTH, SE, WEST, EAST, NW, NORTH, NE },
    { SW, SOUTH, SE, WEST, EAST, NW, NORTH, NE },
    { SOUTH, WEST, EAST, NORTH                 },
    { SW, SE, NW, NE                           },
    { -33, -31, -18, -14, 14, 18, 31, 33       }
    };
 
 
//returns movecount
U8 movegen(smove * moves, U8 tt_move, bool captures) {
 
    m = moves;
 
    movecount = 0;
 
    if (!captures) {
        //Castling
        if ( b.stm == WHITE ) {
            if ( b.castle & CASTLE_WK ) {
                if ( ( b.pieces[F1] == PIECE_EMPTY ) &&
                     ( b.pieces[G1] == PIECE_EMPTY ) &&
                     ( !isAttacked(!b.stm,E1) ) &&
                     ( !isAttacked(!b.stm,F1) ) &&
                     ( !isAttacked(!b.stm,G1) ) )
                    movegen_push(E1,G1,KING,PIECE_EMPTY,MFLAG_CASTLE);
            }
            if ( b.castle & CASTLE_WQ ) {
                if ( ( b.pieces[B1] == PIECE_EMPTY ) &&
                     ( b.pieces[C1] == PIECE_EMPTY ) &&
                     ( b.pieces[D1] == PIECE_EMPTY ) &&
                     ( !isAttacked(!b.stm,E1) ) &&
                     ( !isAttacked(!b.stm,D1) ) &&
                     ( !isAttacked(!b.stm,C1) ) )
                    movegen_push(E1,C1,KING,PIECE_EMPTY,MFLAG_CASTLE);
            }
        } else {
            if ( b.castle & CASTLE_BK ) {
                if ( ( b.pieces[F8] == PIECE_EMPTY ) &&
                     ( b.pieces[G8] == PIECE_EMPTY ) &&
                     ( !isAttacked(!b.stm,E8) ) &&
                     ( !isAttacked(!b.stm,F8) ) &&
                     ( !isAttacked(!b.stm,G8) ) )
                    movegen_push(E8,G8,KING,PIECE_EMPTY,MFLAG_CASTLE);
            }
            if ( b.castle & CASTLE_BQ ) {
                if ( ( b.pieces[B8] == PIECE_EMPTY ) &&
                     ( b.pieces[C8] == PIECE_EMPTY ) &&
                     ( b.pieces[D8] == PIECE_EMPTY ) &&
                     ( !isAttacked(!b.stm,E8) ) &&
                     ( !isAttacked(!b.stm,D8) ) &&
                     ( !isAttacked(!b.stm,C8) ) )
                    movegen_push(E8,C8,KING,PIECE_EMPTY,MFLAG_CASTLE);
            }
        }
    }
 
 
    for (S8 sq=0;sq<120;sq++) {
 
        if (b.color[sq] == b.stm) {
 
            if (b.pieces[sq] == PAWN) {
                movegen_pawn_move(sq, captures);
                movegen_pawn_capt(sq);
            } else {
 
                for (char dir=0;dir<vectors[b.pieces[sq]];dir++) {
 
                    for (char pos = sq;;) {
 
                        pos = pos + vector[b.pieces[sq]][dir];
 
                        if (! IS_SQ(pos)) break;
 
                        if (b.pieces[pos] == PIECE_EMPTY) {
                            if (!captures)
                                movegen_push(sq, pos, b.pieces[sq], PIECE_EMPTY, MFLAG_NORMAL);
                        }
                        else if (b.color[pos] != b.stm) {
                            movegen_push(sq, pos, b.pieces[sq], b.pieces[pos], MFLAG_CAPTURE);
                            break;
                        }
                        else {
                            break;
                        }
 
                        if (! slide[b.pieces[sq]]) break;
                    }
                }
            }
        }
    }
 
    /* if we have a best-move fed into movegen(), then increase its score */
 
    if (  ( tt_move != -1 ) && ( tt_move < movecount ) ) moves[tt_move].score = SORT_HASH;
 
    return movecount;
}
 
U8 movegen_qs(smove * moves) {
 
    m = moves;
 
    movecount = 0;
 
        for (S8 sq=0;sq<120;sq++) {
 
        if (b.color[sq] == b.stm) {
 
            if (b.pieces[sq] == PAWN) {
                movegen_pawn_move(sq, 1);
                movegen_pawn_capt(sq);
            } else {
 
                for (char dir=0;dir<vectors[b.pieces[sq]];dir++) {
 
                    for (char pos = sq;;) {
 
                        pos = pos + vector[b.pieces[sq]][dir];
 
                        if (! IS_SQ(pos)) break;
 
                        if (b.pieces[pos] != PIECE_EMPTY) {
                            if (b.color[pos] != b.stm) {
                                movegen_push(sq, pos, b.pieces[sq], b.pieces[pos], MFLAG_CAPTURE);
                                break;
                            }
                            else break; // hitting own piece
                        }
 
                        if (! slide[b.pieces[sq]]) break;
                    }
                }
            }
        }
    }
 
    return movecount;
}
 
 
void movegen_pawn_move(S8 sq, bool promotion_only) {
 
    if ( b.stm == WHITE ) {
        if (promotion_only && (ROW(sq) < 7)) return;
 
        if (b.pieces[sq+NORTH] == PIECE_EMPTY) {
            movegen_push(sq, sq+NORTH, PAWN, PIECE_EMPTY, MFLAG_NORMAL);
            if ( ( ROW(sq) == 1 ) && 
                 ( b.pieces[sq+NN] == PIECE_EMPTY ) 
               ) {
                movegen_push(sq, sq+NN, PAWN, PIECE_EMPTY, MFLAG_EP);
            }
        }
    } else {
        if (promotion_only && (ROW(sq) > 1)) return;
 
        if (b.pieces[sq+SOUTH] == PIECE_EMPTY) {
            movegen_push(sq, sq+SOUTH, PAWN, PIECE_EMPTY, MFLAG_NORMAL);
            if ( ( ROW(sq) == 6 ) && 
                 ( b.pieces[sq+SS] == PIECE_EMPTY ) 
               ) {
                movegen_push(sq, sq+SS, PAWN, PIECE_EMPTY, MFLAG_EP);
            }
        }
    }
}
 
void movegen_pawn_capt(S8 sq) {
    if (b.stm == WHITE) {
        if (IS_SQ(sq+NW) && ((b.ep==sq+NW) || (b.color[sq+NW] == (b.stm^1)))) {
            movegen_push(sq, sq+NW, PAWN, b.pieces[sq+NW], MFLAG_CAPTURE);
        }
        if (IS_SQ(sq+NE) && ((b.ep==sq+NE) || (b.color[sq+NE] == (b.stm^1)))) {
            movegen_push(sq, sq+17, PAWN, b.pieces[sq+NE], MFLAG_CAPTURE);
        }
    } else {
        if (IS_SQ(sq+SE) && ((b.ep==sq+SE) || (b.color[sq+SE] == (b.stm^1)))) {
            movegen_push(sq, sq+SE, PAWN, b.pieces[sq+SE], MFLAG_CAPTURE);
        }
        if (IS_SQ(sq+SW) && ((b.ep==sq+SW) || (b.color[sq+SW] == (b.stm^1)))) {
            movegen_push(sq, sq+SW, PAWN, b.pieces[sq+SW], MFLAG_CAPTURE);
        }
    }
}
 
 
void movegen_push(char from, char to, U8 piece_from, U8 piece_cap, char flags) {
 
    m[movecount].from = from;
    m[movecount].to = to;
    m[movecount].piece_from = piece_from;
    m[movecount].piece_to = piece_from;
    m[movecount].piece_cap = piece_cap;
    m[movecount].flags = flags;
    m[movecount].ply = b.ply;
    m[movecount].castle = b.castle;
    m[movecount].ep = b.ep;
    m[movecount].id = movecount;
 
    m[movecount].score = sd.history[from][to];
 
    /* score for capture:
        Add the value of the captured piece and the id of the attacking piece.
        So that if two pieces can attack the same target, the one with the higher id (eg. Pawn=5) gets searched first.
    */
    if (piece_cap != PIECE_EMPTY) 
        m[movecount].score = SORT_CAPT + e.SORT_VALUE[piece_cap] + piece_from;
 
    //score for ep-capture
    if ((piece_from == PAWN) && (to == b.ep)) {
        m[movecount].score = SORT_CAPT + e.SORT_VALUE[PAWN] + 5;
        m[movecount].flags = MFLAG_EPCAPTURE;
    }
 
    if ((piece_from == PAWN) && ( (ROW(to)==0)||(ROW(to)==7) )) {
        m[movecount].flags |= MFLAG_PROMOTION;
 
        for (char prompiece = QUEEN; prompiece <= KNIGHT; prompiece++) {
            m[movecount+prompiece-1] = m[movecount];
            m[movecount+prompiece-1].piece_to = prompiece;
            m[movecount+prompiece-1].score += SORT_PROM + e.SORT_VALUE[prompiece];
            m[movecount+prompiece-1].id = movecount+prompiece-1;
        }
        movecount += 3;
    }
 
    movecount++;
 
}
 
void movegen_sort(U8 movecount, smove * m, U8 current) {
 
    //find the move with the highest score - hoping for an early cutoff
 
    int high = current;
 
    for (int i=current+1; i<movecount; i++) {
        if (m[i].score > m[high].score)
            high = i;
    }
 
    smove temp = m[high];
    m[high] = m[current];
    m[current] = temp;
}

What links here?

Page	Date Edited
0x88	Nov 28, 2016
CPW-Engine	Dec 31, 2014
CPW-Engine_movegen(0x88)	Dec 30, 2014
CPW-Engine_root	Sep 27, 2008
Move Generation	Jan 29, 2018
Table-driven Move Generation	Feb 19, 2017

Up one Level

CPW-Engine_movegen_h

Pawel_Koziol — Tue, 30 Dec 2014 19:08:09 GMT

Home * Engines * CPW-Engine * movegen.h

/*********************************************************************
*                              CPW-engine                            *
*           created by some members of Chessprogramming Wiki         *
*                                                                    *
* movegen.h - this file names functions coded within movegen.cpp.    *
* Only movegen() and movegen_sort() are used outside that file.      * 
*********************************************************************/
 
void movegen_push(char from, char to, U8 piece_from, U8 piece_cap, char flags);
void movegen_pawn_move(S8 sq, bool promotion_only);
void movegen_pawn_capt(S8 sq);

Up one Level

CPW-Engine_quiescence

Pawel_Koziol — Tue, 30 Dec 2014 18:57:33 GMT

Home * Engines * CPW-Engine * Quiescence

 
#include "stdafx.h"
#include "0x88_math.h"
 
extern bool time_over;
 
int Quiesce( int alpha, int beta )  {
 
    if ( !time_over && !(sd.nodes & 0x3FF)  )
        time_over = time_stop();
 
    if (time_over) return 0;
 
    sd.nodes++;
    sd.q_nodes++;
 
    /* get a "stand pat" score */
    int val = eval( alpha, beta, 1);
    int stand_pat = val;
 
    /* check if stand-pat score causes a beta cutoff */
    if( val >= beta )
        return beta;            
 
    /* check if stand-pat score may become a new alpha */
    if( alpha < val )
        alpha = val;
 
    /*********************************************************************
    *  We have taken into account rhe stand pat score, and it didn't let *
    *  us  come to a definite conclusion about the position. So we  must *
    *  do a real search.                                                 *
    *********************************************************************/
 
    smove movelist[256];
    U8 mcount = movegen_qs(movelist);
 
    for (U8 i = 0; i < mcount; i++) {
 
        movegen_sort( mcount,movelist, i );
 
        if ( movelist[i].piece_cap == KING ) return INF;
 
        /***************************************************************** 
        *  Delta cutoff - a move guarentees the score well below alpha,  *
        *  so  there's no point in searching it. This heuristic is  not  *
        *  used  in the endgame, because of the  insufficient  material  *
        *  issues and special endgame evaluation heuristics.             *
        *****************************************************************/
 
        if ( ( stand_pat + e.PIECE_VALUE[ movelist[i].piece_cap ] + 200 < alpha ) &&
             ( b.PieceMaterial[!b.stm] - e.PIECE_VALUE[movelist[i].piece_cap] > e.ENDGAME_MAT ) &&
             ( !move_isprom(movelist[i]) ) )
            continue;
 
        /*****************************************************************
        *  badCapture() replaces a cutoff based on the  Static Exchange  *
        *  Evaluation,  marking  the place where it ought to  be  coded. *
        *  Nevertheless, it saves quite a few nodes.                     *
        *****************************************************************/
 
        if ( badCapture( movelist[i] ) 
        &&    !move_canSimplify( movelist[i] ) 
        &&  !move_isprom( movelist[i] )  
           )
           continue;
 
        /*****************************************************************
        *  Cutoffs  misfired, so the move in question can turn out well. *   
        *  Let us try it, then.                                          *
        *****************************************************************/
 
        move_make( movelist[i] );
 
        val = -Quiesce( -beta, -alpha );
 
        move_unmake( movelist[i] );
 
        if (time_over) return 0;
 
        if ( val > alpha ) {
            if( val >= beta )
                return beta;
 
            alpha = val;
        }
    }
    return alpha;
}
 
int badCapture(smove move) {
 
    /* captures by pawn do not lose material */
    if (move.piece_from == PAWN ) return 0;
 
    /* Captures "lower takes higher" (as well as BxN) are good by definition. */
    if ( e.PIECE_VALUE[move.piece_cap] >= e.PIECE_VALUE[move.piece_from] - 50 )
        return 0;
 
    /**************************************************************************
    *   When the enemy piece is defended by a pawn, in the quiescence search  *
    *   we  will  accept rook takes minor, but not minor takes pawn. ( More   *
    *   exact  version  should accept B/N x P if (a) the pawn  is  the  sole  *
    *   defender and (b) there is more than one attacker.                     * 
    **************************************************************************/
 
    if ( pawnRecapture(b.color[move.from], move.to) &&
         e.PIECE_VALUE[move.piece_cap] + 200 - e.PIECE_VALUE[move.piece_from] < 0 )
          return 1;
 
    /* if a capture is not processed, it cannot be considered bad */
    return 0;
}
 
int pawnRecapture( U8 capturers_color, char sq) {
 
    if (capturers_color == WHITE) {
       if ( ( IS_SQ(sq+NW) && isPiece(BLACK, PAWN, sq+NW) ) ||
            ( IS_SQ(sq+NE) && isPiece(BLACK, PAWN, sq+NE) ) )
          return 1;            
    } else {
        if ( ( IS_SQ(sq+SW) && isPiece(WHITE, PAWN, sq+SW) ) ||
                ( IS_SQ(sq+SE) && isPiece(WHITE, PAWN, sq+SE) )  )
          return 1;
    }
    return 0;
}

What links here?

Page	Date Edited
CPW-Engine	Dec 31, 2014
CPW-Engine_quiescence	Dec 30, 2014
Quiescence Search	Aug 19, 2017

Up one Level

CPW-Engine_recognize

Pawel_Koziol — Tue, 30 Dec 2014 18:58:37 GMT

Home * Engines * CPW-Engine * Recognizer

#include "stdafx.h"
 
int is_rim[64] = {
      1,   1,   1,   1,   1,   1,   1,   1,
      1,   0,   0,   0,   0,   0,   0,   1,
      1,   0,   0,   0,   0,   0,   0,   1,
      1,   0,   0,   0,   0,   0,   0,   1,
      1,   0,   0,   0,   0,   0,   0,   1,
      1,   0,   0,   0,   0,   0,   0,   1,
      1,   0,   0,   0,   0,   0,   0,   1,
      1,   1,   1,   1,   1,   1,   1,   1
};
 
 
/* please note that this recognizer assumes that the position is legal, 
   i.e. side to move is not in check */
 
int isDraw() {
 
    /* no pawns */
    if (!b.PawnMaterial[WHITE] && !b.PawnMaterial[BLACK] ) {
 
        /* both sides have at most one minor piece - to guard against the possibility 
           of a helpmate in the corner, we do not claim an immediate draw if the king
           of the weaker side stands on the edge of the board */
 
        if ( b.PieceMaterial[WHITE] < 400 &&
             b.PieceMaterial[BLACK] < 400 &&
             ( !is_rim[b.KingLoc[WHITE] ] || b.PieceMaterial[BLACK] == 0 ) &&
             ( !is_rim[b.KingLoc[BLACK] ] || b.PieceMaterial[WHITE] == 0 )    
        )
        return 1;
 
    }
 
    /* default: no draw spotted */
    return 0;
}

What links here?

Page	Date Edited
CPW-Engine	Dec 31, 2014
CPW-Engine_recognize	Dec 30, 2014
Interior Node Recognizer	Mar 12, 2018

Up one Level

CPW-Engine_root

GerdIsenberg — Sat, 27 Sep 2008 13:39:35 GMT

Header

Home * Engines * CPW-Engine * Root

Header

/* this structure is meant to include data determining performance
   of the search routine, such as timing method, available time
   or depth, as well as boolean flags for additional heuristics
*/
 
struct sSearchDriver {
       int DEPTH;
};
extern sSearchDriver d;
 
/* this structure contains some statistical data about current search */
 
struct sSearchStat {
       int nodes;
       int qnodes;
}
extern sSearchStat stat;

#include "stdafx.h"

#define MAX_DEPTH 100
#define LEAVES_IN_TT 1

/* symbols used to enhance readability */
#define DO_NULL    1
#define NO_NULL    0
#define IS_PV      1
#define NO_PV      0

sSearchDriver sd;

int contempt = 0;

bool time_over = 0;

 
enum ettflag {
 TT_EXACT,
 TT_ALPHA,
 TT_BETA
};

enum eproto {
 PROTO_NOTHING,
 PROTO_XBOARD,
 PROTO_UCI
} extern mode;

 
int search() {
 int in_check;
 
    smove m[256];
 int bestmove = -1;
 int val = 0;
 
 ageHistoryTable();
 
 if ( mode == PROTO_NOTHING ) printSearchHeader();

 for (sd.depth=1; sd.depth<=MAX_DEPTH; sd.depth++) {

  if (sd.depth > 1) {
   if (time_over) break;
   if (time_stop_root()) break;
  }

 /* Check  extension is done also at  the  root */

 in_check = isAttacked( !b.stm, p.KingLoc[b.stm] );
 if ( in_check ) ++sd.depth;

  int mcount = movegen(m, bestmove);
 
  int alpha = -INFINITY;
 
  for ( int i = 0; i < mcount; i++ ) {

   movegen_sort(mcount,m,i);

   if ( m[i].piece_cap == PIECE_KING ) {
    alpha = INFINITY;
    bestmove = m[i].id;
   }

   //info_currmove(m[i],i);

   move_make(m[i]);

   /* the "if" line introduces PVS at root */

   if ( i == 0 || -AlphaBeta( sd.depth-1, -alpha-1, -alpha, 1, 0 ) > alpha )
      val = -AlphaBeta(sd.depth-1, -INFINITY, -alpha, 1, 1);

   move_unmake(m[i]);

   if (time_over) break;

   if ( val > alpha ) {
    alpha = val;
    bestmove = m[i].id;

    tt_save( sd.depth, alpha, TT_ALPHA, m[i].id );

    info_pv( val );
   }
 
  }

  tt_save( sd.depth, alpha, TT_EXACT, bestmove );

 int mcount = movegen(m, -1);
 for ( int i=0; i<mcount; i++ ) {
  if ( m[i].id == bestmove )
   com_sendmove( m[bestmove] );
 }
 
    return 0;
}

 
int AlphaBeta( int depth, int alpha, int beta, int can_null, int is_pv ) {
 
 int  val;
 char bestmove;
 char tt_move;
 int  tt_flag = TT_ALPHA;
 int  in_check;
 int  legal_move = 0;
 int  raised_alpha = 0;

 /* Check for timeout */
 
 if ( !time_over && !(sd.nodes & 0x3FF) )
  time_over = time_stop();

 /***************************************************************
 *  Are we in check? If so, extend. It also means that program  *
 *  will never enter quiescence search while in check.          *
 ***************************************************************/

 in_check = ( isAttacked( !b.stm, p.KingLoc[b.stm] ) );
 if ( in_check ) ++depth;

 /***************************************************************
 *  At leaf nodes we do quiescence search (captures only)       *
 *  to make sure that only relatively quiet positions           *
 *  with no hanging pieces will be evaluated.                   *
 ***************************************************************/

    if ( depth == 0 ) {
  val = Quiesce(alpha, beta);

  if ( LEAVES_IN_TT )
   tt_saveLeaf( alpha, beta, val );

  return val;
    }

 sd.nodes ++;

 if ( isRepetition() ) return contempt;

 if ( ( val = tt_probe(depth, alpha, beta, &tt_move) ) != INVALID )
  return val;
 
 /***************************************************************
 *  Here  we introduce  null move pruning. It  means  allowing  *
 *  opponent  to  execute two moves in a row,  i.e.  capturing  *
 *  something  and escaping a recapture. If this cannot  wreck  *
 *  our  position,  then it is so good that there's  no  point  *
 *  in searching further. The flag "can_null" ensures we don't  *
 *  do  two null moves in a row. Null move is not used in  the  *
 *  endgame because of the risk of zugzwang.                    *
 ***************************************************************/

 if ( ( depth > 2) &&
   ( can_null ) &&
   ( eval(alpha, beta) > beta ) &&
   ( p.PieceMaterial[b.stm] > 1300 ) &&
   ( !in_check )  )
    {

  char ep_old = b.ep;
  move_makeNull();
 
  val = -AlphaBeta( depth - 3, -beta, -beta+1, NO_NULL, NO_PV );

  move_unmakeNull(ep_old);

  if ( time_over ) return 0;
  if (val >= beta) return beta;
 }
 /* end of null move code */

 
    smove m[256];
    int mcount = movegen( m, tt_move );
 
#ifdef USE_KILLERS
 /* reorder killer moves */
 for ( int j=1; j<mcount; j++ ) {

  if ( ( m[j].from == sd.killers[depth][1].from ) &&
    ( m[j].to   == sd.killers[depth][1].to   ) &&
    ( m[j].score < SORT_KILL-1 )  // don't lower the move value
   )
   m[j].score = SORT_KILL-1;
 
  if ( ( m[j].from == sd.killers[depth][0].from ) &&
    ( m[j].to   == sd.killers[depth][0].to   ) &&
    ( m[j].score < SORT_KILL )
   )
   m[j].score = SORT_KILL;
 }
#endif

 bestmove = m[0].id;

    /**************************************************
 *  Now it's time to loop through the move list    *
 ***************************************************/
 
 for (int i = 0; i < mcount; i++) {

  movegen_sort( mcount, m, i );

  if ( m[i].piece_cap == PIECE_KING ) return INFINITY;

  // problem: we do this test several times, even though
  // king capture is sorted fist
 
  move_make( m[i] );
 
        /*******************************************************************
  *  The code below introduces principle variation search. It  means *
  *  that once we are in a PV-node (indicated by IS_PV flag) and  we *
  *  have  found a move that raises alpha, we assume that  the  rest *
  *  of moves ought to be refuted. This is done  relatively  cheaply *
  *  by using  a null-window search centered around alpha.  Only  if *
  *  this search fails high, we are forced to do a real one. This is *
  *  not done when the remaining depth is less than 2 plies.         *
  *******************************************************************/

  if (!is_pv || depth < 3) // non-pv node or low depth - don't use pvs
      val = -AlphaBeta( depth-1, -beta, -alpha, DO_NULL, NO_PV );
        else {
           if (!raised_alpha) // alpha isn't raised - full width search
               val = -AlphaBeta( depth-1, -beta, -alpha, DO_NULL, IS_PV );
            else {
               // first try to refute a move - if this fails, do a real search
               if ( -AlphaBeta( depth-1, -alpha-1, -alpha, DO_NULL, NO_PV ) > alpha )
                  val = -AlphaBeta( depth-1, -beta, -alpha, DO_NULL, IS_PV );
           }
        }
 
        move_unmake(m[i]);

  /********************************************************************
  *  If  the  move doesn't return -INFINITY, it means that the King   *
  *  couldn't be captured immediately. So the move was legal. In this *
  *  case we increase the legal_move counter, to look afterwards,     *
  *  whether there were any legal moves on the board at all.          *                                      *
  ********************************************************************/

  legal_move += ( val != -INFINITY );

  if ( time_over ) return 0;
 
        /********************************************************************
  *  Beta cutoff - the position is so good that the score will not    *
  *  be accepted  one ply below.                                      *
  ********************************************************************/

        if ( val >= beta ) {
   bestmove = m[i].id; // bugfix 2008-07-18
   sd.history [m[i].from] [m[i].to] += depth*depth;
 
#ifdef USE_KILLERS
 
   /* if a move isn't a capture, save it as a killer move */
   if ( m[i].piece_cap == PIECE_EMPTY ) {

    /* make sure killer moves are different
       before saving secondary killer move */
    if ( m[i].from != sd.killers[depth][0].from ||
      m[i].to   != sd.killers[depth][0].to
       )
                   sd.killers[depth][1] = sd.killers[depth][0];

    /* save primary killer move */
       sd.killers[depth][0] = m[i];
   }
#endif

   tt_save(depth, beta, TT_BETA, bestmove);
            return beta;
        }
 
  /****************************************************************
  *  We  can  improve  over alpha, so we change the  node  value  *
  *  together with the expected move. Also the raised_alpha flag, *
  *  used to decide about PVS, is set.                            *
  ****************************************************************/
 
 
 
 
if ( val > alpha ) {
   raised_alpha = 1;
   tt_flag = TT_EXACT;
            alpha = val;
   bestmove = m[i].id;
        }
 
    }   // end of looping through the moves

 /* Checkmate and stalemate detection */
 
 if ( !legal_move ) {
  bestmove = -1;

  if ( in_check )
   alpha = -INFINITY + sd.depth - depth;
  else
   alpha = contempt;
 }

 /* tt_save() does not save anything when the search is timed out */
    tt_save( depth, alpha, tt_flag, bestmove );

    return alpha;
}

 
[[code]]
[[code format="cpp"]]
int info_currmove(smove m, int nr) {

 switch(mode) {
 case PROTO_UCI:

  char buffer[64];
  char move[6];

  algebraic_writemove(m,move);
  sprintf(buffer, "info depth %d currmove %s currmovenumber %d", sd.depth, move, nr);

  com_send(buffer);
 }
 return 0;
}

int info_pv( int val ) {
 char buffer[2048];
 char score[10];
 char pv[2048];

 if (abs( val ) < INFINITY - 2000) {
  sprintf( score,"cp %d", val );
 } else {
  //the mating value is returned in moves not plies
  if (val > 0)
   sprintf( score,"mate %d",(INFINITY - val+1)/2 );
  else
   sprintf( score,"mate %d",(-INFINITY - val+1)/2 );
 }

 unsigned int nodes = (unsigned int) sd.nodes;
 unsigned int time = gettime() - sd.starttime + 1;

 util_pv(pv);

    if ( mode == PROTO_NOTHING )
  sprintf(buffer, " %2d. %9d  %5d %5d %s", sd.depth, nodes, time/10, val, pv);
 else
       sprintf(buffer, "info depth %d score %s time %u nodes %u nps %u pv %s", sd.depth, score, time, nodes, countNps(nodes, time), pv);

 com_send(buffer);

 return 0;
}

 
/* this function guards against overflow and allows to display
   correct nps for longer searches. */

unsigned int countNps(unsigned int nodes, unsigned int time) {
    if ( time > 20000 )
  return nodes / (time/1000);
 else
     return (nodes*1000) / time;
}

int isRepetition() {

 for (int i=0; i < b.rep_index; i++) {
  if (b.rep_stack[i] == b.hash)
   return 1;
 }

 return 0;
}

void clearHistoryTable() {
     for (int i = 0; i < 128; i++)
   for (int j = 0; j < 128; j++) {
             sd.history[i][j] = 0;
   }
}

void ageHistoryTable() {
     for (int i = 0; i < 128; i++)
   for (int j = 0; j < 128; j++) {
             sd.history[i][j] = sd.history[i][j] / 8;
   }
}

External calls:

Up one Level

CPW-Engine_search

GerdIsenberg — Sat, 04 Feb 2017 16:20:18 GMT

Forum Posts

What links here?

Home * Engines * CPW-Engine * Search

For function definitions, see CPW-Engine_search_h

Search

#include "stdafx.h"
#include "search.h"
#include "transposition.h"
 
 
#define MAX_DEPTH 100
 
/* symbols used to enhance readability */
#define DO_NULL    1
#define NO_NULL    0
#define IS_PV      1
#define NO_PV      0
 
sSearchDriver sd;
 
int draw_opening = -10; // middlegame draw value
int draw_endgame = 0;   // endgame draw value
int ASPIRATION   = 50;  // size of the aspiration window ( val-ASPITATION, val+ASPIRATION )
 
bool time_over = 0;
 
enum eproto {
    PROTO_NOTHING,
    PROTO_XBOARD,
    PROTO_UCI
} extern mode; 
 
U8 bestmove;         // move id passed between iterations for sorting purposes
smove move_to_make;     // move to be returned when search runs out of time
 
/***************************************************************
*  search_run() is the interface of all the search functions,  *
*  the only function called outside search.cpp. It does some   *
*  preparatory work, and then calls search_iterate();          *
***************************************************************/
 
void search_run() {
 
    if ( chronos.flags & (FTIME | FINC | FMOVESTOGO) ) {
        if ( getBookMove(BOOK_BROAD) ) return;
    }
 
    search_clearDriver(); 
    time_calc_movetime();
    ageHistoryTable();
    if ( mode == PROTO_NOTHING ) printSearchHeader();
 
    search_iterate();
}
 
void search_clearDriver() {
     sd.myside = b.stm;         // remember color - needed in contempt()
     sd.starttime = gettime();
     sd.movetime = 0;
     sd.depth = 0;
 
     // now clear all the statistical data
     sd.nodes = 0;
     sd.q_nodes = 0;
}
 
/**************************************************************
*  search_iterate() calls search_root() with increasing depth *
*  until allocated time is exhausted.                         *
**************************************************************/
 
void search_iterate() {
     int val, temp;
 
    // check the exact number of legal moves in the current position
 
    int move_count = move_countLegal();
 
    // do a full-window 1-ply search to get the first estimate of val 
 
    sd.depth = 1;
    val = search_root( sd.depth, -INF, INF );
 
    // main loop, increasing deph in steps of 1
 
    for (sd.depth=2; sd.depth<=MAX_DEPTH; sd.depth++) {
 
        // breaking conditions - either expired time
        // or just one legal reply and position searched to depth 4
 
        if ( time_stop_root() || time_over  ) break;
        if ( move_count == 1  && sd.depth == 5 ) break;
 
        // this function deals with aspiration window
        val = search_widen(sd.depth, val);
    } 
 
    // after the loop has finished, send the move to the interface
    com_sendmove(move_to_make);
}
 
int search_widen(int depth, int val) {
    int temp = val, 
    alpha = val - 50,
    beta  = val + 50;
 
    temp = search_root(sd.depth, alpha, beta);
    if (temp <= alpha || temp >= beta)
        temp = search_root(sd.depth, -INF, INF);
    return temp;
}
 
int search_root( U8 depth, int alpha, int beta ) {
 
    int flagInCheck;
    smove movelist[256];
    int val = 0;
 
    U8 currmove_legal = 0;
 
    /* Check  extension is done also at  the  root */
 
    flagInCheck = isAttacked( !b.stm, b.KingLoc[b.stm] );
    if ( flagInCheck ) ++depth;
 
    U8 mcount = movegen(movelist, bestmove);
 
    for ( U8 i = 0; i < mcount; i++ ) {
 
        movegen_sort( mcount, movelist, i);
 
        if ( movelist[i].piece_cap == KING ) {
            alpha = INF;
            bestmove = movelist[i].id;
        }
 
        move_make( movelist[i] );
 
        // filter out illegal moves
        if (isAttacked(b.stm, b.KingLoc[!b.stm])) {
            move_unmake( movelist[i] );
            continue; 
        }
 
    //    if ( mode == PROTO_UCI ) 
    //        info_currmove( movelist[i], currmove_legal ); 
 
        currmove_legal ++; 
 
        /* the "if" clause introduces PVS at root */
 
        if ( ( i == 0 ) || 
             ( -Search( depth-1, 0, -alpha-1, -alpha, DO_NULL, NO_PV ) > alpha ) )
           val = -Search(depth-1, 0, -beta, -alpha, DO_NULL, IS_PV );
 
        move_unmake( movelist[i] );
 
        if (time_over) break;
 
        if ( val > alpha ) {
 
           bestmove = movelist[i].id;
            move_to_make = movelist[i];
 
           if ( val > beta ) { // should be >=, see post
              tt_save(depth, beta, TT_BETA, bestmove);
              info_pv( beta );
              return beta;
           }
 
           alpha = val;
           tt_save( depth, alpha, TT_ALPHA, bestmove ); 
 
           info_pv( val );
        } // changing node value finished
    }
 
    tt_save( depth, alpha, TT_EXACT, bestmove ); 
    return alpha;
}
 
int Search( U8 depth, U8 ply, int alpha, int beta, int can_null, int is_pv ) {
 
    int  val = -INF;
    char bestmove;
    char tt_move = INVALID;
    char tt_flag = TT_ALPHA;
    int  flagInCheck;
    int  legal_move = 0;
    int  raised_alpha = 0;
    int  f_prune = 0;
    int  reduction_depth = 0;
    int  moves_tried = 0;
    int  new_depth;
    int  mate_value = INF - ply; // will be used in mate distance pruning
    smove move;
 
    /************************************************************************  
    *  Probably later we will want to probe the transposition table.        *
    *  Tell the cpu to prepare for that event. This is just a minor         *
    *  speed optimization and program would run fine without that.          *
    ************************************************************************/
 
    _mm_prefetch((char *)&tt[b.hash & tt_size], _MM_HINT_NTA);
 
    /************************************************************************
    * Check for timeout. This is quite time-consuming, so we do it only     *
    * every so often. The side effect is that if we want  to limit search   *
    * by number of nodes, it will be slightly inexact.                      *
    ************************************************************************/
 
    if ( !time_over && !(sd.nodes & 4095) )
        time_over = time_stop();
    if ( time_over ) return 0;
 
    /************************************************************************
    * MATE DISTANCE PRUNING - a minor improvement that helps to shave off   *
    * some nodes when the checkmate is near. Basically it prevents looking  *
    * for checkmates taking longer than one we have already found. No Elo   *
    * gain expected, but it's a nice feature. Don't use it at the root,     *
    * since  this code  doesn't return a move, only a value.                *
    ************************************************************************/
 
    if (alpha < -mate_value) alpha = -mate_value;
    if (beta > mate_value - 1) beta = mate_value - 1;
    if (alpha >= beta) return alpha;
 
    /************************************************************************ 
    *  Are we in check? If so, extend. It also means that program will      *
    *  never enter quiescence search while in check.                        *
    ************************************************************************/
 
    flagInCheck = ( isAttacked( !b.stm, b.KingLoc[b.stm] ) );
    if ( flagInCheck ) ++depth;
 
    /************************************************************************ 
    *  At leaf nodes we do quiescence search (captures only) to make sure   *
    *  that only relatively quiet positions with no hanging pieces will be  *
    *  evaluated.                                                           * 
    ************************************************************************/
 
    if ( depth == 0 ) return Quiesce( alpha, beta );            
 
    sd.nodes ++;
 
    if ( isRepetition() ) return contempt();
 
    /************************************************************************
    *  Read the transposition table. We may have already searched current   *
    *  position. If depth was sufficient, then we might use the score       *
    *  of that search. If not, hash move still is expected to be good       *
    *  and should be sorted first.                                          *
    *                                                                       *
    *  NOTE: current implementation is sub-standard, since tt_move is just  *
    *  an index showing move's location on a move list. We should be able   *
    *  to retrieve move without generating full move list instead.          *
    ************************************************************************/
 
    if ( ( val = tt_probe(depth, alpha, beta, &tt_move) ) != INVALID ) {
        // in pv nodes we return only in case of an exact hash hit
        if (!is_pv || (val > alpha && val < beta))
        return val;
    }
 
    /************************************************************************
    * EVAL PRUNING / STATIC NULL MOVE                                       *
    ************************************************************************/
 
    if (depth < 3
        && (!is_pv)
        && (!flagInCheck)
        && (abs(beta - 1) > -INF+100)) 
    {
        int static_eval = eval(alpha, beta, 1);
 
        int eval_margin = 120 * depth;
        if (static_eval - eval_margin >= beta)
            return static_eval - eval_margin;
    }
 
    /************************************************************************ 
    *  Here  we introduce  NULL MOVE PRUNING. It  means  allowing opponent  * 
    *  to execute two moves in a row, i.e. capturing something and escaping *
    *  a recapture. If this cannot  wreck our position, then it is so good  *
    *  that there's  no  point in searching further. The flag "can_null"    *
    *  ensures we don't do  two null moves in a row. Null move is not used  *
    *  in  the endgame because of the risk of zugzwang.                     *
    ************************************************************************/
 
    if ( ( depth > 2) 
    &&     ( can_null ) 
    &&   (!is_pv)
    &&     ( eval(alpha, beta, 1) > beta ) //should be >=, see post
    &&     ( b.PieceMaterial[b.stm] > e.ENDGAME_MAT ) 
    &&     ( !flagInCheck )  ) 
       {
        char ep_old = b.ep;
        move_makeNull();
 
        /******************************************************************** 
        *  We use so-called adaptative null move pruning. Size of reduction *
        *  depends on remaining  depth.                                     *
        ********************************************************************/
 
        char R = 2;
        if ( depth > 6 ) R = 3;
 
        val = -Search( depth - R - 1, ply, -beta, -beta+1, NO_NULL, NO_PV );    
 
        move_unmakeNull(ep_old);
 
        if ( time_over ) return 0;
        if (val >= beta) return beta;
    }
 
    /************************************************************************
    *  Decide  if FUTILITY PRUNING  is  applicable. If we are not in check, *
    *  not searching for a checkmate and eval is below  (alpha - margin),   *
    *  it  might  mean that searching non-tactical moves at  low depths     *
    *  is futile, so we set a flag allowing this pruning.                   *
    ************************************************************************/
 
    int fmargin[4] = {0, 200, 300, 500};
 
    if ( depth <= 3
    &&     !is_pv
    &&     !flagInCheck
    &&     abs(alpha) < 9000
    &&     eval(alpha,beta, 1) + fmargin[depth] <= alpha )
    f_prune = 1;
 
    /* generate moves */
 
    smove movelist[256];
    U8 mcount = movegen( movelist, tt_move );
 
    ReorderMoves( movelist, mcount, ply );
 
    bestmove = movelist[0].id;
 
    /************************************************************************
    *  Now it's time to loop through the move list.                         *
    ************************************************************************/
 
    for (int i = 0; i < mcount; i++) {
 
        movegen_sort( mcount, movelist, i ); // pick the best of untried moves
        move = movelist[i];
        move_make(move);
 
        // filter out illegal moves
        if (isAttacked(b.stm, b.KingLoc[!b.stm])) {
            move_unmake(move);
            continue; 
        }
        moves_tried++;
 
        /********************************************************************
        *  When the futility pruning flag is set, prune moves which do not  *
        *  give  check and do not change material balance.  Some  programs  *
        *  prune insufficient captures as well, but that seems too risky.   *
        ********************************************************************/
 
        if ( f_prune
        &&     legal_move 
        &&  !move_iscapt(move)
        &&    !move_isprom(move) 
        &&  !isAttacked( !b.stm, b.KingLoc[b.stm] )  ) {
                move_unmake(move);
                continue;
        }
 
        reduction_depth = 0;   // this move has not been reduced yet
        new_depth = depth - 1; // decrease depth by one ply
 
        /********************************************************************
        *  Late move reduction. Typically a cutoff occurs on trying one of  *
        *  the first moves. If it doesn't, we are probably in an all-node,  *
        *  which means that all moves will fail low. So we might as well    *
        *  spare some effort, searching to reduced depth. Of course this is *
        *  not a foolproof method, but it works more often than not. Still, *
        *  we  need to exclude certain moves from reduction, in  order  to  *
        *  filter out tactical moves that may cause a late cutoff.          *
        ********************************************************************/
 
        if (!is_pv 
        && new_depth > 3
        && legal_move
        && moves_tried > 3 
        && !isAttacked(!b.stm, b.KingLoc[b.stm])
        && !flagInCheck 
        && (move.from != sd.killers[0][ply].from || move.to != sd.killers[0][ply].to)
        && (move.from != sd.killers[1][ply].from || move.to != sd.killers[1][ply].to)
        && !move_iscapt(move)
        && !move_isprom(move) ) {
 
            /****************************************************************
            * Real programs tend use more advanced formulas to calculate    *
            * reduction depth. Typically they calculate it from both        *  
            * remaining depth and move count. Formula used here is very     *
            * basic and gives only a minimal improvement over uniform       *
            * one ply reduction, and is included for the sake of complete-  *
            * ness only.                                                    *
            ****************************************************************/
 
            reduction_depth = 1; 
            if (moves_tried > 8) reduction_depth += 1; 
 
            new_depth -= reduction_depth;
        }
 
        re_search:
 
        /******************************************************************** 
        *  The code below introduces principal variation search. It  means  *
        *  that once we are in a PV-node (indicated by IS_PV flag) and  we  *
        *  have  found a move that raises alpha, we assume that  the  rest  *
        *  of moves ought to be refuted. This is done  relatively  cheaply  *
        *  by using  a null-window search centered around alpha.  Only  if  *
        *  this search fails high, we are forced repeat it with full window.*
        *                                                                   *
        *  Understanding the shorthand in the first two lines is a bit      *
        *  tricky. If alpha has not been raised, we might be either in      *
        *  a  zero window (scout) node or in an open window (pv)  node,     *
        *  entered after a scout search failed high. In both cases, we      *
        *  need to search with the same alpha, the same beta AND the same   *
        *  node type.                                                       *
        ********************************************************************/
 
        if (!raised_alpha)
            val = -Search(new_depth, ply+1, -beta, -alpha, DO_NULL, is_pv);
        else {
            // first try to refute a move - if this fails, do a real search
            if (-Search(new_depth, ply+1, -alpha - 1, -alpha, DO_NULL, NO_PV) > alpha)
                val = -Search(new_depth, ply+1, -beta, -alpha, DO_NULL, IS_PV);
        }
 
        /********************************************************************
        *  Sometimes reduced search brings us above alpha. This is unusual, *
        *  since we expected reduced move to be bad in first place. It is   *
        *  not certain now, so let's search to the full, unreduced depth.   *
        ********************************************************************/
 
        if (reduction_depth && val > alpha) {
            new_depth += reduction_depth;
            reduction_depth = 0;
            goto re_search;
        }
 
        move_unmake(move);
 
        /******************************************************************** 
        *  If  the  move doesn't return -INF, it means that  the  King      *
        *  couldn't be captured immediately. So the move was legal. In this * 
        *  case we increase the legal_move counter, to look afterwards,     *
        *  whether there were any legal moves on the board at all.          * 
        ********************************************************************/
 
        legal_move += ( val != -INF );
 
        if ( time_over ) return 0;
 
        /******************************************************************** 
        *  We can improve over alpha, so we change the node value together  * 
        *  with  the expected move. Also the raised_alpha flag, needed  to  *
        *  control PVS, is set. In case of a beta cuoff, when our position  *
        *  is  so good that the score will not be accepted one ply before,  *  
        *  we return it immediately.                                        *
        ********************************************************************/ 
 
        if ( val > alpha ) {
 
            bestmove = movelist[i].id;
 
           if ( val >= beta ) {
 
               /*************************************************************
               *  On a quiet move update killer moves and history table     *
               *  in order to enhance move ordering.                        *
               *************************************************************/
 
               if (!move_iscapt(move)
               && !move_isprom(move)) {
                   setKillers(movelist[i], ply);
                   sd.history[move.from][move.to] += depth*depth;
 
                   /********************************************************* 
                   *  With super deep search history table would overflow   *
                   *  - let's prevent it.                                   *
                   *********************************************************/
 
                   if (sd.history[move.from][move.to] > SORT_KILL) {
                       for (int a = 0; a < 128; a++)
                           for (int b = 0; b < 128; b++) {
                               sd.history[a][b] = sd.history[a][b] / 2;
                           }
                   }
               }
               tt_flag = TT_BETA;
               alpha = beta;
               break; // no need to search any further
           }
 
           raised_alpha = 1;
           tt_flag = TT_EXACT;
           alpha = val;
 
        } // changing the node value is finished
 
    }   // end of looping through the moves
 
    /************************************************************************ 
    *  Checkmate and stalemate detection: if we can't find a legal move     *
    *  in the current position, we test if we are in check. If so, mate     *
    *  score relative to search depth is returned. If not, we use  draw     *
    *  evaluation provided by contempt() function.                          *
    ************************************************************************/
 
    if ( !legal_move ) {
        bestmove = -1;
 
        if ( flagInCheck ) alpha = -INF + ply;
        else               alpha = contempt();
    }
 
    /* tt_save() does not save anything when the search is timed out */
    tt_save( depth, alpha, tt_flag, bestmove ); 
 
    return alpha;
}
 
void setKillers(smove m, U8 ply) {
 
    /* if a move isn't a capture, save it as a killer move */
    if ( m.piece_cap == PIECE_EMPTY ) {
 
        /* make sure killer moves will be different 
           before saving secondary killer move */
        if ( m.from != sd.killers[ply][0].from ||
             m.to   != sd.killers[ply][0].to
           )
             sd.killers[ply][1] = sd.killers[ply][0];
 
              /* save primary killer move */
             sd.killers[ply][0] = m;
    }
}
 
void ReorderMoves(smove * m, U8 mcount, U8 ply) {
 
    for ( int j=0; j<mcount; j++ ) {
        if ( ( m[j].from == sd.killers[ply][1].from ) 
         &&      ( m[j].to   == sd.killers[ply][1].to   )
        &&      ( m[j].score < SORT_KILL-1 ) ) {    
               m[j].score = SORT_KILL-1;
        }
 
        if ( ( m[j].from == sd.killers[ply][0].from )
        &&   ( m[j].to   == sd.killers[ply][0].to   )
        &&     ( m[j].score < SORT_KILL ) ) {
               m[j].score = SORT_KILL;
        }
    } 
}
 
int info_currmove(smove m, int nr) {
 
    switch(mode) {
    case PROTO_UCI:
 
        char buffer[64];
        char move[6];
 
        algebraic_writemove(m,move);
        sprintf(buffer, "info depth %d currmove %s currmovenumber %d", sd.depth, move, nr+1);
 
        com_send(buffer);
    }
    return 0;
}
 
int info_pv( int val ) {
    char buffer[2048];
    char score[10];
    char pv[2048];
 
    if (abs( val ) < INF - 2000) {
        sprintf( score,"cp %d", val );
    } else {
        //the mating value is returned in moves not plies ( thats why /2+1)
        if (val > 0) 
            sprintf(score,"mate %d", (INF - val)/2    + 1);
        else
            sprintf(score,"mate %d",-(INF + val)/2 - 1);
    }
 
    U32 nodes = (U32) sd.nodes;
    U32 time = gettime() - sd.starttime;
 
    util_pv(pv);
 
    if ( mode == PROTO_NOTHING )
        sprintf(buffer, " %2d. %9d  %5d %5d %s", sd.depth, nodes, time/10, val, pv);
    else
          sprintf(buffer, "info depth %d score %s time %u nodes %u nps %u pv %s", sd.depth, score, time, nodes, countNps(nodes, time), pv);
 
    com_send(buffer);
 
    return 0;
}
 
/*********************************************************** 
*  countNps() guards against overflow and thus cares  for  *
*  displaying  correct  nps during longer searches.  Node  *
*  count is converted from U64 to unsigned int because of  *
*  some problems with output.                              *
***********************************************************/
 
unsigned int countNps(unsigned int nodes, unsigned int time) {
    if ( time == 0 ) return 0;
 
    if ( time > 20000 )
        return nodes / (time/1000);
    else
        return (nodes*1000) / time;
}
 
/***********************************************************
*  Checking if the current position has been already       *
*  encountered on the current search path. Function        *
*  does NOT check the actual number of repetitions.        *
***********************************************************/
 
int isRepetition() {
 
    for (int i=0; i < b.rep_index; i++) {
        if ( b.rep_stack[i] == b.hash )
            return 1;
    }
 
    return 0;
}
 
/************************************************************
*  Clearing the history table is needed at the beginning    *
*  of a search starting from a new position, like at the    *
*  beginning of a new game.                                 * 
************************************************************/
 
void clearHistoryTable() {
     for (int i = 0; i < 128; i++)
         for (int j = 0; j < 128; j++) {
             sd.history[i][j] = 0;
         }
}
 
/************************************************************
* ageHistoryTable() is run between searches  to  decrease   *
* the  history values used for move sorting. This  causes   *
* obsolete information to disappear gradually. Clearing     *
* the table was worse for the move ordering.                *
************************************************************/
 
void ageHistoryTable() {
     for (int i = 0; i < 128; i++)
         for (int j = 0; j < 128; j++) {
             sd.history[i][j] = sd.history[i][j] / 8;
         }
}
 
/************************************************************
*  contempt() returns a draw value (which may be non-zero)  *
*  relative  to  the side to move and to the  game  stage.  *
*  This  way  we may make our program play for a  draw  or  *
*  strive to avoid it.                                      *
************************************************************/
 
int contempt() {
    int value = draw_opening;
 
    if ( b.PieceMaterial[sd.myside] < e.ENDGAME_MAT )
        value = draw_endgame;
 
    if ( b.stm == sd.myside ) return value;
    else                      return -value;
}

Forum Posts

value > beta by Robert Pope, CCC, June 10, 2015
Static NULL Move by thevinenator, OpenChess Forum, December 26, 2016 » Reverse Futility Pruning
NULL Move code question by thevinenator, OpenChess Forum, January 27, 2017 » Null Move Pruning

What links here?

Page	Date Edited
Alpha-Beta	Jan 28, 2018
Contempt Factor	Mar 10, 2018
CPW-Engine	Dec 31, 2014
CPW-Engine_search	Feb 4, 2017
Null Move Pruning	Dec 2, 2017
Principal Variation Search	Oct 22, 2017
Reverse Futility Pruning	Jun 2, 2017
Robert Pope	Jun 10, 2017

Up one Level

Wikispaces : chessprogramming - items matching description

CPW-Engine_0x88_math

What links here?

CPW-Engine_algebraic

Table of Contents

Description

Code

int convert_0x88_a(sq, a)

int convert_a_0x88(a)

int algebraic_moves(a)

What links here?

CPW-Engine_attacks

Table of Contents

isAttacked

leaperAttack

straightAttack

diagAttack

CPW-Engine_board(0x88)

What links here?

CPW-Engine_book

What links here?

CPW-Engine_book_h

CPW-Engine_chronos

What links here?

CPW-Engine_com

Table of Contents

Description

Code

What links here?

CPW-Engine_console_ui

What links here?

CPW-Engine_eval

Table of Contents

Description

Code

What links here?

CPW-Engine_eval_h

eval.h

CPW-Engine_eval_init

Code

CPW-Engine_main

Table of Contents

Code

header

int main()

What links here?

CPW-Engine_move(0x88)

Code

What links here?

CPW-Engine_movegen(0x88)

What links here?

CPW-Engine_movegen_h

CPW-Engine_quiescence

What links here?

CPW-Engine_recognize

What links here?

CPW-Engine_root

Table of Contents

Header

CPW-Engine_search

Table of Contents

Search

Forum Posts

What links here?