```Previous   Next
```

## Move Generation: Castling

#### King Capture

Before we discuss castling, it is good to point out that micro-Max is a King-capture engine: At any level it generates all pseudo-legal moves, including those that put his own King in check. Since this is a condition that depends on which moves the opponent has, it seems more logical to test it on the next ply, when we generate the opponent's moves anyway. Usually all opponent's moves are generated before micro-Max starts to think about any of them, and if a King capture is found the branch is aborted and the caller is informed (by the move's score) that the move was an illegal one.

#### Castling and e.p. Capture

Castling and e.p. capture share an underlying philosophy: a piece (Pawn or King) moves farther than it is ordinarily allowed to, and if the square it skips in doing so is under attack by the enemy, it can be captured there anyway. For castling this of course results in the move being declared illegal, since you are not allowed to expose your King to capture.
Micro-Max exploits this similarity: the field that is skipped over with these moves is communicated to the next ply as the recursion argument E, to indicate that something can be captured there. Castling and Pawn e.p. can be easily distinguished by the contents `b[E]`of the e.p. square: after castling it contains a Rook, after a Pawn double move it is empty. King captures never have to be executed. They lead to termination of the move generation altogether, because the previous move was apparently already an illegal one and we are working on a phantom branch of the search tree. This holds just as much for the 'e.p.' capture of a King after castling, as for ordinary king captures. In fact we can also cover the rule that you are not allowed to castle when in check easily by the same mechanism, by not only testing if the subsequent move goes to the e.p. square, but also to either square next to it `(y-E<2&E-y<2)`.
Thus, in line with the King-capture philosophy, several conditions for castling are checked in hindsight, on the reply move.

#### Castling Rights

Enough remains to be checked during move generation itself, though. Castling applies to a King moving sideways (recognized by the direction number j). We have to figure out what the corner associated with the direction (King or Queen side) is, and remember it in G. This variable at the same time flags that we have a castling move, for any non-castling it remains set to the dummy square code S.
We then have to test if both King and Rook have not been moved before (from their virgin bits), and indeed are present, and if the two squares next to the Rook are empty. The King ends on one of these squares, so this also checks if the King does not capture something on castling. If the King captured something next to it, this would terminate the ray after the King's first side step and thus prevent castling. Finally, the lateral King ray must be extended like this only once, tested by checking if the previous move already was castling through G, before calculating the new G. A lot of testing, but if we pass it all, we do exactly the same as for the pawn-double-move extension: unfake the terminating capture and remember the e.p. square in F. The only difference is that G has also been set as a side-effect of the tests. If the test fail, it does not matter that G has been set, because the ray then terminates and at the start of a new ray G is re-initialized as the dummy.

Below the code lines that implement castling are highlighted:

```/***************************************************************************/
/*                               micro-Max,                                */
/* A chess program smaller than 2KB (of non-blank source), by H.G. Muller  */
/***************************************************************************/
/* version 3.2 (2000 characters) features:                                 */
/* - recursive negamax search                                              */
/* - quiescence search with recaptures                                     */
/* - recapture extensions                                                  */
/* - (internal) iterative deepening                                        */
/* - best-move-first 'sorting'                                             */
/* - a hash table storing score and best move                              */
/* - full FIDE rules (expt minor ptomotion) and move-legality checking     */

#define F(I,S,N) for(I=S;I<N;I++)
#define W(A) while(A)
#define K(A,B) *(int*)(T+A+(B&8)+S*(B&7))
#define J(A) K(y+A,b[y])-K(x+A,u)-K(H+A,t)

#define U 16777224
struct _ {int K,V;char X,Y,D;} A[U];           /* hash table, 16M+8 entries*/

int V=112,M=136,S=128,I=8e3,C=799,Q,N,i;       /* V=0x70=rank mask, M=0x88 */

char O,K,L,
w[]={0,1,1,3,-1,3,5,9},                        /* relative piece values    */
o[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0, /* step-vector lists */
7,-1,11,6,8,3,6,                          /* 1st dir. in o[] per piece*/
6,3,5,7,4,5,3,6},                         /* initial piece setup      */
b[129],                                        /* board: half of 16x8+dummy*/
T[1035],                                       /* hash translation table   */

n[]=".?+nkbrq?*?NKBRQ";                        /* piece symbols on printout*/

D(k,q,l,e,J,Z,E,z,n)    /* recursive minimax search, k=moving side, n=depth*/
int k,q,l,e,J,Z,E,z,n;  /* (q,l)=window, e=current eval. score, E=e.p. sqr.*/
{                       /* e=score, z=prev.dest; J,Z=hashkeys; return score*/
int j,r,m,v,d,h,i=9,F,G;
char t,p,u,x,y,X,Y,H,B;
struct _*a=A;
/* lookup pos. in hash table*/
j=(k*E^J)&U-9;                                /* try 8 consec. locations  */
W((h=A[++j].K)&&h-Z&&--i);                    /* first empty or match     */
a+=i?j:0;                                     /* dummy A[0] if miss & full*/
if(a->K)                                      /* hit: pos. is in hash tab */
{d=a->D;v=a->V;X=a->X;                        /* examine stored data      */
if(d>=n)                                     /* if depth sufficient:     */
{if(v>=l|X&S&&v<=q|X&8)return v;             /* use if window compatible */
d=n-1;                                      /* or use as iter. start    */
}X&=~M;Y=a->Y;                               /*      with best-move hint */
Y=d?Y:0;                                     /* don't try best at d=0    */
}else d=X=Y=0;                                /* start iter., no best yet */
N++;                                          /* node count (for timing)  */
W(d++<n|z==8&N<1e7&d<98)                      /* iterative deepening loop */
{x=B=X;                                       /* start scan at prev. best */
Y|=8&Y>>4;                                   /* request try noncastl. 1st*/
m=d>1?-I:e;                                  /* unconsidered:static eval */
do{u=b[x];                                   /* scan board looking for   */
if(u&k)                                     /*  own piece (inefficient!)*/
{r=p=u&7;                                   /* p = piece type (set r>0) */
j=o[p+16];                                 /* first step vector f.piece*/
W(r=p>2&r<0?-r:-o[++j])                    /* loop over directions o[] */
{A:                                        /* resume normal after best */
y=x;F=G=S;                                /* (x,y)=move, (F,G)=castl.R*/
do{H=y+=r;                                /* y traverses ray          */
if(Y&8)H=y=Y&~M;                         /* sneak in prev. best move */
if(y&M)break;                            /* board edge hit           */
if(p<3&y==E)H=y^16;                      /* shift capt.sqr. H if e.p.*/
t=b[H];if(t&k|p<3&!(r&7)!=!t)break;      /* capt. own, bad pawn mode */
i=99*w[t&7];                             /* value of capt. piece t   */
if(i<0||E-S&&b[E]&&y-E<2&E-y<2)m=I;      /* K capt. or bad castling  */
if(m>=l)goto C;                          /* abort on fail high       */

if(h=d-(y!=z))                           /* remaining depth(-recapt.)*/
{v=p<6?b[x+8]-b[y+8]:0;                  /* center positional pts.   */
b[G]=b[H]=b[x]=0;b[y]=u&31;             /* do move, strip virgin-bit*/
if(!(G&M)){b[F]=k+6;v+=30;}             /* castling: put R & score  */
if(p<3)                                 /* pawns:                   */
{v-=9*(((x-2)&M||b[x-2]!=u)+            /* structure, undefended    */
((x+2)&M||b[x+2]!=u)-1);         /*        squares plus bias */
if(y+r+1&S){b[y]|=7;i+=C;}             /* promote p to Q, add score*/
}
v=-D(24-k,-l-(l>e),m>q?-m:-q,-e-v-i,    /* recursive eval. of reply */
J+J(0),Z+J(8)+G-S,F,y,h);          /* J,Z: hash keys           */
v-=v>e;                                 /* delayed-gain penalty     */
if(z==9)                                /* called as move-legality  */
{if(v!=-I&x==K&y==L)                    /*   checker: if move found */
{Q=-e-i;O=F;return l;}                 /*   & not in check, signal */
v=m;                                   /* (prevent fail-lows on    */
}                                       /*   K-capt. replies)       */
b[G]=k+38;b[F]=b[y]=0;b[x]=u;b[H]=t;    /* undo move,G can be dummy */
if(Y&8){m=v;Y&=~8;goto A;}              /* best=1st done,redo normal*/
if(v>m){m=v;X=x;Y=y|S&G;}               /* update max, mark with S  */
}                                        /*          if non castling */
t+=p<5;                                  /* fake capt. for nonsliding*/
if(p<3&6*k+(y&V)==S                      /* pawn on 3rd/6th, or      */
||(u&~24)==36&j==7&&                 /* virgin K moving sideways,*/
G&M&&b[G=(x|7)-(r>>1&7)]&32          /* 1st, virgin R in corner G*/
&&!(b[G^1]|b[G^2])                   /* 2 empty sqrs. next to R  */
){F=y;t--;}                              /* unfake capt., enable e.p.*/
}W(!t);                                   /* if not capt. continue ray*/
}}}W((x=x+9&~M)-B);                          /* next sqr. of board, wrap */
C:if(m>I/4|m<-I/4)d=99;                        /* mate is indep. of depth  */
m=m+I?m:-D(24-k,-I,I,0,J,Z,S,z,1)/2;         /* best loses K: (stale)mate*/
if(!a->K|(a->X&M)!=M|a->D<=d)                /* if new/better type/depth:*/
{a->K=Z;a->V=m;a->D=d;A->K=0;                /* store in hash,dummy stays*/
a->X=X|8*(m>q)|S*(m<l);a->Y=Y;              /* empty, type (limit/exact)*/
}                                            /*    encoded in X S,8 bits */
/*if(z==8)printf("%2d ply, %9d searched, %6d by (%2x,%2x)\n",d-1,N,m,X,Y&0x77);*/
}
if(z&8){K=X;L=Y&~M;}
return m;
}

main()
{
int j,k=8,*p,c[9];

F(i,0,8)
{b[i]=(b[i+V]=o[i+24]+40)+8;b[i+16]=18;b[i+96]=9;   /* initial board setup*/
F(j,0,8)b[16*j+i+8]=(i-4)*(i-4)+(j-3.5)*(j-3.5);   /* center-pts table   */
}                                                   /*(in unused half b[])*/
F(i,M,1035)T[i]=random()>>9;

W(1)                                                /* play loop          */
{F(i,0,121)printf(" %c",i&8&&(i+=7)?10:n[b[i]&15]); /* print board        */
p=c;W((*p++=getchar())>10);                        /* read input line    */
N=0;
if(*c-10){K=c[0]-16*c[1]+C;L=c[2]-16*c[3]+C;}else  /* parse entered move */
D(k,-I,I,Q,1,1,O,8,0);                            /* or think up one    */
F(i,0,U)A[i].K=0;                                  /* clear hash table   */
if(D(k,-I,I,Q,1,1,O,9,2)==I)k^=24;                 /* check legality & do*/
}
}
```

Note that castling also requires some extra code in the do_move and undo_move section, to move the Rook in addition to the King, (which uses the normal mechanism). In the undo part a Rook of the proper color is 'synthesized' through `k+36`, (the 36 = 32 + 4 being the code for Rook plus the virgin bit), and put back in the corner G. The latter is set to the dummy square for non-castlings, hence this code does not have to be executed conditionally (hich is good for size as wel as speed!).

```Previous   Next
```