/**
* @brief main
*
* @param argc
* @param argv[]
*
* @return
*/
int main ( int argc, char *argv[] ) {
char board[N][N] = { {0,0} };
// int *player = &Player;
int x = 0, y =0;
int flag = 2;
status s = -1;
CreateBoard(board);
while ( true ) {
PrintBoard(board, x, y);
PrintInfo(flag, Player);
if ( s == WIN ) {
printf ( "\033[33mSome one win!\n\033[0m" );
break;
}
s = PlayChess(board, Player, &x, &y);
if ( s == -1 ) continue;
if ( s == RES ) {
printf ( "Someone rescinded!\n" );
}
if ( s == QUIT ) {
printf ( "Gave Over\n" );
break;
}
s = CheckBoard(board, Player, &x,&y);
Player = ( Player + 1 ) % 2;
}
return EXIT_SUCCESS;
} /* ---------- end of function main ---------- */
void PerftTest(int depth, S_BOARD *pos) {
S_MOVELIST list[1];
int move;
int MoveNum = 0;
int start = GetTimeMs();
long cumnodes, oldnodes;
ASSERT(CheckBoard(pos));
PrintBoard(pos);
printf("\nStarting Test To Depth:%d\n", depth);
leafNodes = 0;
GenerateAllMoves(pos, list);
for(MoveNum = 0; MoveNum < list->count; ++MoveNum) {
move = list->moves[MoveNum].move;
if(!MakeMove(pos, move))
continue;
cumnodes = leafNodes;
Perft(depth - 1, pos);
TakeMove(pos);
oldnodes = leafNodes - cumnodes;
printf("move %d : %s : %ld\n", MoveNum + 1, PrMove(move), oldnodes);
}
printf("\nTest Complete : %ld nodes visited in %dms\n", leafNodes, GetTimeMs() - start);
}
// next move, moves to a different player
// the NextMove function
void NextMove()
{
if(Player == 1)
{
Player = 2;
}
else
{
Player = 1;
}
Drop.Play();
int Winner = 0;
if(CheckBoard(Winner) == true)
{
GameOver = true;
GameWinner = Winner;
if(GameWinner == 0)
{
CatsGameSound.Play();
}
else
{
GameOverSound.Play();
}
}
}
void Queen(int * board, int n)
{
Stack * StateStack;
if ( CreateStack(&StateStack, sizeof(State), n * n) == false )
{
printf("Loi: Khong du bo nho!\n");
exit(0);
}
int i, k;
i = 0;
k = 0;
State * state;
do
{
if (k < n)
{
for (i = 0; i < n; ++i)
{
state = CreateState(k, i);
push(StateStack, state);
}
}
state = pop(StateStack);
k = state->k;
i = state->i;
board[k] = i;
free(state);
if (k == n - 1)
{
do
{
if (CheckBoard(board, n) == true)
{
Mark(board, n);
}
state = pop(StateStack);
k = state->k;
i = state->i;
board[k] = i;
free(state);
} while (k == n-1);
}
++k;
} while (CheckEmpty(StateStack) != true);
DestroyStack(StateStack);
}
static void AddEnPassantMove(const CHESS_BOARD *pos, int move, MOVELIST *list) {
ASSERT(SqOnBoard(FROMSQ(move)));
ASSERT(SqOnBoard(TOSQ(move)));
ASSERT(CheckBoard(pos));
ASSERT((RanksBrd[TOSQ(move)] == RANK_6 && pos->side == WHITE) || (RanksBrd[TOSQ(move)] == RANK_3 && pos->side == BLACK));
list->moves[list->count].move = move;
list->moves[list->count].score = 105 + 1000000;
list->count++;
}
static void AddCaptureMove(const CHESS_BOARD *pos, int move, MOVELIST *list) {
ASSERT(SqOnBoard(FROMSQ(move)));
ASSERT(SqOnBoard(TOSQ(move)));
ASSERT(PieceValid(CAPTURED(move)));
ASSERT(CheckBoard(pos));
list->moves[list->count].move = move;
list->moves[list->count].score = MvvLvaScores[CAPTURED(move)][pos->pieces[FROMSQ(move)]] + 1000000;
list->count++;
}
void InputMap(int *x,int*y)
{
int inputX,inputY;
char inpx[5],inpy[5];
/*手盤の反転*/
color = FlipColor(color);
CheckBoard();
while(1){
if(color == 1){
printf("BLACK TURN Pass -> -1\n");
}else{
printf("WHITE TURN Pass -> -1\n");
}
/*手の入力*/
printf("x -> ");
fgets(inpx,5,stdin);
inputX = atoi(inpx);
/* Pass */
if(inputX == -1){
move++;
printf("Pass\n");
break;
}
printf("y -> ");
fgets(inpy,5,stdin);
inputY = atoi(inpy);
if(inputX != 0 && inputY != 0 && inputX <= B_SIZE && inputY <= B_SIZE){
break;
}
printf("Try Again! Input is 1 ~ %d.\n",B_SIZE);
printf("If you want to exit,please enter -1 twice.\n");
}
if(inputX == -1 && color == 1){
*x = 0;
}else if(inputX == -1 && color == 2){
*y = 0;
}else{
*x = inputX;
*y = inputY;
}
}
static void AddBlackPawnMove(const CHESS_BOARD *pos, const int from, const int to, MOVELIST *list) {
ASSERT(SqOnBoard(from));
ASSERT(SqOnBoard(to));
ASSERT(CheckBoard(pos));
if (RanksBrd[from] == RANK_2) {
AddQuietMove(pos, MOVE(from, to, EMPTY, bQ, 0), list);
AddQuietMove(pos, MOVE(from, to, EMPTY, bR, 0), list);
AddQuietMove(pos, MOVE(from, to, EMPTY, bB, 0), list);
AddQuietMove(pos, MOVE(from, to, EMPTY, bN, 0), list);
}
else {
AddQuietMove(pos, MOVE(from, to, EMPTY, EMPTY, 0), list);
}
}
static void AddBlackPawnCapMove(const CHESS_BOARD *pos, const int from, const int to, const int cap, MOVELIST *list) {
ASSERT(PieceValidEmpty(cap));
ASSERT(SqOnBoard(from));
ASSERT(SqOnBoard(to));
ASSERT(CheckBoard(pos));
if (RanksBrd[from] == RANK_2) {
AddCaptureMove(pos, MOVE(from, to, cap, bQ, 0), list);
AddCaptureMove(pos, MOVE(from, to, cap, bR, 0), list);
AddCaptureMove(pos, MOVE(from, to, cap, bB, 0), list);
AddCaptureMove(pos, MOVE(from, to, cap, bN, 0), list);
}
else {
AddCaptureMove(pos, MOVE(from, to, cap, EMPTY, 0), list);
}
}
int ParseMove(char *ptrChar, CHESS_BOARD *pos) {
ASSERT(CheckBoard(pos));
if (ptrChar[1] > '8' || ptrChar[1] < '1') return NOMOVE;
if (ptrChar[3] > '8' || ptrChar[3] < '1') return NOMOVE;
if (ptrChar[0] > 'h' || ptrChar[0] < 'a') return NOMOVE;
if (ptrChar[2] > 'h' || ptrChar[2] < 'a') return NOMOVE;
int from = FR2SQ(ptrChar[0] - 'a', ptrChar[1] - '1');
int to = FR2SQ(ptrChar[2] - 'a', ptrChar[3] - '1');
ASSERT(SqOnBoard(from) && SqOnBoard(to));
MOVELIST list[1];
GenerateAllMoves(pos, list);
int MoveNum = 0;
int Move = 0;
int PromPce = EMPTY;
for (MoveNum = 0; MoveNum < list->count; ++MoveNum) {
Move = list->moves[MoveNum].move;
if (FROMSQ(Move) == from && TOSQ(Move) == to) {
PromPce = PROMOTED(Move);
if (PromPce != EMPTY) {
if (IsRQ(PromPce) && !IsBQ(PromPce) && ptrChar[4] == 'r') {
return Move;
}
else if (!IsRQ(PromPce) && IsBQ(PromPce) && ptrChar[4] == 'b') {
return Move;
}
else if (IsRQ(PromPce) && IsBQ(PromPce) && ptrChar[4] == 'q') {
return Move;
}
else if (IsKn(PromPce) && ptrChar[4] == 'n') {
return Move;
}
continue;
}
return Move;
}
}
return NOMOVE;
}
void KlondikeView::Cheat() {
for (short i = 0; i < 4; i++) {
fFoundationsColors[i] = i;
fFoundations[i] = 12;
}
for (short i = 0; i < 7; i++) {
_RemoveCardFromPile(i, fBoard[i]);
}
for (short i = 0; i < 24; i++) {
fStock[i]->fRevealed = true;
}
Invalidate();
CheckBoard();
}
void MirrorBoard(S_BOARD *pos) {
int tempPiecesArray[64];
int tempSide = pos->side^1;
int SwapPiece[13] = { EMPTY, bP, bN, bB, bR, bQ, bK, wP, wN, wB, wR, wQ, wK };
int tempCastlePerm = 0;
int tempEnPas = NO_SQ;
int sq;
int tp;
if (pos->castlePerm & WKCA) tempCastlePerm |= BKCA;
if (pos->castlePerm & WQCA) tempCastlePerm |= BQCA;
if (pos->castlePerm & BKCA) tempCastlePerm |= WKCA;
if (pos->castlePerm & BQCA) tempCastlePerm |= WQCA;
if (pos->enPas != NO_SQ) {
tempEnPas = SQ120(Mirror64[SQ64(pos->enPas)]);
}
for (sq = 0; sq < 64; sq++) {
tempPiecesArray[sq] = pos->pieces[SQ120(Mirror64[sq])];
}
ResetBoard(pos);
for (sq = 0; sq < 64; sq++) {
tp = SwapPiece[tempPiecesArray[sq]];
pos->pieces[SQ120(sq)] = tp;
}
pos->side = tempSide;
pos->castlePerm = tempCastlePerm;
pos->enPas = tempEnPas;
pos->posKey = GeneratePosKey(pos);
UpdateListsMaterial(pos);
ASSERT(CheckBoard(pos));
}
static void AddQuietMove(const CHESS_BOARD *pos, int move, MOVELIST *list) {
ASSERT(SqOnBoard(FROMSQ(move)));
ASSERT(SqOnBoard(TOSQ(move)));
ASSERT(CheckBoard(pos));
ASSERT(pos->ply >= 0 && pos->ply < MAXDEPTH);
list->moves[list->count].move = move;
if (pos->searchKillers[0][pos->ply] == move) {
list->moves[list->count].score = 900000;
}
else if (pos->searchKillers[1][pos->ply] == move) {
list->moves[list->count].score = 800000;
}
else {
list->moves[list->count].score = pos->searchHistory[pos->pieces[FROMSQ(move)]][TOSQ(move)];
}
list->count++;
}
void KlondikeView::Pulse()
{
if (fDoubleClick > -1)
fDoubleClick--;
if (fAutoPlayStarted) {
if (fAutoPlayCountdown > -1) {
fAutoPlayCountdown--;
return;
}
if (!MoveOneToFoundation()) {
fAutoPlayStarted = false;
CheckBoard();
}
Invalidate();
fAutoPlayCountdown = 1;
} else
fAutoPlayCountdown = -1;
}
void Perft(int depth, S_BOARD *pos) {
S_MOVELIST list[1];
int MoveNum = 0;
ASSERT(CheckBoard(pos));
if(depth == 0) {
leafNodes++;
return;
}
GenerateAllMoves(pos, list);
for(MoveNum = 0; MoveNum < list->count; ++MoveNum) {
if(!MakeMove(pos, list->moves[MoveNum].move)) {
continue;
}
Perft(depth - 1, pos);
TakeMove(pos);
}
return;
}
void KlondikeView::MouseUp(BPoint point)
{
if (fIsCardPicked) {
int hSpacing = _CardHSpacing();
short stack = (int)((point.x - hSpacing) / (CARD_WIDTH + hSpacing));
if (stack >= 3 && stack < 7 && point.y < 15 + CARD_HEIGHT) {
short foundation = stack - 3;
if (fPickedCard->fValue == 0)
fFoundationsColors[foundation] = fPickedCard->fColor;
if (fFoundationsColors[foundation] == fPickedCard->fColor
&& fPickedCard->fValue - fFoundations[foundation] == 1) {
fFoundations[foundation]++;
if (_FindLastUsed(fPickedCardBoardPos) != NULL)
_FindLastUsed(fPickedCardBoardPos)->fRevealed = true;
fPoints += 10;
CheckBoard();
} else
_AddCardToPile(fPickedCardBoardPos, fPickedCard);
}
else if (stack >= 0 && stack < 7 && (_FindLastUsed(stack) == NULL
|| (_FindLastUsed(stack)->fValue - fPickedCard->fValue == 1
&& _FindLastUsed(stack)->fIsColorRed
!= fPickedCard->fIsColorRed)) && fIsCardPicked
&& point.y > 2 * 15 + CARD_HEIGHT) {
// attach to stack, only kings on empty fields
if (!(fPickedCard-> fValue != 12 && fBoard[stack] == NULL)) {
_AddCardToPile(stack, fPickedCard);
// reveal last card from pile the cards were from
if (_FindLastUsed(fPickedCardBoardPos) != NULL) {
_FindLastUsed(fPickedCardBoardPos)->fRevealed = true;
if (stack != fPickedCardBoardPos)
fPoints += 5;
}
} else
_AddCardToPile(fPickedCardBoardPos, fPickedCard);
} else {
// reattach to old stack
_AddCardToPile(fPickedCardBoardPos, fPickedCard);
}
fIsCardPicked = false;
Invalidate();
return;
}
if (fIsWasteCardPicked) {
int hSpacing = _CardHSpacing();
short stack = (int)((point.x - hSpacing) / (CARD_WIDTH + hSpacing));
if (stack >= 3 && stack < 7 && point.y < 18 + CARD_HEIGHT) {
short foundation = stack - 3;
if (fPickedCard->fValue == 0)
fFoundationsColors[foundation] = fPickedCard->fColor;
if (fFoundationsColors[foundation] == fPickedCard->fColor
&& fPickedCard->fValue - fFoundations[foundation] == 1) {
fFoundations[foundation]++;
fPickedCard->fRevealed = true;
fWasteCard--;
while (fWasteCard != -1 && fStock[fWasteCard]->fRevealed)
fWasteCard--;
fPoints += 10;
CheckBoard();
}
}
else if (stack >= 0 && stack < 7 && (_FindLastUsed(stack) == NULL
|| _FindLastUsed(stack)->fValue - fPickedCard->fValue == 1)) {
// attach to stack, only kings on empty fields
if (!(fPickedCard-> fValue != 12 && fBoard[stack] == NULL)) {
_AddCardToPile(stack, fPickedCard);
fPickedCard->fRevealed = true;
fWasteCard--;
while (fWasteCard != -1 && fStock[fWasteCard]->fRevealed)
fWasteCard--;
fPoints += 5;
}
}
fIsWasteCardPicked = false;
Invalidate();
}
if (fIsFoundationCardPicked) {
int hSpacing = _CardHSpacing();
short stack = (int)((point.x - hSpacing) / (CARD_WIDTH + hSpacing));
if (stack >= 0 && stack < 7 && (_FindLastUsed(stack) == NULL
|| _FindLastUsed(stack)->fValue - fPickedCard->fValue == 1)) {
// attach to stack
_AddCardToPile(stack, fPickedCard);
if (fFoundations[fPickedCardBoardPos] == -1)
fFoundationsColors[fPickedCardBoardPos] = -1;
fPoints -= 15;
if (fPoints < 0)
fPoints = 0;
} else {
fFoundations[fPickedCardBoardPos]++;
}
fIsFoundationCardPicked = false;
Invalidate();
}
fMouseLock = false;
}
void KlondikeView::MouseDown(BPoint point)
{
if (fMouseLock)
return;
fMouseLock = true;
uint32 mouse;
GetMouse(&point, &mouse);
if (mouse == B_SECONDARY_MOUSE_BUTTON) {
// stop auto-play if it's started
if (fAutoPlayStarted) {
fAutoPlayStarted = false;
return;
}
if (fQuickAutoPlay) {
while(MoveOneToFoundation());
Invalidate();
CheckBoard();
}
else {
fAutoPlayStarted = true;
}
return;
}
int hSpacing = _CardHSpacing();
short stack = (int)((point.x - hSpacing) / (CARD_WIDTH + hSpacing));
if (point.x > (stack + 1) * (CARD_WIDTH + hSpacing))
return;
// stock
if (point.y < 15 + CARD_HEIGHT && point.y > 15
&& stack == 0 && point.x > hSpacing) {
int revealed = 0;
for (short i = 0; i < 24; i++)
if (fStock[i]->fRevealed)
revealed++;
if (revealed < 24 && ++fWasteCard == 24) {
fWasteCard = -1;
fPoints -= 100;
if (fPoints < 0)
fPoints = 0;
}
Invalidate();
return;
}
// pick up a card from waste
if (stack == 1 && point.y < 15 + CARD_HEIGHT) {
if (fWasteCard == -1)
return;
if (fDoubleClick == -1)
fDoubleClick = 1;
else if (fDoubleClick > -1) {
_MoveWasteToFoundation();
CheckBoard();
Invalidate();
fDoubleClick = -1;
return;
}
card* picked = fStock[fWasteCard];
fPickedCard = picked;
fIsWasteCardPicked = true;
BMessage msg(B_SIMPLE_DATA);
msg.AddPointer("view", this);
BBitmap* img = new BBitmap(
fCards[picked->fColor * CARDS_IN_SUIT + picked->fValue]);
DragMessage(&msg, img, B_OP_BLEND,
BPoint((int)(point.x - hSpacing) % (CARD_WIDTH + hSpacing),
point.y - 15));
Invalidate();
return;
}
// pick up a card from a foundation
if (stack > 2 && stack < 7 && point.y < 15 + CARD_HEIGHT) {
short foundation = stack - 3;
short value = fFoundations[foundation];
short color = fFoundationsColors[foundation];
if (fFoundations[foundation] == -1)
return;
// find picked card
for (short i = 0; i < CARDS_IN_DECK; i++) {
if (fAllCards[i]->fValue == value
&& fAllCards[i]->fColor == color)
fPickedCard = fAllCards[i];
}
BMessage msg(B_SIMPLE_DATA);
msg.AddPointer("view", this);
BBitmap* img = new BBitmap(
fCards[fPickedCard->fColor * CARDS_IN_SUIT + fPickedCard->fValue]);
fIsFoundationCardPicked = true;
fPickedCardBoardPos = foundation;
fFoundations[foundation]--;
DragMessage(&msg, img, B_OP_BLEND,
BPoint((int)(point.x - hSpacing) % (CARD_WIDTH + hSpacing),
point.y - 15));
Invalidate();
return;
}
// pick up a stack
if (stack < 7 && fBoard[stack] != NULL
&& point.x > hSpacing && point.y > 2 * 15 + CARD_HEIGHT) {
// find clicked on card
int cardNumber = 1;
card* picked = fBoard[stack];
while (picked->fNextCard != NULL) {
if (point.y - 18 * cardNumber - CARD_HEIGHT - 15 < 18) {
break;
}
picked = picked->fNextCard;
cardNumber++;
}
if (picked->fNextCard == NULL) {
// on last card, if below than not clicking on card
if (point.y - 18 * cardNumber - CARD_HEIGHT - 15 >= CARD_HEIGHT) {
return;
}
if (fDoubleClick == -1)
fDoubleClick = 1;
else if (fDoubleClick > -1 && fAutoPlayEnabled) {
MoveOneToFoundation(stack, stack);
CheckBoard();
Invalidate();
fDoubleClick = -1;
return;
}
}
if (picked->fRevealed == false)
return;
card* currentCard = picked->fNextCard;
card* lastCard = picked;
short pickedHeight = 1;
for (short i = 1; currentCard != NULL;
i++) {
pickedHeight++;
if (lastCard->fIsColorRed == currentCard->fIsColorRed)
return;
lastCard = currentCard;
currentCard = currentCard->fNextCard;
}
fPickedCardBoardPos = stack;
fPickedCard = picked;
fIsCardPicked = true;
_RemoveCardFromPile(stack, picked);
BMessage msg(B_SIMPLE_DATA);
msg.AddPointer("view", this);
BBitmap* img;
if (pickedHeight == 1)
img = new BBitmap(
fCards[picked->fColor * CARDS_IN_SUIT + picked->fValue]);
else {
img = new BBitmap(BRect(0, 0, CARD_WIDTH - 1,
CARD_HEIGHT + (pickedHeight - 1) * 18),
fBack[0]->ColorSpace(), true);
BView* imgView = new BView(img->Bounds(), NULL, 0, 0);
BRect destRect = fBack[0]->Bounds();
img->AddChild(imgView);
img->Lock();
currentCard = picked;
imgView->SetDrawingMode(B_OP_COPY);
imgView->DrawBitmap(fCards
[currentCard->fColor * CARDS_IN_SUIT + currentCard->fValue],
destRect);
destRect.top = (pickedHeight - 1) * 18;
destRect.bottom = destRect.top + CARD_HEIGHT;
imgView->DrawBitmap(fBack[0], destRect);
// we don't know the top card yet, so we'll overwrite this
imgView->SetDrawingMode(B_OP_ALPHA);
for (short j = 0; j < pickedHeight; j++) {
destRect.top = j * 18;
destRect.bottom = destRect.top + CARD_HEIGHT;
imgView->DrawBitmap(fCards[currentCard->fColor
* CARDS_IN_SUIT + currentCard->fValue], destRect);
currentCard = currentCard->fNextCard;
}
imgView->Sync();
img->Unlock();
img->RemoveChild(imgView);
delete imgView;
}
DragMessage(&msg, img, B_OP_BLEND,
BPoint((int)(point.x - hSpacing) % (CARD_WIDTH + hSpacing),
point.y - cardNumber * 18 - 131));
Invalidate();
}
}
void GenerateAllMoves(const CHESS_BOARD *pos, MOVELIST *list) {
ASSERT(CheckBoard(pos));
list->count = 0;
int pce = EMPTY;
int side = pos->side;
int sq = 0; int t_sq = 0;
int pceNum = 0;
int dir = 0;
int index = 0;
int pceIndex = 0;
if (side == WHITE) {
for (pceNum = 0; pceNum < pos->pieceNum[wP]; ++pceNum) {
sq = pos->pList[wP][pceNum];
ASSERT(SqOnBoard(sq));
if (pos->pieces[sq + 10] == EMPTY) {
AddWhitePawnMove(pos, sq, sq + 10, list);
if (RanksBrd[sq] == RANK_2 && pos->pieces[sq + 20] == EMPTY) {
AddQuietMove(pos, MOVE(sq, (sq + 20), EMPTY, EMPTY, MFLAGPS), list);
}
}
if (!SQOFFBOARD(sq + 9) && PieceCol[pos->pieces[sq + 9]] == BLACK) {
AddWhitePawnCapMove(pos, sq, sq + 9, pos->pieces[sq + 9], list);
}
if (!SQOFFBOARD(sq + 11) && PieceCol[pos->pieces[sq + 11]] == BLACK) {
AddWhitePawnCapMove(pos, sq, sq + 11, pos->pieces[sq + 11], list);
}
if (pos->enPas != NO_SQ) {
if (sq + 9 == pos->enPas) {
AddEnPassantMove(pos, MOVE(sq, sq + 9, EMPTY, EMPTY, MFLAGEP), list);
}
if (sq + 11 == pos->enPas) {
AddEnPassantMove(pos, MOVE(sq, sq + 11, EMPTY, EMPTY, MFLAGEP), list);
}
}
}
if (pos->castlePerm & WKCA) {
if (pos->pieces[F1] == EMPTY && pos->pieces[G1] == EMPTY) {
if (!SqAttacked(E1, BLACK, pos) && !SqAttacked(F1, BLACK, pos)) {
AddQuietMove(pos, MOVE(E1, G1, EMPTY, EMPTY, MFLAGCA), list);
}
}
}
if (pos->castlePerm & WQCA) {
if (pos->pieces[D1] == EMPTY && pos->pieces[C1] == EMPTY && pos->pieces[B1] == EMPTY) {
if (!SqAttacked(E1, BLACK, pos) && !SqAttacked(D1, BLACK, pos)) {
AddQuietMove(pos, MOVE(E1, C1, EMPTY, EMPTY, MFLAGCA), list);
}
}
}
}
else {
for (pceNum = 0; pceNum < pos->pieceNum[bP]; ++pceNum) {
sq = pos->pList[bP][pceNum];
ASSERT(SqOnBoard(sq));
if (pos->pieces[sq - 10] == EMPTY) {
AddBlackPawnMove(pos, sq, sq - 10, list);
if (RanksBrd[sq] == RANK_7 && pos->pieces[sq - 20] == EMPTY) {
AddQuietMove(pos, MOVE(sq, (sq - 20), EMPTY, EMPTY, MFLAGPS), list);
}
}
if (!SQOFFBOARD(sq - 9) && PieceCol[pos->pieces[sq - 9]] == WHITE) {
AddBlackPawnCapMove(pos, sq, sq - 9, pos->pieces[sq - 9], list);
}
if (!SQOFFBOARD(sq - 11) && PieceCol[pos->pieces[sq - 11]] == WHITE) {
AddBlackPawnCapMove(pos, sq, sq - 11, pos->pieces[sq - 11], list);
}
if (pos->enPas != NO_SQ) {
if (sq - 9 == pos->enPas) {
AddEnPassantMove(pos, MOVE(sq, sq - 9, EMPTY, EMPTY, MFLAGEP), list);
}
if (sq - 11 == pos->enPas) {
AddEnPassantMove(pos, MOVE(sq, sq - 11, EMPTY, EMPTY, MFLAGEP), list);
}
}
}
// castling
if (pos->castlePerm & BKCA) {
if (pos->pieces[F8] == EMPTY && pos->pieces[G8] == EMPTY) {
if (!SqAttacked(E8, WHITE, pos) && !SqAttacked(F8, WHITE, pos)) {
AddQuietMove(pos, MOVE(E8, G8, EMPTY, EMPTY, MFLAGCA), list);
}
}
}
if (pos->castlePerm & BQCA) {
if (pos->pieces[D8] == EMPTY && pos->pieces[C8] == EMPTY && pos->pieces[B8] == EMPTY) {
if (!SqAttacked(E8, WHITE, pos) && !SqAttacked(D8, WHITE, pos)) {
AddQuietMove(pos, MOVE(E8, C8, EMPTY, EMPTY, MFLAGCA), list);
}
}
}
}
/* Loop for slide pieces */
pceIndex = LoopSlideIndex[side];
pce = LoopSlidePce[pceIndex++];
while (pce != 0) {
ASSERT(PieceValid(pce));
for (pceNum = 0; pceNum < pos->pieceNum[pce]; ++pceNum) {
sq = pos->pList[pce][pceNum];
ASSERT(SqOnBoard(sq));
for (index = 0; index < NumDir[pce]; ++index) {
dir = PceDir[pce][index];
t_sq = sq + dir;
while (!SQOFFBOARD(t_sq)) {
// BLACK ^ 1 == WHITE WHITE ^ 1 == BLACK
if (pos->pieces[t_sq] != EMPTY) {
if (PieceCol[pos->pieces[t_sq]] == (side ^ 1)) {
AddCaptureMove(pos, MOVE(sq, t_sq, pos->pieces[t_sq], EMPTY, 0), list);
}
break;
}
AddQuietMove(pos, MOVE(sq, t_sq, EMPTY, EMPTY, 0), list);
t_sq += dir;
}
}
}
pce = LoopSlidePce[pceIndex++];
}
/* Loop for non slide */
pceIndex = LoopNonSlideIndex[side];
pce = LoopNonSlidePce[pceIndex++];
while (pce != 0) {
ASSERT(PieceValid(pce));
for (pceNum = 0; pceNum < pos->pieceNum[pce]; ++pceNum) {
sq = pos->pList[pce][pceNum];
ASSERT(SqOnBoard(sq));
for (index = 0; index < NumDir[pce]; ++index) {
dir = PceDir[pce][index];
t_sq = sq + dir;
if (SQOFFBOARD(t_sq)) {
continue;
}
// BLACK ^ 1 == WHITE WHITE ^ 1 == BLACK
if (pos->pieces[t_sq] != EMPTY) {
if (PieceCol[pos->pieces[t_sq]] == (side ^ 1)) {
AddCaptureMove(pos, MOVE(sq, t_sq, pos->pieces[t_sq], EMPTY, 0), list);
}
continue;
}
AddQuietMove(pos, MOVE(sq, t_sq, EMPTY, EMPTY, 0), list);
}
}
pce = LoopNonSlidePce[pceIndex++];
}
//ASSERT(MoveListOk(list, pos));
}
int IsSqAttack(int sq,int side,BOARD *board) {
ASSERT(sq>=0 && sq<120);
ASSERT(CheckBoard(board));
int pce,index,t_sq,dir;
if(board->Pieces[sq]==OFF)
return FALSE;
//make sure that the pce u are looking forward to be attack by is actually present on that square
//i.e the square is not OFF or EMPTY....
// pawns
if(side == WHITE)
{
if(board->Pieces[sq-11]==wP||board->Pieces[sq-9]==wP)
return TRUE;
}
else
{
if(board->Pieces[sq+11]==bP||board->Pieces[sq+9]==bP)
return TRUE;
}
// knights
for(index = 0; index < 8; ++index)
{
pce = board->Pieces[sq + KnDir[index]];
if(pce>=wP && pce<=bK && IsKnight[pce] && PceCol[pce]==side)
return TRUE;
}
// rooks, queens in rooks(horizontal,vertical) direction
for(index = 0; index < 4; ++index)
{
dir = RkDir[index];
t_sq = sq + dir;
pce = board->Pieces[t_sq];
while(pce != OFF)
{
if(pce != EMPTY)
{
if(IsRQ[pce] && PceCol[pce] == side)
return TRUE;
break;
}
t_sq += dir;
pce = board->Pieces[t_sq];
}
}
// bishops, queens in bishop(diagnol) direction
for(index = 0; index < 4; ++index)
{
dir = BiDir[index];
t_sq = sq + dir;
pce = board->Pieces[t_sq];
while(pce != OFF)
{
if(pce != EMPTY)
{
if(IsBQ[pce] && PceCol[pce] == side)
return TRUE;
break;
}
t_sq += dir;
pce = board->Pieces[t_sq];
}
}
// kings are the same as knights with 8 directions
for(index = 0; index < 8; ++index)
{
pce = board->Pieces[sq + KiDir[index]];
if(pce>=wP && pce<=bK && IsKing[pce] && PceCol[pce]==side)
return TRUE;
}
return FALSE;
}
INT_PTR CALLBACK DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (uMsg)
{
case WM_INITDIALOG:
{
SetEditsLimit(hwndDlg);
//SetEntireBoard(hwndDlg); // HACK(Daniel): this will set the entire displayed board to zero since the variable is initialized to zero
// NOTE(Daniel): if we uncomment it becomes annoying to enter new numbers
return TRUE;
} break;
case WM_COMMAND:
{
int control_code = HIWORD(wParam);
int control_identifier = LOWORD(wParam);
switch (control_identifier)
{
case ID_BTN_SOLVE:
{
GetEntireBoard(hwndDlg);
RecursiveBacktrackDS rbds = { 0, 0, true, false, false };
RecursiveBacktrackFill(&rbds);
if (rbds.impossible)
{
MessageBox(0, "Board has no solution...", "Message", 0);
}
SetEntireBoard(hwndDlg);
if (!CheckBoard())
{
MessageBox(0, "Board not Ok!!!", "Message", 0);
}
else
{
MessageBox(0, "Board Ok!!!", "Message", 0);
}
SetFocus(hwndDlg);
} break;
case ID_BTN_EXIT:
{
running = false;
} break;
}
return TRUE;
} break;
case WM_QUIT:
case WM_CLOSE:
{
running = false;
} break;
}
return FALSE;
}
void GenerateAllCaps(const CHESS_BOARD *pos, MOVELIST *list) {
ASSERT(CheckBoard(pos));
list->count = 0;
int pce = EMPTY;
int side = pos->side;
int sq = 0; int t_sq = 0;
int pceNum = 0;
int dir = 0;
int index = 0;
int pceIndex = 0;
if (side == WHITE) {
for (pceNum = 0; pceNum < pos->pieceNum[wP]; ++pceNum) {
sq = pos->pList[wP][pceNum];
ASSERT(SqOnBoard(sq));
if (!SQOFFBOARD(sq + 9) && PieceCol[pos->pieces[sq + 9]] == BLACK) {
AddWhitePawnCapMove(pos, sq, sq + 9, pos->pieces[sq + 9], list);
}
if (!SQOFFBOARD(sq + 11) && PieceCol[pos->pieces[sq + 11]] == BLACK) {
AddWhitePawnCapMove(pos, sq, sq + 11, pos->pieces[sq + 11], list);
}
if (pos->enPas != NO_SQ) {
if (sq + 9 == pos->enPas) {
AddEnPassantMove(pos, MOVE(sq, sq + 9, EMPTY, EMPTY, MFLAGEP), list);
}
if (sq + 11 == pos->enPas) {
AddEnPassantMove(pos, MOVE(sq, sq + 11, EMPTY, EMPTY, MFLAGEP), list);
}
}
}
}
else {
for (pceNum = 0; pceNum < pos->pieceNum[bP]; ++pceNum) {
sq = pos->pList[bP][pceNum];
ASSERT(SqOnBoard(sq));
if (!SQOFFBOARD(sq - 9) && PieceCol[pos->pieces[sq - 9]] == WHITE) {
AddBlackPawnCapMove(pos, sq, sq - 9, pos->pieces[sq - 9], list);
}
if (!SQOFFBOARD(sq - 11) && PieceCol[pos->pieces[sq - 11]] == WHITE) {
AddBlackPawnCapMove(pos, sq, sq - 11, pos->pieces[sq - 11], list);
}
if (pos->enPas != NO_SQ) {
if (sq - 9 == pos->enPas) {
AddEnPassantMove(pos, MOVE(sq, sq - 9, EMPTY, EMPTY, MFLAGEP), list);
}
if (sq - 11 == pos->enPas) {
AddEnPassantMove(pos, MOVE(sq, sq - 11, EMPTY, EMPTY, MFLAGEP), list);
}
}
}
}
/* Loop for slide pieces */
pceIndex = LoopSlideIndex[side];
pce = LoopSlidePce[pceIndex++];
while (pce != 0) {
ASSERT(PieceValid(pce));
for (pceNum = 0; pceNum < pos->pieceNum[pce]; ++pceNum) {
sq = pos->pList[pce][pceNum];
ASSERT(SqOnBoard(sq));
for (index = 0; index < NumDir[pce]; ++index) {
dir = PceDir[pce][index];
t_sq = sq + dir;
while (!SQOFFBOARD(t_sq)) {
// BLACK ^ 1 == WHITE WHITE ^ 1 == BLACK
if (pos->pieces[t_sq] != EMPTY) {
if (PieceCol[pos->pieces[t_sq]] == (side ^ 1)) {
AddCaptureMove(pos, MOVE(sq, t_sq, pos->pieces[t_sq], EMPTY, 0), list);
}
break;
}
t_sq += dir;
}
}
}
pce = LoopSlidePce[pceIndex++];
}
/* Loop for non slide */
pceIndex = LoopNonSlideIndex[side];
pce = LoopNonSlidePce[pceIndex++];
while (pce != 0) {
ASSERT(PieceValid(pce));
for (pceNum = 0; pceNum < pos->pieceNum[pce]; ++pceNum) {
sq = pos->pList[pce][pceNum];
ASSERT(SqOnBoard(sq));
for (index = 0; index < NumDir[pce]; ++index) {
dir = PceDir[pce][index];
t_sq = sq + dir;
if (SQOFFBOARD(t_sq)) {
continue;
}
// BLACK ^ 1 == WHITE WHITE ^ 1 == BLACK
if (pos->pieces[t_sq] != EMPTY) {
if (PieceCol[pos->pieces[t_sq]] == (side ^ 1)) {
AddCaptureMove(pos, MOVE(sq, t_sq, pos->pieces[t_sq], EMPTY, 0), list);
}
continue;
}
}
}
pce = LoopNonSlidePce[pceIndex++];
}
ASSERT(MoveListOk(list, pos));
}
