void print_move(const int& move) {
char f[6],t[6];
sq_str(m_from(move),f);
sq_str(m_to(move),t);
print("%s %s %c %c %c ep = %d",f,t,piece_name[m_piece(move)],
piece_name[m_capture(move)],piece_name[m_promote(move)],is_ep(move));
}
RVAPI int RVCALLCONV /* type of node */
pstGetNodeRange(
IN HPST hSyn,
IN int nodeId,
OUT int *from,
OUT int *to
)
{
stNodeExt* node;
node = (stNodeExt *)stGetNodeDataByNodeId(hSyn, nodeId);
if (node == NULL) return RVERROR;
if (from) *from = m_from(node);
if (to) *to = m_to(node);
return (m_to(node) == 0)? RVERROR : 0;
}
void SEARCHER::do_move(const int& move) {
int from = m_from(move),to = m_to(move),sq;
/*remove captured piece*/
if(m_capture(move)) {
if(is_ep(move)) {
sq = to - pawn_dir[player];
} else {
sq = to;
}
pcRemove(m_capture(move),sq);
board[sq] = empty;
}
/*move piece*/
if(m_promote(move)) {
board[to] = m_promote(move);
board[from] = empty;
pcAdd(m_promote(move),to);
pcRemove(COMBINE(player,pawn),from);
} else {
board[to] = board[from];
board[from] = empty;
pcSwap(from,to);
}
/*move castle*/
if(is_castle(move)) {
int fromc,toc;
if(to > from) {
fromc = to + RR;
toc = to + LL;
} else {
fromc = to + 2*LL;
toc = to + RR;
}
board[toc] = board[fromc];
board[fromc] = empty;
pcSwap(fromc,toc);
}
/*update current state*/
epsquare = 0;
fifty++;
if(DECOMB(player,m_piece(move)) == pawn) {
fifty = 0;
if(to - from == (2 * pawn_dir[player])) {
epsquare = ((to + from) >> 1);
}
/************************************************************************
* pstPrintNode
* purpose: Print the information of a syntax tree node to a buffer
* input : hSyn - Syntax tree handle
* nodeId - Node to print
* buf - Result buffer to use
* len - Length of buffer
* output : none
* return : Number of characters printed
************************************************************************/
int pstPrintNode(
IN HPST hSyn,
IN int nodeId,
IN char* buf,
IN int len)
{
stNodeExt* node;
char* ptr = buf;
char* fromString;
stNodeExt* ofNode;
/* Get the node itself */
node = (stNodeExt *)stGetNodeDataByNodeId(hSyn, nodeId);
if (node == NULL) return 0;
/* 1. GENERAL TYPE */
ptr += sprintf(ptr, "%s ", nprn(pstGetTokenName((pstNodeType)(m_type(node)))));
/* 2. TAG */
if (m_tag(node) >= 0)
ptr += sprintf(ptr, "[%s %d] ", nprn(pstGetTagClassName((pstTagClass)m_tagClass(node))), m_tag(node));
/* 3. FROM-TO */
if ((m_from(node) > 0) || (m_to(node) > 0))
{
/* Check for negative boundaries */
if (m_from(node) <= m_to(node))
ptr += sprintf(ptr, "(%d..%d) ", m_from(node), m_to(node));
else
ptr += sprintf(ptr, "(%u..%u)or(%d..%d) ", m_from(node), m_to(node), m_from(node), m_to(node));
}
/* 4. FROM CHARS */
if (m_fromId(node) >= 0)
{
fromString = stGetNameByNameId(hSyn, m_fromId(node), NULL);
if (fromString[0])
ptr += sprintf(ptr, "FROM '%s' ", fromString);
}
/* 5. EXTENSION */
if (m_isExtension(node))
{
strcpy(ptr, "... ");
ptr += 4;
}
/* 6. SEQUENCE OF recursion */
switch (m_type(node))
{
case pstOf:
case pstSequenceOf:
case pstSetOf:
ofNode = (stNodeExt *)stGetNodeDataByNodeId(hSyn, m_ofId(node));
if (ofNode != NULL)
{
int printedChars = (ptr - buf);
return printedChars + pstPrintNode(hSyn, m_ofId(node), ptr, len - printedChars);
}
default:
break;
}
return (ptr - buf);
}
int SEARCHER::see(MOVE move) {
int list[32],n;
int from = m_from(move),to = m_to(move),sq,score;
int w_atkers[16],b_atkers[16];
int w_atks = 0,b_atks = 0;
int w_count , b_count;
int col,atkd_val;
int i,bi,bv,v,step,temp;
PLIST current;
/*initial value*/
col = PCOLOR(m_piece(move));
score = piece_see_v[m_capture(move)];
atkd_val = piece_see_v[m_piece(move)];
/*king captures*/
if(atkd_val > 1000)
return score;
/*collect pawn attackers*/
temp = score - atkd_val + piece_see_v[pawn];
if (board[to + RD] == wpawn && from != (to + RD)) {
QUICK_CUT(black);
w_atkers[w_atks++] = to + RD;
}
if (board[to + LD] == wpawn && from != (to + LD)) {
QUICK_CUT(black);
w_atkers[w_atks++] = to + LD;
}
if (board[to + RU] == bpawn && from != (to + RU)) {
QUICK_CUT(white);
b_atkers[b_atks++] = to + RU;
}
if (board[to + LU] == bpawn && from != (to + LU)) {
QUICK_CUT(white);
b_atkers[b_atks++] = to + LU;
}
/*knight attackers*/
temp = score - atkd_val + piece_see_v[knight];
current = plist[wknight];
while (current) {
sq = current->sq;
if (sqatt_pieces(to - sq) & NM) {
if(sq != from) {
QUICK_CUT(black);
w_atkers[w_atks++] = sq;
}
}
current = current->next;
}
current = plist[bknight];
while (current) {
sq = current->sq;
if (sqatt_pieces(to - sq) & NM) {
if(sq != from) {
QUICK_CUT(white);
b_atkers[b_atks++] = sq;
}
}
current = current->next;
}
/*sliders*/
temp = score - atkd_val + piece_see_v[bishop];
AddSlider(to,RU,wbishop,bbishop,1);
AddSlider(to,LU,wbishop,bbishop,1);
AddSlider(to,RD,wbishop,bbishop,1);
AddSlider(to,LD,wbishop,bbishop,1);
temp = score - atkd_val + piece_see_v[rook];
AddSlider(to,UU,wrook,brook,1);
AddSlider(to,DD,wrook,brook,1);
AddSlider(to,RR,wrook,brook,1);
AddSlider(to,LL,wrook,brook,1);
/*king attackers*/
sq = plist[wking]->sq;
if (sq != from && (sqatt_pieces(to - sq) & KM)) {
w_atkers[w_atks++] = sq;
}
sq = plist[bking]->sq;
if (sq != from && (sqatt_pieces(to - sq) & KM)) {
b_atkers[b_atks++] = sq;
}
/*we start by capturing*/
col = invert(col);
if(col == opponent)
AddHiddenAttacker(from);
/*no attackers*/
if((col == white && !w_atks)
|| (col == black && !b_atks))
return score;
/*swap*/
list[0] = score;
n = 1;
w_count = 0;
b_count = 0;
while(true) {
if((col == white && w_count == w_atks) ||
(col == black && b_count == b_atks) )
break;
list[n] = -list[n-1] + atkd_val;
n++;
if(col == white) {
/*get smallest attacker to the front*/
bi = w_count;
bv = piece_see_v[board[w_atkers[bi]]];
for(i = w_count + 1;i < w_atks;i++) {
v = piece_see_v[board[w_atkers[i]]];
if(v < bv) {
bi = i;
bv = v;
}
}
if(bi != w_count) {
temp = w_atkers[bi];
w_atkers[bi] = w_atkers[w_count];
w_atkers[w_count] = temp;
}
/*add hidden attacker*/
sq = w_atkers[w_count];
AddHiddenAttacker(sq);
atkd_val = bv;
col = black;
w_count++;
} else {
/*get smallest attacker to the front*/
bi = b_count;
bv = piece_see_v[board[b_atkers[bi]]];
for(i = b_count + 1;i < b_atks;i++) {
v = piece_see_v[board[b_atkers[i]]];
if(v < bv) {
bi = i;
bv = v;
}
}
if(bi != b_count) {
temp = b_atkers[bi];
b_atkers[bi] = b_atkers[b_count];
b_atkers[b_count] = temp;
}
/*add hidden attacker*/
sq = b_atkers[b_count];
AddHiddenAttacker(sq);
atkd_val = bv;
col = white;
b_count++;
}
}
while(--n)
list[n-1] = MIN(-list[n], list[n-1]);
score = list[0];
return score;
}
