CPW-Engine_utils


 * Home * Engines * CPW-Engine * Utils**

code format="cpp"


 * 1) include "stdafx.h"
 * 2) include "0x88_math.h"
 * 3) include "transposition.h"

enum etask { TASK_NOTHING, TASK_SEARCH, TASK_PONDER } extern task;

extern bool time_over;

unsigned int gettime;

int util_pv(char * pv) {

sboard rootb = b;

char best; smove m[256]; int mcount = 0;

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

best = -1; tt_probe(0,0,0,&best);

if (best == -1) break;

mcount = movegen(m, 0xFF);

for (int i=0; i<mcount; i++) { if (m[i].id == best) { move_make(m[i]);

pv = algebraic_writemove(m[i], pv); pv[0] = ' '; pv++;

break; }		}	}

pv[0] = 0; b = rootb; return 0; }

void perft_start(char * command) {

unsigned int starttime = gettime;

int depth; sscanf(command + 6, "%d", &depth);

printf("Performance Test\n"); for (U8 d=1;d<=depth;d++) { printf("%d:\t%d\t%d\n",d,gettime-starttime,perft(d)); } }

U64 perft(U8 depth) {

U64 nodes = 0; if (depth == 0) return 1; smove m[256]; int mcount = movegen(m, 0xFF); for (int i = 0; i < mcount; i++) { move_make(m[i]);

if (!isAttacked(b.stm, b.KingLoc[!b.stm])) nodes += perft(depth - 1);

move_unmake(m[i]); }

return nodes; }

void util_bench(char * command) {

unsigned int starttime = gettime;

int depth; sscanf(command + 6, "%d", &depth);

time_over = false;

sd.myside = b.stm; sd.starttime = gettime; sd.depth = 0; sd.nodes = 0;

task = TASK_SEARCH;

chronos.depth = depth; chronos.flags = FDEPTH;

search_run;

task = TASK_NOTHING;

if (gettime-starttime < 1000) starttime = gettime - 1000;

printf("Nodes:\t%d\nTime:\t%d ms\nNPS:\t%d\n", (int) sd.nodes, gettime-starttime, (int) sd.nodes / ((gettime-starttime)/1000));

return; }

smove strToMove(char * a) { smove m;

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 = -1; m.ply = 0; m.score = 0;

/* default promotion to queen */

if ( ( m.piece_to == PAWN ) && 		  ( ROW(m.to) == ROW_1 || ROW(m.to) == ROW_8 ) ) m.piece_to = QUEEN;

switch (a[4]) { case 'q': m.piece_to = QUEEN; a++; break; case 'r': m.piece_to = ROOK; a++; break; case 'b': m.piece_to = BISHOP; a++; break; case 'n': m.piece_to = KNIGHT; a++; break; }	 //castling if ((m.piece_from == 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 == PAWN) &&		(m.piece_cap == PIECE_EMPTY) &&		((abs(m.from-m.to)==15)||(abs(m.from-m.to)==17))) { m.flags = MFLAG_EPCAPTURE; }

if ((m.piece_from == PAWN) && (abs(m.from - m.to) == 32)) { m.flags |= MFLAG_EP; }

return m; }

int algebraic_moves(char * a) { smove m;   int found_match = 0; while (a[0]) {

if (!((a[0] >= 'a') && (a[0] <= 'h'))) { a++; continue; }

m = strToMove(a);

found_match = move_isLegal(m);

if ( found_match ) { move_make(m);

if ( ( m.piece_from == PAWN ) || 				( move_iscapt(m) ) || 				( m.flags == MFLAG_CASTLE ) ) b.rep_index = 0;

} else {

break;

}

a += 4; if (a[0] == 0) break; if (a[0] != ' ') a++;

}   return found_match; }

//returns new pointer char * algebraic_writemove(smove m, char * a) { char parray[5] = {0,'q','r','b','n'};

convert_0x88_a(m.from, a); convert_0x88_a(m.to, a+2); a+=4; if (m.piece_to != m.piece_from) { a[0] = parray[m.piece_to]; a++; }	a[0] = 0; return a; }

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

U8 convert_a_0x88(char * a) { S8 sq; sq = a[0] - 'a'; sq += (a[1] - '1') * 16;

return sq; }

code
 * Up one Level**