-/***********************************************************************/\r
-/* HaChu */\r
-/* A WinBoard engine for large (dropless) Shogi variants by H.G.Muller */\r
-/* The engine is based on incremental updating of an attack map and */\r
-/* mobility scores, since the effort in this only grows proportional */\r
-/* to board edge length, rather than board area. */\r
-/***********************************************************************/\r
+/**************************************************************************/\r
+/* HaChu */\r
+/* A WinBoard engine for Chu Shogi (and some related games) by H.G.Muller */\r
+/**************************************************************************/\r
+/* This source code is released in the public domain */\r
+/**************************************************************************/\r
\r
// TODO:\r
// in GenCapts we do not generate jumps of more than two squares yet\r
mobilityScore -= MapOneColor(0, last[BLACK], map);\r
}\r
\r
-void\r
-Connect (int sqr, int piece, int dir)\r
-{ // scan to both sides along ray to elongate attacks from there, and remove our own attacks on there, if needed\r
- int x, step = kStep[dir], r1 = p[piece].range[dir], r2 = p[piece].range[dir+4], r3, r4, piece1, piece2;\r
- int d1, d2, r, y, c;\r
-\r
- if((attacks[2*sqr] + attacks[2*sqr+1]) & attackMask[dir]) { // there are incoming attack(s) from 'behind'\r
- x = sqr;\r
- while(board[x-=step] == EMPTY); // in any case, scan to attacker, to see where / what it is\r
- d1 = dist[x-sqr]; piece1 = board[x];\r
- attacks[2*x + stm] -= -(d1 <= r2) & one[dir+4]; // remove our attack on it if in-range\r
- if((attacks[2*sqr] + attacks[2*sqr+1]) & attackMask[dir+4]) { // there are also incoming attack(s) from 'ahead'\r
-\r
- y = sqr;\r
- while(board[y+=step] == EMPTY); // also always scan to that one to see what it is\r
- d2 = dist[y-sqr]; piece2 = board[y];\r
- attacks[2*y+stm] -= -(d2 <= r1) & one[dir]; // remove our attack on it if in-range\r
- // we have two pieces now shooting at each other. See how far they get.\r
- if(d1 + d2 <= (r3 = p[piece1].range[dir])) { // 1 hits 2\r
- attacks[2*y + (piece1 & WHITE)] += one[dir]; // count attack\r
- UPDATE_MOBILITY(piece1, d2);\r
- } else UPDATE_MOBILITY(piece1, r3 - d1); // does not connect, but could still gain mobility\r
- if(d1 + d2 <= (r4 = p[piece2].range[dir+4])) { // 2 hits 1\r
- attacks[2*x + (piece2 & WHITE)] += one[dir+4]; // count attack\r
- UPDATE_MOBILITY(piece2, d1);\r
- } else UPDATE_MOBILITY(piece2, r4 - d2); // does not connect, but could still gain mobility\r
- // if r1 or r2<0, moves typically jump, and thus cannot be unblocked. Exceptions are FF and BS distant moves.\r
- // test for d1+d2 > 2 && rN == F && d== 3 or rN == S\r
- if(d1 <= 2) { // could be jump interactions\r
- if(d1 == 2) {\r
- if(r2 <= J) attacks[2*x + stm] -= one[dir+4];\r
- if(r1 <= J) attacks[2*y + stm] -= one[dir];\r
- } else { // d1 == 1\r
- if(r2 < J) attacks[2*x + stm] -= one[dir+4];\r
- if(r1 < J) attacks[2*y + stm] -= one[dir];\r
- if(board[x-step] != EMPTY && board[x-step] != EDGE)\r
- attacks[2*(x-step) + stm] -= one[dir+4];\r
- }\r
- }\r
-\r
- } else { // we were only attacked from behind\r
-\r
- r = (r2 = p[piece1].range[dir]) - d1;\r
- if(r < 0 || c > one[dir+4]) { // Oops! This was not our attacker, or not the only one. There must be a jump attack from even further behind!\r
- // for now, forget jumpers\r
- }\r
- y = sqr; \r
- while(r--)\r
- if(board[y+=step] != EMPTY) {\r
- d2 = dist[y-sqr]; piece2 = board[y];\r
- if(piece2 != EDGE) { // extended move hits a piece\r
- attacks[2*y + (piece1 & WHITE)] += one[dir]; // count attack\r
- attacks[2*y + stm] -= -(d2 <= r1) & one[dir]; // remove our own attack on it, if in-range\r
- }\r
- UPDATE_MOBILITY(piece1, d2); // count extra mobility even if we hit edge\r
- return;\r
- }\r
- // we hit nothing with the extended move of the attacker behind us.\r
- UPDATE_MOBILITY(piece1, r2 - d1);\r
- r = r1 - r2 + d1; // extra squares covered by mover\r
- while(r-- > 0)\r
- if(board[y+=step] != EMPTY) {\r
- d2 = dist[y-sqr]; piece2 = board[y];\r
- if(piece2 != EDGE) { // extended move hits a piece\r
- attacks[2*y + stm] -= one[dir]; // count attack\r
- }\r
- return;\r
- }\r
- }\r
- // if r2<0 we should again test for F and S moves\r
-\r
- } else // no incoming attack from behind\r
- if(c = (attacks[2*sqr] + attacks[2*sqr+1]) & attackMask[dir+4]) { // but incoming attack(s) from 'ahead'\r
-\r
- y = sqr; while(board[y+=step]); // locate attacker\r
- d2 = dist[y-sqr]; piece2 = board[y];\r
- attacks[2*y + stm] -= -(d2 <= r1) & one[dir]; // remove our attack on it if in-range\r
- r = (r1 = p[piece1].range[dir]) - d2;\r
- if(r < 0 || c > one[dir]) { // Oops! This was not our attacker, or not the only one. There must be a jump attack from even further behind!\r
- // for now, forget jumpers\r
- }\r
- x = sqr;\r
- while(r--)\r
- if(board[x-=step] != EMPTY) {\r
- d1 = dist[x-sqr]; piece1 = board[x];\r
- if(piece1 != EDGE) { // extended move hits a piece\r
- attacks[2*x + (piece2 & WHITE)] += one[dir+4]; // count attack\r
- attacks[2*x + stm] -= -(d1 <= r2) & one[dir+4]; // remove our own attack on it, if in-range\r
- }\r
- UPDATE_MOBILITY(piece2, d1); // count extra mobility even if we hit edge\r
- return;\r
- }\r
- // we hit nothing with the extended move of the attacker behind us.\r
- UPDATE_MOBILITY(piece2, r2 - d1);\r
- r = r2 - r1 + d2; // extra squares covered by mover\r
- while(r-- > 0)\r
- if(board[x-=step] != EMPTY) {\r
- d1 = dist[x-sqr]; piece1 = board[x];\r
- if(piece1 != EDGE) { // extended move hits a piece\r
- attacks[2*x + stm] -= one[dir+4]; // count attack\r
- }\r
- return;\r
- }\r
-\r
- } else { // no incoming attacks from either side. Only delete attacks of mover on others\r
-\r
- x = sqr;\r
- while(r1--)\r
- if(board[x+=step] != EMPTY) { // piece found that we attacked\r
- attacks[2*x + stm] -= one[dir]; // decrement attacks along that direction\r
- break;\r
- }\r
-\r
- x = sqr;\r
- while(r2--)\r
- if(board[x-=step] != EMPTY) { // piece found that we attacked\r
- attacks[2*x + stm] -= one[dir+4]; // decrement attacks along opposite direction\r
- break;\r
- }\r
-\r
- }\r
-}\r
-\r
-inline int\r
-Hit (int r, int d)\r
-{ // test if move with range r reaches over (un-obstructed) distance d\r
- if(r < 0) switch(r) {\r
- case J: return (d == 2);\r
- case D:\r
- case L: return (d <= 2);\r
- case T:\r
- case F: return (d <= 3);\r
- case S: return 1;\r
- default: return 0;\r
- } else return (d <= r);\r
- return 0; // not reached\r
-}\r
-\r
-void\r
-Disconnect (int sqr, int piece, int dir)\r
-{\r
- int x = sqr, step = kStep[dir], piece1, piece2, d1, d2, r1, r2, y;\r
- while( board[x+=step] == EMPTY );\r
- piece1 = board[x];\r
- if(piece1 != EDGE) { // x has hit a piece\r
- d1 = dist[x-sqr];\r
- r1 = p[piece1].range[dir+4];\r
- y = sqr; while( board[y-=step] == EMPTY );\r
- piece2 = board[y];\r
- if(piece2 != EDGE) { // both ends of the ray hit a piece\r
- d2 = dist[y-sqr];\r
- r2 = p[piece2].range[dir];\r
- if(r1 >= d1) { // piece1 hits us\r
- attacks[2*sqr + (piece1 & WHITE)] += one[dir+4];\r
- if(r1 >= d1 + d2) // was hitting piece2 before, now blocked\r
- attacks[2*y + (piece1 & WHITE)] -= one[dir+4];\r
- }\r
- if(r2 >= d2) { // piece2 hits us\r
- attacks[2*sqr + (piece2 & WHITE)] += one[dir];\r
- if(r2 >= d1 + d2) // was hitting piece1 before, now blocked\r
- attacks[2*x + (piece2 & WHITE)] -= one[dir];\r
- }\r
- if( Hit(p[piece].range[dir], d1) )\r
- attacks[2*sqr + stm] += one[dir];\r
- if( Hit(p[piece].range[dir+4], d2) )\r
- attacks[2*sqr + stm] += one[dir+4];\r
- return;\r
- }\r
- } else {\r
- x = sqr; while( board[x-=step] == EMPTY );\r
- piece1 = board[x];\r
- if(piece1 == EDGE) return; // ray empty on both sides\r
- d1 = dist[x-sqr];\r
- r1 = p[piece1].range[dir];\r
- dir += 4;\r
- }\r
- // we only get here if one side looks to the board edge\r
- if(r1 >= d1) // piece1 hits us\r
- attacks[2*sqr + (piece1 & WHITE)] += one[dir^4];\r
- if( Hit(p[piece].range[dir], d1) )\r
- attacks[2*sqr + stm] += one[dir];\r
-}\r
-\r
-void\r
-Occupy (int sqr)\r
-{ // determines attacks on square and blocking when a piece lands on an empty square\r
- int i;\r
- for(i=0; i<4; i++) {\r
- Disconnect(sqr, board[sqr], i);\r
- }\r
-}\r
-\r
-void\r
-Evacuate (int sqr, int piece)\r
-{ // determines change in attacks on neighbors due to unblocking and mover when the mentioned piece vacates the given square\r
- int i;\r
- for(i=0; i<4; i++) Connect(sqr, piece, i);\r
-}\r
-\r
int\r
MakeMove(Move m, UndoInfo *u)\r
{\r
postThinking--; repCnt = 0; tlim1 = tlim2 = tlim3 = 1e8; abortFlag = msp = 0;\r
Search(-INF-1, INF+1, 0, QSdepth+1, 0, sup1 & ~PROMOTE, sup2, INF);\r
postThinking++;\r
+\r
listStart = retFirst; listEnd = msp = retMSP;\r
}\r
\r
projects / hachu.git / commitdiff