static void InitSocket(HANDLE sock,int fd)
{
socket_t s = GetSocketByHandle(sock);
s->fd = fd;
LIST_CLEAR(s->pending_send);
LIST_CLEAR(s->pending_recv);
s->readable = s->writeable = 0;
s->active_read_count = s->active_write_count = 0;
s->engine = 0;
}
TexDictionary::TexDictionary( const TexDictionary& right ) : RwObject( right )
{
// Create a new dictionary with all the textures.
this->hasRecommendedPlatform = right.hasRecommendedPlatform;
this->recDevicePlatID = right.recDevicePlatID;
this->numTextures = 0;
LIST_CLEAR( textures.root );
Interface *engineInterface = right.engineInterface;
LIST_FOREACH_BEGIN( TextureBase, right.textures.root, texDictNode )
TextureBase *texture = item;
// Clone the texture and insert it into us.
TextureBase *newTex = (TextureBase*)engineInterface->CloneRwObject( texture );
if ( newTex )
{
newTex->AddToDictionary( this );
}
LIST_FOREACH_END
}
void sort_init_qs(sort_t * sort, board_t * board, const attack_t * attack, int depth, int node_type, int trans_killer) {
ASSERT(sort!=NULL);
ASSERT(board!=NULL);
ASSERT(attack!=NULL);
ASSERT(depth_is_ok(depth));
ASSERT(node_type==NodePV||node_type==NodeCut||node_type==NodeAll);
ASSERT(trans_killer==MoveNone||move_is_ok(trans_killer));
sort->board = board;
sort->attack = attack;
sort->depth = depth;
sort->value = node_type; // HACK
sort->trans_killer = trans_killer;
if (ATTACK_IN_CHECK(sort->attack)) {
sort->gen = PosEvasionQS;
} else if (depth >= 0) {
sort->gen = PosCheckQS;
} else {
sort->gen = PosCaptureQS;
}
LIST_CLEAR(sort->list);
sort->pos = 0;
}
HANDLE CreateEngine(char mode)
{
HANDLE engine = NewEngine();
if(engine >= 0)
{
engine_t e = GetEngineByHandle(engine);
e->mode = mode;
LIST_CLEAR(e->buffering_event_queue);
LIST_CLEAR(e->block_thread_queue);
if(0 != e->Init(e))
{
CloseEngine(engine);
engine = -1;
}
}
return engine;
}
void gen_captures(list_t * list, const board_t * board) {
ASSERT(list!=NULL);
ASSERT(board!=NULL);
LIST_CLEAR(list);
add_captures(list,board);
add_en_passant_captures(list,board);
// debug
ASSERT(list_is_ok(list));
}
// DebugHeap initializator routine.
// Call it before CRT initialization.
void DbgHeap_Init( void )
{
#ifdef USE_HEAP_DEBUGGING
GetSystemInfo( &g_systemInfo );
// Initialize watch callbacks.
_memAllocWatchCallback = NULL;
_nativeAlloc = new (malloc(sizeof(DebugFullPageHeapAllocator))) DebugFullPageHeapAllocator();
_win32_initHeap();
LIST_CLEAR( _dbgAllocBlocks.root );
#endif
}
void gen_quiet_moves(list_t * list, const board_t * board) {
ASSERT(list!=NULL);
ASSERT(board!=NULL);
ASSERT(!board_is_check(board));
LIST_CLEAR(list);
add_quiet_moves(list,board);
add_castle_moves(list,board);
// debug
ASSERT(list_is_ok(list));
}
void sort_init(sort_t * sort, board_t * board, const attack_t * attack, int depth, int height, int trans_killer) {
ASSERT(sort!=NULL);
ASSERT(board!=NULL);
ASSERT(attack!=NULL);
ASSERT(depth_is_ok(depth));
ASSERT(height_is_ok(height));
ASSERT(trans_killer==MoveNone||move_is_ok(trans_killer));
sort->board = board;
sort->attack = attack;
sort->depth = depth;
sort->height = height;
sort->trans_killer = trans_killer;
sort->killer_1 = Killer[sort->height][0];
sort->killer_2 = Killer[sort->height][1];
if (sort->height > 2){
sort->killer_3 = Killer[sort->height-2][0];
sort->killer_4 = Killer[sort->height-2][1];
}
else{
sort->killer_3 = MoveNone;
sort->killer_4 = MoveNone;
}
if (ATTACK_IN_CHECK(sort->attack)) {
gen_legal_evasions(sort->list,sort->board,sort->attack);
note_moves(sort->list,sort->board,sort->height,sort->trans_killer);
list_sort(sort->list);
sort->gen = PosLegalEvasion + 1;
sort->test = TEST_NONE;
} else { // not in check
LIST_CLEAR(sort->list);
sort->gen = PosSEE;
}
sort->pos = 0;
}
void sort_init_qs(sort_t * sort, board_t * board, const attack_t * attack, bool check) {
ASSERT(sort!=NULL);
ASSERT(board!=NULL);
ASSERT(attack!=NULL);
ASSERT(check==true||check==false);
sort->board = board;
sort->attack = attack;
if (ATTACK_IN_CHECK(sort->attack)) {
sort->gen = PosEvasionQS;
} else if (check) {
sort->gen = PosCheckQS;
} else {
sort->gen = PosCaptureQS;
}
LIST_CLEAR(sort->list);
sort->pos = 0;
}
static bool gen_evasions(list_t * list, const board_t * board, const attack_t * attack, bool legal, bool stop) {
int me, opp;
int opp_flag;
int king;
const inc_t * inc_ptr;
int inc;
int to;
int piece;
ASSERT(list!=NULL);
ASSERT(board!=NULL);
ASSERT(attack!=NULL);
ASSERT(legal==true||legal==false);
ASSERT(stop==true||stop==false);
ASSERT(board_is_check(board));
ASSERT(ATTACK_IN_CHECK(attack));
// init
LIST_CLEAR(list);
me = board->turn;
opp = COLOUR_OPP(me);
opp_flag = COLOUR_FLAG(opp);
king = KING_POS(board,me);
for (inc_ptr = KingInc; (inc=*inc_ptr) != IncNone; inc_ptr++) {
if (inc != -attack->di[0] && inc != -attack->di[1]) { // avoid escaping along a check line
to = king + inc;
piece = board->square[to];
if (piece == Empty || FLAG_IS(piece,opp_flag)) {
if (!legal || !is_attacked(board,to,opp)) {
if (stop) return true;
LIST_ADD(list,MOVE_MAKE(king,to));
}
}
}
}
if (attack->dn >= 2) return false; // double check, we are done
// single check
ASSERT(attack->dn==1);
// capture the checking piece
if (add_pawn_captures(list,board,attack->ds[0],legal,stop) && stop) return true;
if (add_piece_moves(list,board,attack->ds[0],legal,stop) && stop) return true;
// interpose a piece
inc = attack->di[0];
if (inc != IncNone) { // line
for (to = king+inc; to != attack->ds[0]; to += inc) {
ASSERT(SQUARE_IS_OK(to));
ASSERT(board->square[to]==Empty);
if (add_pawn_moves(list,board,to,legal,stop) && stop) return true;
if (add_piece_moves(list,board,to,legal,stop) && stop) return true;
}
}
return false;
}
int sort_next(sort_t * sort, int ThreadId) {
int move;
int gen;
ASSERT(sort!=NULL);
while (true) {
while (sort->pos < LIST_SIZE(sort->list)) {
// next move
move = LIST_MOVE(sort->list,sort->pos);
sort->value = HistoryMax; // default score, HistoryMax instead of 16384
sort->pos++;
ASSERT(move!=MoveNone);
// test
if (false) {
} else if (sort->test == TEST_NONE) {
// no-op
} else if (sort->test == TEST_TRANS_KILLER) {
if (!move_is_pseudo(move,sort->board)) continue;
if (!pseudo_is_legal(move,sort->board)) continue;
} else if (sort->test == TEST_GOOD_CAPTURE) {
ASSERT(move_is_tactical(move,sort->board));
if (move == sort->trans_killer) continue;
if (!capture_is_good(move,sort->board,sort->in_pv)) {
LIST_ADD(sort->bad,move);
continue;
}
if (!pseudo_is_legal(move,sort->board)) continue;
} else if (sort->test == TEST_BAD_CAPTURE) {
ASSERT(move_is_tactical(move,sort->board));
ASSERT(!capture_is_good(move,sort->board,sort->in_pv));
ASSERT(move!=sort->trans_killer);
if (!pseudo_is_legal(move,sort->board)) continue;
sort->value = HistoryBadCap; // WHM(31)
} else if (sort->test == TEST_KILLER) {
if (move == sort->trans_killer) continue;
if (!quiet_is_pseudo(move,sort->board)) continue;
if (!pseudo_is_legal(move,sort->board)) continue;
ASSERT(!move_is_tactical(move,sort->board));
sort->value = HistoryKiller; // WHM(31)
} else if (sort->test == TEST_QUIET) {
ASSERT(!move_is_tactical(move,sort->board));
if (move == sort->trans_killer) continue;
if (move == sort->killer_1) continue;
if (move == sort->killer_2) continue;
if (move == sort->killer_3) continue;
if (move == sort->killer_4) continue;
if (!pseudo_is_legal(move,sort->board)) continue;
sort->value = history_prob(move,sort->board,ThreadId);
} else {
ASSERT(false);
return MoveNone;
}
ASSERT(pseudo_is_legal(move,sort->board));
return move;
}
// next stage
gen = Code[sort->gen++];
if (false) {
} else if (gen == GEN_TRANS) {
LIST_CLEAR(sort->list);
if (sort->trans_killer != MoveNone) LIST_ADD(sort->list,sort->trans_killer);
sort->test = TEST_TRANS_KILLER;
} else if (gen == GEN_GOOD_CAPTURE) {
gen_captures(sort->list,sort->board);
note_mvv_lva(sort->list,sort->board);
list_sort(sort->list);
LIST_CLEAR(sort->bad);
sort->test = TEST_GOOD_CAPTURE;
} else if (gen == GEN_BAD_CAPTURE) {
list_copy(sort->list,sort->bad);
sort->test = TEST_BAD_CAPTURE;
} else if (gen == GEN_KILLER) {
LIST_CLEAR(sort->list);
if (sort->killer_1 != MoveNone) LIST_ADD(sort->list,sort->killer_1);
if (sort->killer_2 != MoveNone) LIST_ADD(sort->list,sort->killer_2);
if (sort->killer_3 != MoveNone) LIST_ADD(sort->list,sort->killer_3);
if (sort->killer_4 != MoveNone) LIST_ADD(sort->list,sort->killer_4);
sort->test = TEST_KILLER;
} else if (gen == GEN_QUIET) {
gen_quiet_moves(sort->list,sort->board);
note_quiet_moves(sort->list,sort->board,sort->in_pv,ThreadId);
list_sort(sort->list);
sort->test = TEST_QUIET;
} else {
ASSERT(gen==GEN_END);
return MoveNone;
}
sort->pos = 0;
}
}
void sort_init(sort_t * sort, board_t * board, const attack_t * attack, int depth, int height, int trans_killer, bool in_pv, int ThreadId) {
ASSERT(sort!=NULL);
ASSERT(board!=NULL);
ASSERT(attack!=NULL);
ASSERT(depth_is_ok(depth));
ASSERT(height_is_ok(height));
ASSERT(trans_killer==MoveNone||move_is_ok(trans_killer));
sort->board = board;
sort->attack = attack;
sort->height = height;
sort->trans_killer = trans_killer;
sort->killer_1 = Killer[ThreadId][sort->height][0]; // last best
sort->killer_3 = Killer[ThreadId][sort->height][1];
if (sort->height > 2){
sort->killer_2 = Killer[ThreadId][sort->height-2][0]; // last best below
sort->killer_4 = Killer[ThreadId][sort->height-2][1];
}
else{
sort->killer_2 = MoveNone;
sort->killer_4 = MoveNone;
}
// uniqueness added. // WHM
if (sort->killer_1 != MoveNone) { // WHM
if (sort->killer_2 == sort->killer_1) sort->killer_2 = MoveNone; // WHM
if (sort->killer_3 == sort->killer_1) sort->killer_3 = MoveNone; // WHM
if (sort->killer_4 == sort->killer_1) sort->killer_4 = MoveNone; // WHM
} // WHM
if (sort->killer_2 != MoveNone) { // WHM
if (sort->killer_3 == sort->killer_2) sort->killer_3 = MoveNone; // WHM
if (sort->killer_4 == sort->killer_2) sort->killer_4 = MoveNone; // WHM
} // WHM
if (sort->killer_4 == sort->killer_3) sort->killer_4 = MoveNone; // WHM
ASSERT(sort->killer_1 == MoveNone || sort->killer_1 != sort->killer_2); // WHM
ASSERT(sort->killer_1 == MoveNone || sort->killer_1 != sort->killer_3); // WHM
ASSERT(sort->killer_1 == MoveNone || sort->killer_1 != sort->killer_4); // WHM
ASSERT(sort->killer_2 == MoveNone || sort->killer_2 != sort->killer_1); // WHM
ASSERT(sort->killer_2 == MoveNone || sort->killer_2 != sort->killer_3); // WHM
ASSERT(sort->killer_2 == MoveNone || sort->killer_2 != sort->killer_4); // WHM
ASSERT(sort->killer_3 == MoveNone || sort->killer_3 != sort->killer_1); // WHM
ASSERT(sort->killer_3 == MoveNone || sort->killer_3 != sort->killer_2); // WHM
ASSERT(sort->killer_3 == MoveNone || sort->killer_3 != sort->killer_4); // WHM
ASSERT(sort->killer_4 == MoveNone || sort->killer_4 != sort->killer_1); // WHM
ASSERT(sort->killer_4 == MoveNone || sort->killer_4 != sort->killer_2); // WHM
ASSERT(sort->killer_4 == MoveNone || sort->killer_4 != sort->killer_3); // WHM
sort->in_pv = in_pv;
if (ATTACK_IN_CHECK(sort->attack)) {
gen_legal_evasions(sort->list,sort->board,sort->attack);
note_moves(sort->list,sort->board,sort->height,sort->trans_killer,ThreadId);
list_sort(sort->list);
sort->gen = PosLegalEvasion + 1;
sort->test = TEST_NONE;
} else { // not in check
LIST_CLEAR(sort->list);
sort->gen = PosSEE;
}
sort->pos = 0;
}
int sort_next_qs(sort_t * sort) {
int move;
int gen;
ASSERT(sort!=NULL);
while (true) {
while (sort->pos < LIST_SIZE(sort->list)) {
// next move
move = LIST_MOVE(sort->list,sort->pos);
sort->pos++;
ASSERT(move!=MoveNone);
// test
if (false) {
} else if (sort->test == TEST_LEGAL) {
if (!pseudo_is_legal(move,sort->board)) continue;
} else if (sort->test == TEST_TRANS_KILLER) {
if (!move_is_pseudo(move,sort->board)) continue;
if (!pseudo_is_legal(move,sort->board)) continue;
// check
if (!MOVE_IS_TACTICAL(move,sort->board)
&& (!move_is_check(move,sort->board) || sort->depth < 0)) continue;
} else if (sort->test == TEST_CAPTURE_QS) {
ASSERT(MOVE_IS_TACTICAL(move,sort->board));
ASSERT(sort->value==NodePV||sort->value==NodeCut||sort->value==NodeAll);
if (move == sort->trans_killer) continue;
if (sort->value != NodePV && !capture_is_good(move,sort->board)) continue;
if (!pseudo_is_legal(move,sort->board)) continue;
} else if (sort->test == TEST_CHECK_QS) {
ASSERT(!MOVE_IS_TACTICAL(move,sort->board));
ASSERT(move_is_check(move,sort->board));
if (move == sort->trans_killer) continue;
if (see_move(move,sort->board,0) < 0) continue;
if (!pseudo_is_legal(move,sort->board)) continue;
} else {
ASSERT(false);
return MoveNone;
}
ASSERT(pseudo_is_legal(move,sort->board));
return move;
}
// next stage
gen = Code[sort->gen++];
if (false) {
} else if (gen == GEN_EVASION_QS) {
gen_pseudo_evasions(sort->list,sort->board,sort->attack);
note_moves_simple(sort->list,sort->board,sort->trans_killer);
list_sort(sort->list);
sort->test = TEST_LEGAL;
} else if (gen == GEN_TRANS) {
LIST_CLEAR(sort->list);
if (sort->trans_killer != MoveNone) LIST_ADD(sort->list,sort->trans_killer);
sort->test = TEST_TRANS_KILLER;
} else if (gen == GEN_CAPTURE_QS) {
gen_captures(sort->list,sort->board);
note_mvv_lva(sort->list,sort->board);
list_sort(sort->list);
sort->test = TEST_CAPTURE_QS;
} else if (gen == GEN_CHECK_QS) {
gen_quiet_checks(sort->list,sort->board);
sort->test = TEST_CHECK_QS;
} else {
ASSERT(gen==GEN_END);
return MoveNone;
}
sort->pos = 0;
}
}
int sort_next(sort_t * sort) {
int move;
int gen;
ASSERT(sort!=NULL);
while (true) {
while (sort->pos < LIST_SIZE(sort->list)) {
// next move
move = LIST_MOVE(sort->list,sort->pos);
sort->value = 65536; // default score
sort->pos++;
ASSERT(move!=MoveNone);
// test
if (false) {
} else if (sort->test == TEST_NONE) {
// Evasion (no-op)
} else if (sort->test == TEST_TRANS_KILLER) {
if (!move_is_pseudo(move,sort->board)) continue;
if (!pseudo_is_legal(move,sort->board)) continue;
} else if (sort->test == TEST_CAPTURE) {
ASSERT(MOVE_IS_TACTICAL(move,sort->board));
if (move == sort->trans_killer) continue;
if (!capture_is_good(move,sort->board)) {
LIST_ADD(sort->bad,move);
continue;
}
if (!pseudo_is_legal(move,sort->board)) continue;
} else if (sort->test == TEST_KILLER) {
if (move == sort->trans_killer) continue;
if (!quiet_is_pseudo(move,sort->board)) continue;
if (!pseudo_is_legal(move,sort->board)) continue;
ASSERT(!MOVE_IS_TACTICAL(move,sort->board));
sort->value = 32768;
} else if (sort->test == TEST_QUIET) {
ASSERT(!MOVE_IS_TACTICAL(move,sort->board));
if (move == sort->trans_killer) continue;
if (move == sort->killer_1) continue;
if (move == sort->killer_2) continue;
if (!pseudo_is_legal(move,sort->board)) continue;
sort->value = history_prob(move,sort->board);
} else if (sort->test == TEST_BAD) {
ASSERT(MOVE_IS_TACTICAL(move,sort->board));
ASSERT(!capture_is_good(move,sort->board));
ASSERT(move!=sort->trans_killer);
if (!pseudo_is_legal(move,sort->board)) continue;
} else {
ASSERT(false);
return MoveNone;
}
ASSERT(pseudo_is_legal(move,sort->board));
return move;
}
// next stage
gen = Code[sort->gen++];
if (false) {
} else if (gen == GEN_TRANS) {
LIST_CLEAR(sort->list);
if (sort->trans_killer != MoveNone) LIST_ADD(sort->list,sort->trans_killer);
sort->test = TEST_TRANS_KILLER;
} else if (gen == GEN_CAPTURE) {
gen_captures(sort->list,sort->board);
note_mvv_lva(sort->list,sort->board);
list_sort(sort->list);
LIST_CLEAR(sort->bad);
sort->test = TEST_CAPTURE;
} else if (gen == GEN_KILLER) {
LIST_CLEAR(sort->list);
if (sort->killer_1 != MoveNone) LIST_ADD(sort->list,sort->killer_1);
if (sort->killer_2 != MoveNone) LIST_ADD(sort->list,sort->killer_2);
sort->test = TEST_KILLER;
} else if (gen == GEN_QUIET) {
gen_quiet_moves(sort->list,sort->board);
note_quiet_moves(sort->list,sort->board);
list_sort(sort->list);
sort->test = TEST_QUIET;
} else if (gen == GEN_BAD) {
list_copy(sort->list,sort->bad);
sort->test = TEST_BAD;
} else {
ASSERT(gen==GEN_END);
return MoveNone;
}
sort->pos = 0;
}
}
inline static void _win32_initHeap( void )
{
LIST_CLEAR( g_privateMemory.root );
}
