static void update_best_move_history(position_t *p, int index_of_best,
sortable_move_t* lst, int count) {
tbassert(ENABLE_TABLES, "Tables weren't enabled.\n");
int color_to_move = color_to_move_of(p);
for (int i = 0; i < count; i++) {
move_t mv = get_move(lst[i]);
ptype_t pce = ptype_mv_of(mv);
rot_t ro = rot_of(mv); // rotation
square_t fs = from_square(mv);
int ot = ORI_MASK & (ori_of(p->board[fs]) + ro);
square_t ts = to_square(mv);
int s = best_move_history[BMH(color_to_move, pce, ts, ot)];
if (index_of_best == i) {
s = s + 11200; // number will never exceed 1017
}
s = s * 0.90; // decay score over time
tbassert(s < 102000, "s = %d\n", s); // or else sorting will fail
best_move_history[BMH(color_to_move, pce, ts, ot)] = s;
}
}
// Obtain a sorted move list.
static int get_sortable_move_list(searchNode *node, sortable_move_t * move_list,
int hash_table_move) {
// number of moves in list
int num_of_moves = generate_all_opt(&(node->position), move_list, false);
color_t fake_color_to_move = color_to_move_of(&(node->position));
move_t killer_a = killer[KMT(node->ply, 0)];
move_t killer_b = killer[KMT(node->ply, 1)];
// sort special moves to the front
for (int mv_index = 0; mv_index < num_of_moves; mv_index++) {
move_t mv = get_move(move_list[mv_index]);
if (mv == hash_table_move) {
set_sort_key(&move_list[mv_index], SORT_MASK);
} else if (mv == killer_a) {
set_sort_key(&move_list[mv_index], SORT_MASK - 1);
} else if (mv == killer_b) {
set_sort_key(&move_list[mv_index], SORT_MASK - 2);
} else {
ptype_t pce = ptype_mv_of(mv);
rot_t ro = rot_of(mv); // rotation
square_t fs = from_square(mv);
int ot = ORI_MASK & (ori_of(node->position.board[fs]) + ro);
square_t ts = to_square(mv);
set_sort_key(&move_list[mv_index],
best_move_history[BMH(fake_color_to_move, pce, ts, ot)]);
}
}
return num_of_moves;
}
// -----------------------------------------------------------------------------
// searchRoot
//
// This handles scout search logic for the first level of the search tree
// -----------------------------------------------------------------------------
static void initialize_root_node(searchNode *node, score_t alpha, score_t beta, int depth,
int ply, position_t* p) {
node->type = SEARCH_ROOT;
node->alpha = alpha;
node->beta = beta;
node->depth = depth;
node->ply = ply;
node->position = *p;
node->fake_color_to_move = color_to_move_of(&(node->position));
node->best_score = -INF;
node->pov = 1 - node->fake_color_to_move * 2; // pov = 1 for White, -1 for Black
node->abort = false;
}
// Zobrist hashing
uint64_t compute_zob_key(position_t *p) {
uint64_t key = 0;
for (fil_t f = 0; f < BOARD_WIDTH; f++) {
square_t sq = (FIL_ORIGIN + f) * ARR_WIDTH + RNK_ORIGIN;
for (rnk_t r = 0; r < BOARD_WIDTH; r++, sq++) {
key ^= zob[sq][p->board[sq]];
}
}
if (color_to_move_of(p) == BLACK)
key ^= zob_color;
return key;
}
// Initialize a scout search node for a "Null Window" search.
// https://chessprogramming.wikispaces.com/Scout
// https://chessprogramming.wikispaces.com/Null+Window
static void initialize_scout_node(searchNode *node, int depth) {
node->type = SEARCH_SCOUT;
node->beta = -(node->parent->alpha);
node->alpha = node->beta - 1;
node->depth = depth;
node->ply = node->parent->ply + 1;
node->subpv[0] = 0;
node->legal_move_count = 0;
node->fake_color_to_move = color_to_move_of(node->position);
// point of view = 1 for white, -1 for black
node->pov = 1 - node->fake_color_to_move * 2;
node->best_move_index = 0; // index of best move found
node->abort = false;
}
// Initializes a PV (principle variation node)
// https://chessprogramming.wikispaces.com/Node+Types#PV
static void initialize_pv_node(searchNode* node, int depth) {
node->type = SEARCH_PV;
node->alpha = -node->parent->beta;
node->orig_alpha = node->alpha; // Save original alpha.
node->beta = -node->parent->alpha;
node->subpv[0] = 0;
node->depth = depth;
node->legal_move_count = 0;
node->ply = node->parent->ply + 1;
node->fake_color_to_move = color_to_move_of(&(node->position));
// point of view = 1 for white, -1 for black
node->pov = 1 - node->fake_color_to_move * 2;
node->quiescence = (depth <= 0);
node->best_move_index = 0;
node->best_score = -INF;
node->abort = false;
}
// Obtain a sorted move list.
static int get_sortable_move_list(searchNode *node, sortable_move_t * move_list,
int hash_table_move) {
// number of moves in list
int num_of_moves = generate_all(&(node->position), move_list, false);
color_t fake_color_to_move = color_to_move_of(&(node->position));
move_t killer_a = killer[KMT(node->ply, 0)];
move_t killer_b = killer[KMT(node->ply, 1)];
for (int mv_index = 0; mv_index < num_of_moves; mv_index++) {
move_t mv = move_list[mv_index]; // don't use get_move. assumes generate_all doesn't bungle up high bits
if (mv == hash_table_move) {
set_sort_key(&move_list[mv_index], SORT_MASK);
} else if (mv == killer_a) {
set_sort_key(&move_list[mv_index], SORT_MASK - 1);
} else if (mv == killer_b) {
set_sort_key(&move_list[mv_index], SORT_MASK - 2);
} else {
ptype_t pce = ptype_mv_of(mv);
rot_t ro = rot_of(mv); // rotation
square_t fs = from_square(mv);
int ot = ORI_MASK & (ori_of(node->position.board[fs]) + ro);
square_t ts = to_square(mv);
set_sort_key(&move_list[mv_index],
best_move_history[BMH(fake_color_to_move, pce, ts, ot)]);
}
sortable_move_t insert = move_list[mv_index];
// TODO: enable this optimization for final since node counts change
// if (insert > SORT_MASK) {
int hole = mv_index;
while (hole > 0 && insert > move_list[hole-1]) {
move_list[hole] = move_list[hole-1];
hole--;
}
move_list[hole] = insert;
// }
}
return num_of_moves;
}
// Static evaluation. Returns score
score_t eval(position_t *p, bool verbose, full_board_t* board) {
// seed rand_r with a value of 1, as per
// http://linux.die.net/man/3/rand_r
static __thread unsigned int seed = 1;
// verbose = true: print out components of score
ev_score_t score[2] = { 0, 0 };
// int corner[2][2] = { {INF, INF}, {INF, INF} };
ev_score_t bonus;
color_t c = WHITE;
while (true) {
for (pnum_t pnum = 0; pnum <= board->pawn_count[c]; pnum++) {
square_t sq = board->pieces[c][pnum];
rnk_t r = rnk_of(sq);
fil_t f = fil_of(sq);
piece_t x = board->board[sq];
switch (ptype_of(x)) {
case EMPTY:
tbassert(false, "Jose says: no way!\n"); // No way, Jose!
case PAWN:
// PBETWEEN heuristic
bonus = pbetween(p, r, f, board);
score[c] += bonus;
// PCENTRAL heuristic
bonus = pcentral(r, f);
score[c] += bonus;
break;
case KING:
// KFACE heuristic
bonus = kface(p, r, f, board);
score[c] += bonus;
// KAGGRESSIVE heuristic
bonus = kaggressive(p, r, f, board);
score[c] += bonus;
break;
case INVALID:
tbassert(false, "Jose says: no way!\n"); // No way, Jose!
default:
tbassert(false, "Jose says: no way!\n"); // No way, Jose!
}
}
if (c == BLACK)
break;
c = BLACK;
}
score[WHITE] += board->pawn_count[WHITE] * PAWN_EV_VALUE;
score[BLACK] += board->pawn_count[BLACK] * PAWN_EV_VALUE;
square_t white_laser_list[MAX_NUM_PIECES];
square_t black_laser_list[MAX_NUM_PIECES];
int whitePathCount = get_laser_path_list(p, white_laser_list, WHITE, board);
int blackPathCount = get_laser_path_list(p, black_laser_list, BLACK, board);
ev_score_t w_hattackable = HATTACK * h_squares_attackable(p, WHITE, white_laser_list, whitePathCount, board);
score[WHITE] += w_hattackable;
ev_score_t b_hattackable = HATTACK * h_squares_attackable(p, BLACK, black_laser_list, blackPathCount, board);
score[BLACK] += b_hattackable;
int w_mobility_list = MOBILITY * mobility_list(p, WHITE, black_laser_list, blackPathCount, board);
score[WHITE] += w_mobility_list;
int b_mobility_list = MOBILITY * mobility_list(p, BLACK, white_laser_list, whitePathCount, board);
score[BLACK] += b_mobility_list;
// PAWNPIN Heuristic --- is a pawn immobilized by the enemy laser.
int w_pawnpin = PAWNPIN * pawnpin(p, WHITE, black_laser_list, blackPathCount, board); //use other color's laser map
score[WHITE] += w_pawnpin;
int b_pawnpin = PAWNPIN * pawnpin(p, BLACK, white_laser_list, whitePathCount, board); //use other color's laser map
score[BLACK] += b_pawnpin;
// score from WHITE point of view
ev_score_t tot = score[WHITE] - score[BLACK];
if (RANDOMIZE) {
ev_score_t z = rand_r(&seed) % (RANDOMIZE*2+1);
tot = tot + z - RANDOMIZE;
}
if (color_to_move_of(p) == BLACK) {
tot = -tot;
}
return tot / EV_SCORE_RATIO;
}
// Static evaluation. Returns score
score_t eval(position_t *p, bool verbose) {
// seed rand_r with a value of 1, as per
// http://linux.die.net/man/3/rand_r
static __thread unsigned int seed = 1;
// verbose = true: print out components of score
ev_score_t score[2] = { 0, 0 };
// int corner[2][2] = { {INF, INF}, {INF, INF} };
ev_score_t bonus;
//char buf[MAX_CHARS_IN_MOVE];
color_t c;
for (fil_t f = 0; f < BOARD_WIDTH; f++) {
for (rnk_t r = 0; r < BOARD_WIDTH; r++) {
square_t sq = square_of(f, r);
piece_t x = p->board[sq];
//if (verbose) {
// square_to_str(sq, buf, MAX_CHARS_IN_MOVE);
//}
switch (ptype_of(x)) {
case EMPTY:
break;
case PAWN:
c = color_of(x);
// MATERIAL heuristic: Bonus for each Pawn
bonus = PAWN_EV_VALUE;
// if (verbose) {
// printf("MATERIAL bonus %d for %s Pawn on %s\n", bonus, color_to_str(c), buf);
// }
score[c] += bonus;
// PBETWEEN heuristic
bonus = pbetween(p, f, r);
// if (verbose) {
// printf("PBETWEEN bonus %d for %s Pawn on %s\n", bonus, color_to_str(c), buf);
// }
score[c] += bonus;
// PCENTRAL heuristic
bonus = pcentral(f, r);
// if (verbose) {
// printf("PCENTRAL bonus %d for %s Pawn on %s\n", bonus, color_to_str(c), buf);
// }
score[c] += bonus;
break;
case KING:
c = color_of(x);
// KFACE heuristic
bonus = kface(p, f, r);
// if (verbose) {
// printf("KFACE bonus %d for %s King on %s\n", bonus,
// color_to_str(c), buf);
// }
score[c] += bonus;
// KAGGRESSIVE heuristic
color_t othercolor = opp_color(c);
square_t otherking = p->kloc[othercolor];
fil_t otherf = fil_of(otherking);
rnk_t otherr = rnk_of(otherking);
bonus = kaggressive(f, r, otherf, otherr);
assert(bonus == kaggressive_old(p, f, r));
// if (verbose) {
// printf("KAGGRESSIVE bonus %d for %s King on %s\n", bonus, color_to_str(c), buf);
// }
score[c] += bonus;
break;
case INVALID:
break;
default:
tbassert(false, "Jose says: no way!\n"); // No way, Jose!
}
laser_map_black[sq] = 0;
laser_map_white[sq] = 0;
}
}
int black_pawns_unpinned = mark_laser_path(p, laser_map_white, WHITE, 1); // 1 = path of laser with no moves
ev_score_t w_hattackable = HATTACK * (int) h_attackable;
score[WHITE] += w_hattackable;
// if (verbose) {
// printf("HATTACK bonus %d for White\n", w_hattackable);
// }
// PAWNPIN Heuristic --- is a pawn immobilized by the enemy laser.
int b_pawnpin = PAWNPIN * black_pawns_unpinned;
score[BLACK] += b_pawnpin;
int b_mobility = MOBILITY * mobility(p, BLACK);
score[BLACK] += b_mobility;
// if (verbose) {
// printf("MOBILITY bonus %d for Black\n", b_mobility);
// }
int white_pawns_unpinned = mark_laser_path(p, laser_map_black, BLACK, 1); // 1 = path of laser with no moves
ev_score_t b_hattackable = HATTACK * (int) h_attackable;
score[BLACK] += b_hattackable;
// if (verbose) {
// printf("HATTACK bonus %d for Black\n", b_hattackable);
// }
int w_mobility = MOBILITY * mobility(p, WHITE);
score[WHITE] += w_mobility;
// if (verbose) {
// printf("MOBILITY bonus %d for White\n", w_mobility);
// }
int w_pawnpin = PAWNPIN * white_pawns_unpinned;
score[WHITE] += w_pawnpin;
// score from WHITE point of view
ev_score_t tot = score[WHITE] - score[BLACK];
if (RANDOMIZE) {
ev_score_t z = rand_r(&seed) % (RANDOMIZE*2+1);
tot = tot + z - RANDOMIZE;
}
if (color_to_move_of(p) == BLACK) {
tot = -tot;
}
return tot / EV_SCORE_RATIO;
}
break;
case LEFT:
buf += snprintf(buf, bufsize - (buf - orig_buf), "L");
break;
default:
tbassert(false, "Whoa, now. Whoa, I say.\n"); // Bad, bad, bad
break;
}
}
}
// Generate all moves from position p. Returns number of moves.
// strict currently ignored
int generate_all(position_t * restrict p, sortable_move_t * restrict sortable_move_list,
bool strict) {
color_t color_to_move = color_to_move_of(p);
// Make sure that the enemy_laser map is marked
char laser_map[ARR_SIZE];
for (int i = 0; i < ARR_SIZE; ++i) {
laser_map[i] = 4; // Invalid square
}
mark_laser_path(p, laser_map, opp_color(color_to_move));
int move_count = 0;
for (fil_t f = 0; f < BOARD_WIDTH; f++) {
square_t sq = (FIL_ORIGIN + f) * ARR_WIDTH + RNK_ORIGIN;
for (rnk_t r = 0; r < BOARD_WIDTH; r++, sq++) {
piece_t x = p->board[sq];
ptype_t typ = ptype_of(x);
