Hi Tommy,
s32 value[] = { OO, VP, VN, VB, VR, VR, VQ, VK, VK, VP, VN, VB, VR, VR, VQ, VK, VK,
OO, OO, Vb, Vr, Vn, OO, OO, Vq, Vb, Vr, Vn, Vq };
I remember the pattern. I did find and change it before but then forgot to change it again after a code rollback. Who knows when I'd have found it again. So, much thanks!
best wishes
Mike
I don't want to give up
Moderators: hgm, Rebel, chrisw
-
Mike Sherwin
- Posts: 860
- Joined: Fri Aug 21, 2020 1:25 am
- Location: Planet Earth, Sol system
- Full name: Michael J Sherwin
-
Mike Sherwin
- Posts: 860
- Joined: Fri Aug 21, 2020 1:25 am
- Location: Planet Earth, Sol system
- Full name: Michael J Sherwin
Re: I don't want to give up
Bric played its first statistically driven search. I posted the game in the General Topics, "Something new coming down the highway". Here is the code that produced that example game.
Code: Select all
// Bricabrac
// A chess engine by Michael J Sherwin
// TommyTC - Chief problem solver,bug squisher and ex honorary co-author
// Sven Schule - some bugs found
// HGM - help with branchless code
#include <intrin.h>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#define equates 1
#ifdef equates
typedef signed char s08;
typedef unsigned char u08;
typedef int s32;
typedef unsigned long u32;
typedef long long s64;
typedef unsigned long long u64;
constexpr auto one = 1ull;
constexpr auto INF = 0x7fff;
constexpr auto STOP = INF;
constexpr auto ColA = 0;
constexpr auto Row8 = 7;
constexpr auto ILLEGAL = 0x8000;
constexpr auto VP = 100;
constexpr auto VN = 300;
constexpr auto VB = 300;
constexpr auto VR = 500;
constexpr auto VQ = 900;
constexpr auto VK = 1600;
constexpr auto Vq = 800;
constexpr auto Vn = 200;
constexpr auto Vr = 400;
constexpr auto Vb = 200;
constexpr auto WOCCS = 0x0000000000000060;
constexpr auto WOCCL = 0x000000000000000e;
constexpr auto BOCCS = 0x6000000000000000;
constexpr auto BOCCL = 0x0e00000000000000;
constexpr auto WATKS = 0x0000000000000070;
constexpr auto WATKL = 0x000000000000001c;
constexpr auto BATKS = 0x7000000000000000;
constexpr auto BATKL = 0x1c00000000000000;
enum { BLACK, WHITE };
enum { B, R, N, Q };
enum {
OO, WP, WN, WB, WR, WRC, WQ, WK, WC, BP, BN, BB, BR, BRC, BQ, BK, BC,
Wd, We, Wb, Wr, Wn, Wq, Bd, Be, Bb, Br, Bn, Bq, WS, WL, BS, BL
};
enum { RANK1, RANK2, RANK3, RANK4, RANK5, RANK6, RANK7, RANK8 };
enum {
A1, B1, C1, D1, E1, F1, G1, H1,
A2, B2, C2, D2, E2, F2, G2, H2,
A3, B3, C3, D3, E3, F3, G3, H3,
A4, B4, C4, D4, E4, F4, G4, H4,
A5, B5, C5, D5, E5, F5, G5, H5,
A6, B6, C6, D6, E6, F6, G6, H6,
A7, B7, C7, D7, E7, F7, G7, H7,
A8, B8, C8, D8, E8, F8, G8, H8
};
enum { EXIT, GETCMD, BRICABRAC, MOVE };
#endif
#define definitions 1
#ifdef definitions
struct Move {
s32 fs;
s32 ts;
s32 type;
s32 score;
s64 stats[2];
s32 status;
};
struct Thread {
s32 wtm;
s32 ply;
s32 start;
s32 mat[2];
s32 board[64];
u64 piece[2];
u64 king[2];
u64 epbb[100];
s32 fifty[100];
Move move[10000];
Move* root;
};
#define wtm t->wtm
#define ply t->ply
#define fifty t->fifty
#define start t->start
#define mat t->mat
#define board t->board
#define piece t->piece
#define king t->king
#define epbb t->epbb
#define move t->move
#define root t->root
#endif
#define variables 1
#ifdef variables
Thread thread;
Thread* t;
s32 bricabrac;
s32 gamePly;
s32 sd;
u64 wPawnMoves[64];
u64 wPawnCapts[64];
u64 bPawnMoves[64];
u64 bPawnCapts[64];
u64 knightMoves[64];
u64 kingMoves[64];
u64 qss[64][256][8];
u64 bob[64];
u64 rob[64];
u64 above[65];
u64 below[65];
Move gameMoves[1000];
Move bestMove;
s32 value[] = { OO, VP, VN, VB, VR, VR, VQ, VK, VK, VP, VN, VB, VR, VR, VQ, VK, VK,
OO, OO, Vb, Vr, Vn, Vq, OO, OO, Vb, Vr, Vn, Vq };
u08 startFen[] = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1";
#endif
void PrintBoard(Thread* t) {
s32 x, y, sq, pce;
u08 fig[] = { ".PNBRRQKKpnbrrqkk" };
for (y = 7; y >= 0; y--) {
for (x = 0; x < 8; x++) {
sq = ((y << 3) + x);
pce = board[sq];
std::cout << " " << fig[pce];
}
std::cout << std::endl;
}
std::cout << std::endl;
}
s32 LoadFen(Thread* t, u08* f) {
s32 row, col, sq, fs, pce;
for (sq = A1; sq <= H8; sq++) board[sq] = OO;
col = ColA;
row = Row8;
fs = 56;
mat[WHITE] = OO;
mat[BLACK] = OO;
piece[WHITE] = OO;
piece[BLACK] = OO;
for (;; f++) {
if (*f == ' ') break;
switch (*f) {
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
col += *f - '0';
fs = (row * 8 + col) & 63;
continue;
case '/':
col = ColA;
row--;
fs = (row * 8 + col) & 63;
continue;
case 'P':
pce = WP;
mat[WHITE] += VP;
piece[WHITE] ^= one << fs;
break;
case 'N':
pce = WN;
mat[WHITE] += VN;
piece[WHITE] ^= one << fs;
break;
case 'B':
pce = WB;
mat[WHITE] += VB;
piece[WHITE] ^= one << fs;
break;
case 'R':
pce = WR;
mat[WHITE] += VR;
piece[WHITE] ^= one << fs;
break;
case 'Q':
pce = WQ;
mat[WHITE] += VQ;
piece[WHITE] ^= one << fs;
break;
case 'K':
pce = WK;
piece[WHITE] ^= one << fs;
king[WHITE] = one << fs;
break;
case 'p':
pce = BP;
mat[BLACK] += VP;
piece[BLACK] ^= one << fs;
break;
case 'n':
pce = BN;
mat[BLACK] += VN;
piece[BLACK] ^= one << fs;
break;
case 'b':
pce = BB;
mat[BLACK] += VB;
piece[BLACK] ^= one << fs;
break;
case 'r':
pce = BR;
mat[BLACK] += VR;
piece[BLACK] ^= one << fs;
break;
case 'q':
pce = BQ;
mat[BLACK] += VQ;
piece[BLACK] ^= one << fs;
break;
case 'k':
pce = BK;
piece[BLACK] ^= one << fs;
king[BLACK] = one << fs;
break;
default:
return false;
}
board[fs] = pce;
col++;
fs = (row * 8 + col) & 63;
}
f++;
switch (*f++) {
case 'w':
wtm = WHITE;
break;
case 'b':
wtm = BLACK;
break;
default:
return false;
}
if (*f++ != ' ') return false;
if (*f == '-') {
f++;
if (*f++ != ' ') return false;
}
else {
for (;;) {
if (*f == ' ') {
f++;
break;
}
switch (*f++) {
case 'K':
board[E1] = WC;
board[H1] = WRC;
break;
case 'Q':
board[E1] = WC;
board[A1] = WRC;
break;
case 'k':
board[E8] = BC;
board[H8] = BRC;
break;
case 'q':
board[E8] = BC;
board[A8] = BRC;
break;
default:
return false;
}
}
}
epbb[OO] = OO;
if (*f == '-') f++;
else {
if (*f < 'a' || *f > 'h') return false;
if (*(f + 1) < '0' || *(f + 1) > '7') return false;
row = *(f + 1) - '1';
col = *f - 'a';
epbb[OO] = one << (row * 8 + col);
f += 2;
}
if (*f++ != ' ') return false;
fifty[OO] = OO;
for (;;) {
if (!isdigit(*f)) break;
fifty[OO] *= 10;
fifty[OO] += *f++ - '0';
}
if (*f++ != ' ') return false;
start = 0;
for (;;) {
if (!isdigit(*f)) break;
start *= 10;
start += *f++ - '0';
}
if (start < 1) return false;
while (*f == ' ') f++;
if (*f != '\0') return false;
return true;
}
void MakeMove(Thread* t, Move* m) {
s32 ctype = 0, sq;
board[m->fs] = OO;
piece[wtm] ^= one << m->fs;
piece[wtm] ^= one << m->ts;
switch (m->type) {
case OO: break;
case WP:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WP;
break;
case WN:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WN;
break;
case WB:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WB;
break;
case WR:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WR;
break;
case WRC:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WR;
break;
case WQ:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WQ;
break;
case WK:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WK;
king[WHITE] ^= one << m->fs;
king[WHITE] ^= one << m->ts;
break;
case WC:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WK;
king[WHITE] ^= one << m->fs;
king[WHITE] ^= one << m->ts;
break;
case BP:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BP;
break;
case BN:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BN;
break;
case BB:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BB;
break;
case BR:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BR;
break;
case BRC:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BR;
break;
case BQ:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BQ;
break;
case BK:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BK;
king[BLACK] ^= one << m->fs;
king[BLACK] ^= one << m->ts;
break;
case BC:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BK;
king[BLACK] ^= one << m->fs;
king[BLACK] ^= one << m->ts;
break;
case Wd:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WP;
epbb[ply + 1] = (u64)(m->fs + 16 == m->ts) << (m->fs + 8);
break;
case We:
sq = m->ts - ((epbb[ply] == (one << m->ts)) << 3);
ctype = board[sq];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << sq;
board[sq] = OO;
board[m->ts] = WP;
break;
case Wb:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WB;
mat[WHITE] += 200;
break;
case Wr:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WR;
mat[WHITE] += 400;
break;
case Wn:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WN;
mat[WHITE] += 200;
break;
case Wq:
ctype = board[m->ts];
mat[BLACK] -= value[ctype];
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = WQ;
mat[WHITE] += 800;
break;
case Bd:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BP;
epbb[ply + 1] = (u64)(m->fs - 16 == m->ts) << (m->fs - 8);
break;
case Be:
sq = m->ts + ((epbb[ply] == (one << m->ts)) << 3);
ctype = board[sq];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << sq;
board[sq] = OO;
board[m->ts] = BP;
break;
case Bb:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BB;
mat[BLACK] += 200;
break;
case Br:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BR;
mat[BLACK] += 400;
break;
case Bn:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BN;
mat[BLACK] += 200;
break;
case Bq:
ctype = board[m->ts];
mat[WHITE] -= value[ctype];
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
board[m->ts] = BQ;
mat[BLACK] += 800;
break;
case WS:
ctype = OO;
board[G1] = WK;
board[H1] = OO;
board[F1] = WR;
king[WHITE] ^= one << E1;
king[WHITE] ^= one << G1;
piece[WHITE] ^= one << H1;
piece[WHITE] ^= one << F1;
break;
case WL:
ctype = OO;
board[C1] = WK;
board[A1] = OO;
board[D1] = WR;
king[WHITE] ^= one << E1;
king[WHITE] ^= one << C1;
piece[WHITE] ^= one << A1;
piece[WHITE] ^= one << D1;
break;
case BS:
ctype = OO;
board[G8] = BK;
board[H8] = OO;
board[F8] = BR;
king[BLACK] ^= one << E8;
king[BLACK] ^= one << G8;
piece[BLACK] ^= one << H8;
piece[BLACK] ^= one << F8;
break;
case BL:
ctype = OO;
board[C8] = BK;
board[A8] = OO;
board[D8] = BR;
king[BLACK] ^= one << E8;
king[BLACK] ^= one << C8;
piece[BLACK] ^= one << A8;
piece[BLACK] ^= one << D8;
break;
}
m->type |= ctype << 6;
wtm = 1 - wtm;
ply++;
}
void TakeBack(Thread* t, Move* m) {
s32 ctype, sq;
ply--;
wtm = 1 - wtm;
piece[wtm] ^= one << m->ts;
piece[wtm] ^= one << m->fs;
ctype = m->type >> 6;
mat[1 - wtm] += value[ctype];
m->type &= 0x3f;
switch (m->type) {
case OO: break;
case WP:
board[m->ts] = ctype;
board[m->fs] = WP;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WN:
board[m->ts] = ctype;
board[m->fs] = WN;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WB:
board[m->ts] = ctype;
board[m->fs] = WB;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WR:
board[m->ts] = ctype;
board[m->fs] = WR;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WRC:
board[m->ts] = ctype;
board[m->fs] = WRC;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WQ:
board[m->ts] = ctype;
board[m->fs] = WQ;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WK:
board[m->ts] = ctype;
board[m->fs] = WK;
king[WHITE] ^= one << m->fs;
king[WHITE] ^= one << m->ts;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case WC:
board[m->ts] = ctype;
board[m->fs] = WC;
king[WHITE] ^= one << m->fs;
king[WHITE] ^= one << m->ts;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case BP:
board[m->ts] = ctype;
board[m->fs] = BP;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BN:
board[m->ts] = ctype;
board[m->fs] = BN;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BB:
board[m->ts] = ctype;
board[m->fs] = BB;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BR:
board[m->ts] = ctype;
board[m->fs] = BR;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BRC:
board[m->ts] = ctype;
board[m->fs] = BRC;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BQ:
board[m->ts] = ctype;
board[m->fs] = BQ;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BK:
board[m->ts] = ctype;
board[m->fs] = BK;
king[BLACK] ^= one << m->fs;
king[BLACK] ^= one << m->ts;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case BC:
board[m->ts] = ctype;
board[m->fs] = BC;
king[BLACK] ^= one << m->fs;
king[BLACK] ^= one << m->ts;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Wd:
board[m->ts] = ctype;
board[m->fs] = WP;
epbb[ply + 1] = OO;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case We:
sq = m->ts - ((epbb[ply] == (one << m->ts)) << 3);
board[m->ts] = OO;
board[sq] = ctype;
piece[BLACK] ^= (u64)(ctype != OO) << sq;
board[m->fs] = WP;
break;
case Wb:
board[m->ts] = ctype;
board[m->fs] = WP;
mat[WHITE] -= 200;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case Wr:
board[m->ts] = ctype;
board[m->fs] = WP;
mat[WHITE] -= 400;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case Wn:
board[m->ts] = ctype;
board[m->fs] = WP;
mat[WHITE] -= 200;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case Wq:
board[m->ts] = ctype;
board[m->fs] = WP;
mat[WHITE] -= 800;
piece[BLACK] ^= (u64)(ctype != OO) << m->ts;
break;
case Bd:
board[m->ts] = ctype;
board[m->fs] = BP;
epbb[ply + 1] = OO;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Be:
sq = m->ts + ((epbb[ply] == (one << m->ts)) << 3);
board[m->ts] = OO;
board[sq] = ctype;
piece[WHITE] ^= (u64)(ctype != OO) << sq;
board[m->fs] = BP;
break;
case Bb:
board[m->ts] = ctype;
board[m->fs] = BP;
mat[BLACK] -= 200;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Br:
board[m->ts] = ctype;
board[m->fs] = BP;
mat[BLACK] -= 400;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Bn:
board[m->ts] = ctype;
board[m->fs] = BP;
mat[BLACK] -= 200;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case Bq:
board[m->ts] = ctype;
board[m->fs] = BP;
mat[BLACK] -= 800;
piece[WHITE] ^= (u64)(ctype != OO) << m->ts;
break;
case WS:
board[G1] = OO;
board[E1] = WC;
board[H1] = WRC;
board[F1] = OO;
king[WHITE] ^= one << G1;
king[WHITE] ^= one << E1;
piece[WHITE] ^= one << H1;
piece[WHITE] ^= one << F1;
break;
case WL:
board[C1] = OO;
board[E1] = WC;
board[A1] = WRC;
board[D1] = OO;
king[WHITE] ^= one << C1;
king[WHITE] ^= one << E1;
piece[WHITE] ^= one << A1;
piece[WHITE] ^= one << D1;
break;
case BS:
board[G8] = OO;
board[E8] = BC;
board[H8] = BRC;
board[F8] = OO;
king[BLACK] ^= one << G8;
king[BLACK] ^= one << E8;
piece[BLACK] ^= one << H8;
piece[BLACK] ^= one << F8;
break;
case BL:
board[C8] = OO;
board[E8] = BC;
board[A8] = BRC;
board[D8] = OO;
king[BLACK] ^= one << C8;
king[BLACK] ^= one << E8;
piece[BLACK] ^= one << A8;
piece[BLACK] ^= one << D8;
break;
}
}
s32 AtkByWhite(Thread* t, u64 bb) {
u32 ts, fs;
u64 b, aPieces = piece[WHITE] | piece[BLACK];
do {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
b = bPawnCapts[ts];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WP) return true;
}
b = knightMoves[ts] & piece[WHITE];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WN) return true;
}
b = kingMoves[ts];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WK) return true;
}
b = qss[ts][(aPieces >> (ts & 56)) & 127][0]
& qss[ts][(aPieces >> 8) & 255][1]
& qss[ts][(aPieces >> 16) & 255][2]
& qss[ts][(aPieces >> 24) & 255][3]
& qss[ts][(aPieces >> 32) & 255][4]
& qss[ts][(aPieces >> 40) & 255][5]
& qss[ts][(aPieces >> 48) & 255][6]
& bob[ts]
& piece[WHITE];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WB || board[fs] == WQ) return true;
}
b = qss[ts][(aPieces >> (ts & 56)) & 127][0]
& qss[ts][(aPieces >> 8) & 255][1]
& qss[ts][(aPieces >> 16) & 255][2]
& qss[ts][(aPieces >> 24) & 255][3]
& qss[ts][(aPieces >> 32) & 255][4]
& qss[ts][(aPieces >> 40) & 255][5]
& qss[ts][(aPieces >> 48) & 255][6]
& rob[ts]
& piece[WHITE];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == WR || board[fs] == WQ) return true;
}
} while (bb);
return false;
}
s32 AtkByBlack(Thread* t, u64 bb) {
u32 ts, fs;
u64 b, aPieces = piece[WHITE] | piece[BLACK];
do {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
b = wPawnCapts[ts];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BP) return true;
}
b = knightMoves[ts] & piece[BLACK];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BN) return true;
}
b = kingMoves[ts];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BK) return true;
}
b = qss[ts][(aPieces >> (ts & 56)) & 127][0]
& qss[ts][(aPieces >> 8) & 255][1]
& qss[ts][(aPieces >> 16) & 255][2]
& qss[ts][(aPieces >> 24) & 255][3]
& qss[ts][(aPieces >> 32) & 255][4]
& qss[ts][(aPieces >> 40) & 255][5]
& qss[ts][(aPieces >> 48) & 255][6]
& bob[ts]
& piece[BLACK];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BB || board[fs] == BQ) return true;
}
b = qss[ts][(aPieces >> (ts & 56)) & 127][0]
& qss[ts][(aPieces >> 8) & 255][1]
& qss[ts][(aPieces >> 16) & 255][2]
& qss[ts][(aPieces >> 24) & 255][3]
& qss[ts][(aPieces >> 32) & 255][4]
& qss[ts][(aPieces >> 40) & 255][5]
& qss[ts][(aPieces >> 48) & 255][6]
& rob[ts]
& piece[BLACK];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BR || board[fs] == BQ) return true;
}
} while (bb);
return false;
}
__forceinline s32 Sort(Thread* t, Move* m) {
s32 i, mi = 0, high = -INF;
Move* mov;
for (i = 0; (m + i)->status != STOP; i++) {
mov = m + i;
if (mov->status == false && mov->score > high) {
high = mov->score;
mi = i;
}
}
(m + mi)->status = true;
return mi;
}
__forceinline s32 Qsort(Thread* t, Move* m, s32 n) {
s32 i = 0, high = -INF;
Move* mov;
for (; n > OO; n--) {
mov = m - n;
if (!mov->status && mov->score > high) {
high = mov->score;
i = n;
}
}
(m - i)->status = true;
return i;
}
s32 Qsearch(Thread* t, Move* m, s32 alpha, s32 beta) {
s32 n, i, mi, type, score;
u32 fs, ts;
u64 bb, captures, pieces, aPieces, enemy, empty;
Move* mov;
score = mat[wtm] - mat[1 - wtm];
if (score >= beta) return beta;
if (score > alpha) alpha = score;
n = 0;
bb = 0;
captures = 0;
pieces = piece[wtm];
aPieces = piece[BLACK] | piece[WHITE];
enemy = aPieces ^ pieces;
empty = 0xffffffffffffffff ^ aPieces;
do {
_BitScanForward64(&fs, pieces);
pieces ^= one << fs;
type = board[fs];
switch (type) {
case OO: break;
case WP:
switch (fs >> 3) {
case RANK1: break;
case RANK2:
case RANK3:
case RANK4:
case RANK6:
bb = wPawnCapts[fs] & enemy;
break;
case RANK5:
bb = wPawnCapts[fs] & (enemy | epbb[ply]);
type = We;
break;
case RANK7:
bb = (wPawnMoves[fs] & empty) | (wPawnCapts[fs] & enemy);
if (bb & king[1 - wtm]) return -ILLEGAL;
while (bb) {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
for (i = Q; i >= B; i--) {
m->fs = (s32)fs;
m->ts = (s32)ts;
m->type = Wb + i;
m->score = (value[board[ts]] << 4) + value[m->type];
m->status = false;
m++;
}
n += 4;
}
continue;
}
break;
case WN:
case BN:
bb = knightMoves[fs] & enemy;
break;
case WB:
case BB:
bb = qss[fs][(aPieces >> (fs & 56)) & 127][0]
& qss[fs][(aPieces >> 8) & 255][1]
& qss[fs][(aPieces >> 16) & 255][2]
& qss[fs][(aPieces >> 24) & 255][3]
& qss[fs][(aPieces >> 32) & 255][4]
& qss[fs][(aPieces >> 40) & 255][5]
& qss[fs][(aPieces >> 48) & 255][6]
& bob[fs]
& enemy;
break;
case WR:
case WRC:
case BR:
case BRC:
bb = qss[fs][(aPieces >> (fs & 56)) & 127][0]
& qss[fs][(aPieces >> 8) & 255][1]
& qss[fs][(aPieces >> 16) & 255][2]
& qss[fs][(aPieces >> 24) & 255][3]
& qss[fs][(aPieces >> 32) & 255][4]
& qss[fs][(aPieces >> 40) & 255][5]
& qss[fs][(aPieces >> 48) & 255][6]
& rob[fs]
& enemy;
break;
case WQ:
case BQ:
bb = qss[fs][(aPieces >> (fs & 56)) & 127][0]
& qss[fs][(aPieces >> 8) & 255][1]
& qss[fs][(aPieces >> 16) & 255][2]
& qss[fs][(aPieces >> 24) & 255][3]
& qss[fs][(aPieces >> 32) & 255][4]
& qss[fs][(aPieces >> 40) & 255][5]
& qss[fs][(aPieces >> 48) & 255][6]
& enemy;
break;
case WK:
case BK:
case WC:
case BC:
bb = kingMoves[fs] & enemy;
break;
case BP:
switch (fs >> 3) {
case RANK1:
break;
case RANK2:
bb = (bPawnMoves[fs] & empty) | (bPawnCapts[fs] & enemy);
if (bb & king[1 - wtm]) return -ILLEGAL;
while (bb) {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
for (i = Q; i >= B; i--) {
m->fs = (s32)fs;
m->ts = (s32)ts;
m->type = Bb + i;
m->score = (value[board[ts]] << 4) + value[m->type];
m->status = false;
m++;
}
n += 4;
}
continue;
case RANK3:
case RANK5:
case RANK6:
case RANK7:
bb = bPawnCapts[fs] & enemy;
break;
case RANK4:
bb = bPawnCapts[fs] & (enemy | epbb[ply]);
type = Be;
break;
}
break;
}
captures |= bb;
while (bb) {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
m->fs = (s32)fs;
m->ts = (s32)ts;
m->type = type;
m->score = (value[board[ts]] << 4) - value[m->type];
m->status = false;
m++;
n++;
}
} while (pieces);
if (captures & king[1 - wtm]) return -ILLEGAL;
for (i = n; i > OO; i--) {
mi = Qsort(t, m, n);
mov = (m - mi);
MakeMove(t, mov);
mov->score = -Qsearch(t, m, -beta, -alpha);
TakeBack(t, mov);
if (mov->score == ILLEGAL) continue;
if (mov->score > alpha) {
if (mov->score >= beta) {
return beta;
}
alpha = mov->score;
}
}
return alpha;
}
u64 GenMoves(Thread* t, Move* m) {
s32 i, type, score = -INF;
u32 fs, ts, sq;
u64 bb = 0, captures = 0;
Move* n = m;
u64 pieces = piece[wtm];
u64 aPieces = piece[BLACK] | piece[WHITE];
u64 enemy = aPieces ^ pieces;
u64 empty = 0xffffffffffffffff ^ aPieces;
u64 notme = 0xffffffffffffffff ^ pieces;
do {
_BitScanForward64(&fs, pieces);
pieces ^= one << fs;
type = board[fs];
switch (type) {
case OO:
break;
case WP:
switch (fs >> 3) {
case RANK1: break;
case RANK2:
_BitScanForward64(&sq, wPawnMoves[fs] & aPieces);
bb = (wPawnMoves[fs] & below[sq]) | (wPawnCapts[fs] & enemy);
type = Wd;
break;
case RANK3:
case RANK4:
case RANK6:
bb = (wPawnMoves[fs] & empty) | (wPawnCapts[fs] & enemy);
break;
case RANK5:
bb = (wPawnMoves[fs] & empty) | (wPawnCapts[fs] & (enemy | epbb[ply]));
type = We;
break;
case RANK7:
bb = (wPawnMoves[fs] & empty) | (wPawnCapts[fs] & enemy);
if (bb & king[1 - wtm]) return OO;
while (bb) {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
for (i = Q; i >= B; i--) {
m->fs = (s32)fs;
m->ts = (s32)ts;
m->type = Wb + i;
m->score = (value[board[m->ts]] << 4) - VP;
m->status = false;
m++;
}
}
continue;
}
break;
case WN:
case BN:
bb = knightMoves[fs] & notme;
break;
case WB:
case BB:
bb = qss[fs][(aPieces >> (fs & 56)) & 127][0]
& qss[fs][(aPieces >> 8) & 255][1]
& qss[fs][(aPieces >> 16) & 255][2]
& qss[fs][(aPieces >> 24) & 255][3]
& qss[fs][(aPieces >> 32) & 255][4]
& qss[fs][(aPieces >> 40) & 255][5]
& qss[fs][(aPieces >> 48) & 255][6]
& bob[fs]
& notme;
break;
case WR:
case WRC:
case BR:
case BRC:
bb = qss[fs][(aPieces >> (fs & 56)) & 127][0]
& qss[fs][(aPieces >> 8) & 255][1]
& qss[fs][(aPieces >> 16) & 255][2]
& qss[fs][(aPieces >> 24) & 255][3]
& qss[fs][(aPieces >> 32) & 255][4]
& qss[fs][(aPieces >> 40) & 255][5]
& qss[fs][(aPieces >> 48) & 255][6]
& rob[fs]
& notme;
break;
case WQ:
case BQ:
bb = qss[fs][(aPieces >> (fs & 56)) & 127][0]
& qss[fs][(aPieces >> 8) & 255][1]
& qss[fs][(aPieces >> 16) & 255][2]
& qss[fs][(aPieces >> 24) & 255][3]
& qss[fs][(aPieces >> 32) & 255][4]
& qss[fs][(aPieces >> 40) & 255][5]
& qss[fs][(aPieces >> 48) & 255][6]
& notme;
break;
case WK:
case BK:
bb = kingMoves[fs] & notme;
break;
case WC:
bb = kingMoves[fs] & notme;
if (board[H1] == WRC && !(WOCCS & aPieces) && !AtkByBlack(t, WATKS)) {
m->fs = E1;
m->ts = G1;
m->type = WS;
m->score = 1000;
m->status = false;
m++;
}
if (board[A1] == WRC && !(WOCCL & aPieces) && !AtkByBlack(t, WATKL)) {
m->fs = E1;
m->ts = C1;
m->type = WL;
m->score = 1000;
m->status = false;
m++;
}
break;
case BP:
switch (fs >> 3) {
case RANK1:
break;
case RANK2:
bb = (bPawnMoves[fs] & empty) | (bPawnCapts[fs] & enemy);
if (bb & king[1 - wtm]) return OO;
while (bb) {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
for (i = Q; i >= B; i--) {
m->fs = (s32)fs;
m->ts = (s32)ts;
m->type = Bb + i;
m->score = (value[board[m->ts]] << 4) - VP;
m->status = false;
m++;
}
}
continue;
case RANK3:
case RANK5:
case RANK6:
bb = (bPawnMoves[fs] & empty) | (bPawnCapts[fs] & enemy);
break;
case RANK4:
bb = (bPawnMoves[fs] & empty) | (bPawnCapts[fs] & (enemy | epbb[ply]));
type = Be;
break;
case RANK7:
_BitScanReverse64(&sq, bPawnMoves[fs] & aPieces);
bb = (bPawnMoves[fs] & above[sq]) | (bPawnCapts[fs] & enemy);
type = Bd;
break;
}
break;
case BC:
bb = kingMoves[fs] & notme;
if (board[H8] == BRC && !(BOCCS & aPieces) && !AtkByWhite(t, BATKS)) {
m->fs = E8;
m->ts = G8;
m->type = BS;
m->score = 1000;
m->status = false;
m++;
}
if (board[A8] == BRC && !(BOCCL & aPieces) && !AtkByWhite(t, BATKL)) {
m->fs = E8;
m->ts = C8;
m->type = BL;
m->score = 1000;
m->status = false;
m++;
}
break;
}
captures |= bb;
while (bb) {
_BitScanForward64(&ts, bb);
bb ^= one << ts;
m->fs = (s32)fs;
m->ts = (s32)ts;
m->type = type;
m->score = (value[board[m->ts]] << 4) - value[board[m->fs]];
m->status = false;
m++;
}
} while (pieces);
if (captures & king[1 - wtm]) return OO;
m->status = STOP;
m++;
return m - n;
}
s32 Search(Thread* t, Move* m, s32 alpha, s32 beta, s32 depth) {
s32 i, mi;
u64 n;
Move* mov;
n = GenMoves(t, m);
if (!n) return -ILLEGAL;
depth--;
for (i = 0; (m + i)->status != STOP; i++) {
mi = Sort(t, m);
mov = m + mi;
MakeMove(t, mov);
if (!depth) {
mov->score = -Qsearch(t, m + n, -beta, -alpha);
}
else {
mov->score = -Search(t, m + n, -beta, -alpha, depth);
}
TakeBack(t, mov);
if (mov->score == ILLEGAL) continue;
if (mov->score >= beta) {
root->stats[1 - wtm]++;
return beta;
}
if (mov->score > alpha) {
alpha = mov->score;
}
}
return alpha;
}
s32 RootSearch(Thread* t, Move* m, s32 alpha, s32 beta, s32 depth) {
s32 i, mi;
u64 n;
Move* mov;
s64 stats1, stats2;
n = GenMoves(t, m);
if (!n) return -ILLEGAL;
depth--;
bestMove.score = -INF;
for (i = 0; (m + i)->status != STOP; i++) {
mi = Sort(t, m);
mov = m + mi;
root = mov;
root->stats[WHITE] = OO;
root->stats[BLACK] = OO;
MakeMove(t, mov);
if (!depth) {
mov->score = -Qsearch(t, m + n, -beta, -alpha);
}
else {
mov->score = -Search(t, m + n, -beta, -alpha, depth);
}
TakeBack(t, mov);
if (mov->score == ILLEGAL) continue;
if (mov->score > bestMove.score) {
alpha = mov->score - 1;
bestMove.fs = mov->fs;
bestMove.ts = mov->ts;
bestMove.type = mov->type;
bestMove.score = mov->score;
bestMove.stats[wtm] = mov->stats[wtm];
bestMove.stats[1 - wtm] = mov->stats[1 - wtm];
}
else
if (mov->score == bestMove.score) {
stats1 = mov->stats[wtm] - mov->stats[1 - wtm];
stats2 = bestMove.stats[wtm] - bestMove.stats[1 - wtm];
if (stats1 > stats2) {
bestMove.fs = mov->fs;
bestMove.ts = mov->ts;
bestMove.type = mov->type;
bestMove.stats[wtm] = mov->stats[wtm];
bestMove.stats[1 - wtm] = mov->stats[1 - wtm];
}
}
}
return alpha;
}
void Bricabrac(Thread* t) {
RootSearch(t, &move[0], -INF, INF, sd);
bricabrac = MOVE;
}
void GetCmd(Thread* t) {
s32 match, i, fs, ts;
u64 n, epbit;
char data[256], mvstr[20];
match = false;
epbit = epbb[1];
PrintBoard(t);
fgets(data, 256, stdin);
_strlwr_s(data);
std::cout << std::endl;
if (data[0] >= 'a' && data[0] <= 'h' &&
data[1] >= '1' && data[1] <= '8' &&
data[2] >= 'a' && data[2] <= 'h' &&
data[3] >= '1' && data[3] <= '8') {
epbb[0] = epbit;
n = GenMoves(t, &move[0]);
for (i = OO; i < n; i++) {
fs = move[i].fs;
ts = move[i].ts;
sprintf_s(mvstr, 20, "%c%d%c%d\n", (fs & 7) + 'a', (fs >> 3) + 1, (ts & 7) + 'a', (ts >> 3) + 1);
if (!strcmp(data, mvstr)) {
gameMoves[gamePly].fs = fs;
gameMoves[gamePly].ts = ts;
gameMoves[gamePly].type = move[i].type;
MakeMove(t, &gameMoves[gamePly]);
epbb[0] = epbit;
gamePly++;
ply--;
return;
}
}
return;
}
if (!strcmp(data, "go\n")) {
bricabrac = BRICABRAC;
return;
}
if (!strcmp(data, "u\n") || !strcmp(data, "undo\n")) {
gamePly--;
ply++;
TakeBack(t, &gameMoves[gamePly]);
return;
}
}
void DoMove(Thread* t) {
s32 i, j = 0, score;
score = -INF;
if (bestMove.score != ILLEGAL) {
// TommyTC
printf("\nMove Played: ");
printf("%c%c", 'A' + (bestMove.fs & 7), '1' + (bestMove.fs >> 3));
printf("%c%c\n", 'A' + (bestMove.ts & 7), '1' + (bestMove.ts >> 3));
gameMoves[gamePly].fs = bestMove.fs;
gameMoves[gamePly].ts = bestMove.ts;
gameMoves[gamePly].type = bestMove.type;
MakeMove(t, &gameMoves[gamePly]);
epbb[0] = epbb[1];
ply--;
gamePly++;
}
bricabrac = GETCMD;
}
void InitializeQSS() {
u08 sq, sqr, k, l;
s08 x, y, dx, dy;
s32 i;
u64 b, bb;
for (sq = 0; sq < 64; sq++) {
y = sq >> 3;
x = sq & 7;
bob[sq] = 0;
rob[sq] = 0;
for (i = 0; i < 256; i++) {
for (k = 0, l = 0; k <= 56; k += 8, l++) {
bb = 0;
b = (u64)i << k;
for (dx = +1, dy = +1; x + dx < +8 && y + dy < +8; dx++, dy++) {
sqr = (((y + dy) << 3) + x + dx);
bb |= one << sqr;
bob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = -1, dy = +1; x + dx > -1 && y + dy < +8; dx--, dy++) {
sqr = (((y + dy) << 3) + x + dx);
bb |= one << sqr;
bob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = +1, dy = -1; x + dx < +8 && y + dy > -1; dx++, dy--) {
sqr = (((y + dy) << 3) + x + dx);
bb |= one << sqr;
bob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = -1, dy = -1; x + dx > -1 && y + dy > -1; dx--, dy--) {
sqr = (((y + dy) << 3) + x + dx);
bb |= one << sqr;
bob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = -1; x + dx > -1; dx--) {
sqr = (y << 3) + x + dx;
bb |= one << sqr;
rob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = +1; x + dx < +8; dx++) {
sqr = (y << 3) + x + dx;
bb |= one << sqr;
rob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dy = +1; y + dy < +8; dy++) {
sqr = ((y + dy) << 3) + x;
bb |= one << sqr;
rob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dy = -1; y + dy > -1; dy--) {
sqr = ((y + dy) << 3) + x;
bb |= one << sqr;
rob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
qss[sq][i][l] = bb;
}
}
}
}
void InitializeRNK() {
u08 sq, sqr, i;
s08 x, y, dx, dy;
u64 bb, b;
for (sq = 0; sq < 64; sq++) {
y = sq >> 3;
x = sq & 7;
for (i = 0; i < 128; i++) {
bb = 0;
b = (u64)i << (sq & 56);
for (dx = +1, dy = +1; x + dx < +8 && y + dy < +8; dx++, dy++) {
sqr = (((y + dy) << 3) + x + dx);
bb |= one << sqr;
bob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = -1, dy = +1; x + dx > -1 && y + dy < +8; dx--, dy++) {
sqr = (((y + dy) << 3) + x + dx);
bb |= one << sqr;
bob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = +1, dy = -1; x + dx < +8 && y + dy > -1; dx++, dy--) {
sqr = (((y + dy) << 3) + x + dx);
bb |= one << sqr;
bob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = -1, dy = -1; x + dx > -1 && y + dy > -1; dx--, dy--) {
sqr = (((y + dy) << 3) + x + dx);
bb |= one << sqr;
bob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = -1; x + dx > -1; dx--) {
sqr = (y << 3) + x + dx;
bb |= one << sqr;
rob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dx = +1; x + dx < +8; dx++) {
sqr = (y << 3) + x + dx;
bb |= one << sqr;
rob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dy = +1; y + dy < +8; dy++) {
sqr = ((y + dy) << 3) + x;
bb |= one << sqr;
rob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
for (dy = -1; y + dy > -1; dy--) {
sqr = ((y + dy) << 3) + x;
bb |= one << sqr;
rob[sq] |= one << sqr;
if ((one << sqr) & b) break;
}
qss[sq][i][0] = bb;
}
}
}
void InitPieceBB() {
s32 sq, x, y;
above[0] = 0xfffffffffffffffe;
below[0] = 0xffffffffffffffff;
for (sq = A1; sq <= H8; sq++) {
x = sq & 7;
y = sq >> 3;
above[sq + 1] = ((0xffffffffffffffff >> (sq + 1)) ^ 1) << (sq + 1);
below[sq + 1] = ((0xffffffffffffffff >> (sq + 1)) << (sq + 1)) ^ 0xffffffffffffffff;
wPawnMoves[sq] = 0;
wPawnCapts[sq] = 0;
bPawnMoves[sq] = 0;
bPawnCapts[sq] = 0;
if (sq > H1 && sq < A8) {
// White Pawn Moves
wPawnMoves[sq] |= one << (sq + 8);
if (sq < A3) wPawnMoves[sq] |= one << (sq + 16);
// White Pawn Captures
if (x + 1 < +8) wPawnCapts[sq] |= one << (sq + 9);
if (x - 1 > -1) wPawnCapts[sq] |= one << (sq + 7);
// Black Pawn Moves
bPawnMoves[sq] |= one << (sq - 8);
if (sq > H6) bPawnMoves[sq] |= one << (sq - 16);
// Black Pawn Captures
if (x + 1 < +8) bPawnCapts[sq] |= one << (sq - 7);
if (x - 1 > -1) bPawnCapts[sq] |= one << (sq - 9);
}
// Knight Moves
knightMoves[sq] = 0;
if (y + 2 < +8 && x + 1 < +8) knightMoves[sq] |= one << (sq + 17);
if (y + 1 < +8 && x + 2 < +8) knightMoves[sq] |= one << (sq + 10);
if (y - 1 > -1 && x + 2 < +8) knightMoves[sq] |= one << (sq - +6);
if (y - 2 > -1 && x + 1 < +8) knightMoves[sq] |= one << (sq - 15);
if (y - 2 > -1 && x - 1 > -1) knightMoves[sq] |= one << (sq - 17);
if (y - 1 > -1 && x - 2 > -1) knightMoves[sq] |= one << (sq - 10);
if (y + 1 < +8 && x - 2 > -1) knightMoves[sq] |= one << (sq + +6);
if (y + 2 < +8 && x - 1 > -1) knightMoves[sq] |= one << (sq + 15);
// King Moves
kingMoves[sq] = 0;
if (y + 1 < +8) kingMoves[sq] |= one << (sq + 8);
if (y - 1 > -1) kingMoves[sq] |= one << (sq - 8);
if (x + 1 < +8) kingMoves[sq] |= one << (sq + 1);
if (x - 1 > -1) kingMoves[sq] |= one << (sq - 1);
if (y + 1 < +8 && x + 1 < +8) kingMoves[sq] |= one << (sq + 9);
if (y - 1 > -1 && x + 1 < +8) kingMoves[sq] |= one << (sq - 7);
if (y - 1 > -1 && x - 1 > -1) kingMoves[sq] |= one << (sq - 9);
if (y + 1 < +8 && x - 1 > -1) kingMoves[sq] |= one << (sq + 7);
}
InitializeQSS();
InitializeRNK();
}
void NewGame(Thread* t) {
LoadFen(t, startFen);
}
void Initialize() {
bricabrac = GETCMD;
gamePly = OO;
wtm = WHITE;
ply = OO;
InitPieceBB();
NewGame(t);
}
// TommyTC
void SetSearchDepth()
{
char data[256];
int x = 0;
printf("Enter SEARCH DEPTH (sd): \n");
fgets(data, 4, stdin);
while ((data[x] >= '0') && (data[x] <= '9')) {
sd = 10 * sd + (data[x++] - '0');
}
}
s32 main() {
printf("TOMDEBUG: %i\n\n", 3);
SetSearchDepth(); // TommyTC
t = &thread;
Initialize();
do {
if (bricabrac == BRICABRAC) Bricabrac(t);
if (bricabrac == MOVE) DoMove(t);
GetCmd(t);
} while (bricabrac);
return 0;
}-
TommyTC
- Posts: 38
- Joined: Thu Mar 30, 2017 8:52 am
Re: I don't want to give up
Hi Mike,
(I created this message before your most recent post a few minutes ago about Bricabrac playing its first game.)
Before implementing iterative deepening (ID), I think you should first fix the program to recognize stalemate and checkmate positions. Not just after the search is complete, but during the search process.
Here are the reasons why you should do this first:
1. If it's easy, well why not?
2. If it's hard, it will be harder to fix after ID.
I am seeing something bad near the end of the depth 2 "default" game (one played from the starting position and just entering "go" at every move). White has several moves to play. After searching some moves, a move is found that stalemates the opponent. At that point, the move that stalemates is given a score of +INF. When the next move in the list is searched by White, the alpha-beta window is now [+INF, +INF]. This means no other move will ever evaluate to better than stalemate, not even a checkmating move.
Here is the end of the game. After B6A5, white has many moves including G1G6 (Rg6) which stalemates, whereas G8D8 (Qd8) checkmates. (This output is generated by some of my "debug" code.)
Move Played: B6A5
. . . . . . Q B
. . . . . . . .
. . . . . . . .
k . . . . . . .
. . . . . . . R
. . . . . . . .
. . . . B . . .
. . K . . . R .
go
0: C1B1 Score: Infinite order: 58
1: C1D1 Score: Infinite order: 59
2: C1B2 Score: Infinite order: 60
3: C1C2 Score: Infinite order: 61
4: C1D2 Score: Infinite order: 62
5: G1D1 Score: 2500 order: 16
6: G1E1 Score: 2500 order: 17
7: G1F1 Score: 2500 order: 18
8: G1H1 Score: 2500 order: 19
9: G1G2 Score: 2500 order: 20
10: G1G3 Score: 2500 order: 21
11: G1G4 Score: 2500 order: 22
12: G1G5 Score: 2500 order: 23
13: G1G6 Score: Infinite order: 24
14: G1G7 Score: Infinite order: 25
15: E2D1 Score: 2500 order: 0
16: E2F1 Score: 2500 order: 1
17: E2D3 Score: 2500 order: 2
18: E2F3 Score: 2500 order: 3
19: E2C4 Score: 2500 order: 4
20: E2G4 Score: 2500 order: 5
21: E2B5 Score: 2500 order: 6
22: E2H5 Score: 2500 order: 7
23: E2A6 Score: 2500 order: 8
24: H4H1 Score: Infinite order: 26
25: H4H2 Score: Infinite order: 27
26: H4H3 Score: Infinite order: 28
27: H4A4 Score: Infinite order: 29
28: H4B4 Score: Infinite order: 30
29: H4C4 Score: Infinite order: 31
30: H4D4 Score: Infinite order: 32
31: H4E4 Score: Infinite order: 33
32: H4F4 Score: Infinite order: 34
33: H4G4 Score: Infinite order: 35
34: H4H5 Score: Infinite order: 36
35: H4H6 Score: Infinite order: 37
36: H4H7 Score: Infinite order: 38
37: G8A2 Score: Infinite order: 39
38: G8G2 Score: Infinite order: 40
39: G8B3 Score: Infinite order: 41
40: G8G3 Score: Infinite order: 42
41: G8C4 Score: Infinite order: 43
42: G8G4 Score: Infinite order: 44
43: G8D5 Score: Infinite order: 45
44: G8G5 Score: Infinite order: 46
45: G8E6 Score: Infinite order: 47
46: G8G6 Score: Infinite order: 48
47: G8F7 Score: Infinite order: 49
48: G8G7 Score: Infinite order: 50
49: G8H7 Score: Infinite order: 51
50: G8A8 Score: Infinite order: 52
51: G8B8 Score: Infinite order: 53
52: G8C8 Score: Infinite order: 54
53: G8D8 Score: Infinite order: 55
54: G8E8 Score: Infinite order: 56
55: G8F8 Score: Infinite order: 57
56: H8A1 Score: 2500 order: 9
57: H8B2 Score: 2500 order: 10
58: H8C3 Score: 2500 order: 11
59: H8D4 Score: 2500 order: 12
60: H8E5 Score: 2500 order: 13
61: H8F6 Score: 2500 order: 14
62: H8G7 Score: 2500 order: 15
Move Played: G1G6
. . . . . . Q B
. . . . . . . .
. . . . . . R .
k . . . . . . .
. . . . . . . R
. . . . . . . .
. . . . B . . .
. . K . . . . .
go
0: A5A4 Score: Illegal order: 0
1: A5B4 Score: Illegal order: 1
2: A5B5 Score: Illegal order: 2
3: A5A6 Score: Illegal order: 3
4: A5B6 Score: Illegal order: 4
Move Played: G1G6
. . . . . . Q B
. . . . . . . .
. . . . . . R .
k . . . . . . .
. . . . . . . R
. . . . . . . .
. . . . B . . .
. . K . . . . .
Tommy
(I created this message before your most recent post a few minutes ago about Bricabrac playing its first game.)
Before implementing iterative deepening (ID), I think you should first fix the program to recognize stalemate and checkmate positions. Not just after the search is complete, but during the search process.
Here are the reasons why you should do this first:
1. If it's easy, well why not?
2. If it's hard, it will be harder to fix after ID.
I am seeing something bad near the end of the depth 2 "default" game (one played from the starting position and just entering "go" at every move). White has several moves to play. After searching some moves, a move is found that stalemates the opponent. At that point, the move that stalemates is given a score of +INF. When the next move in the list is searched by White, the alpha-beta window is now [+INF, +INF]. This means no other move will ever evaluate to better than stalemate, not even a checkmating move.
Here is the end of the game. After B6A5, white has many moves including G1G6 (Rg6) which stalemates, whereas G8D8 (Qd8) checkmates. (This output is generated by some of my "debug" code.)
Move Played: B6A5
. . . . . . Q B
. . . . . . . .
. . . . . . . .
k . . . . . . .
. . . . . . . R
. . . . . . . .
. . . . B . . .
. . K . . . R .
go
0: C1B1 Score: Infinite order: 58
1: C1D1 Score: Infinite order: 59
2: C1B2 Score: Infinite order: 60
3: C1C2 Score: Infinite order: 61
4: C1D2 Score: Infinite order: 62
5: G1D1 Score: 2500 order: 16
6: G1E1 Score: 2500 order: 17
7: G1F1 Score: 2500 order: 18
8: G1H1 Score: 2500 order: 19
9: G1G2 Score: 2500 order: 20
10: G1G3 Score: 2500 order: 21
11: G1G4 Score: 2500 order: 22
12: G1G5 Score: 2500 order: 23
13: G1G6 Score: Infinite order: 24
14: G1G7 Score: Infinite order: 25
15: E2D1 Score: 2500 order: 0
16: E2F1 Score: 2500 order: 1
17: E2D3 Score: 2500 order: 2
18: E2F3 Score: 2500 order: 3
19: E2C4 Score: 2500 order: 4
20: E2G4 Score: 2500 order: 5
21: E2B5 Score: 2500 order: 6
22: E2H5 Score: 2500 order: 7
23: E2A6 Score: 2500 order: 8
24: H4H1 Score: Infinite order: 26
25: H4H2 Score: Infinite order: 27
26: H4H3 Score: Infinite order: 28
27: H4A4 Score: Infinite order: 29
28: H4B4 Score: Infinite order: 30
29: H4C4 Score: Infinite order: 31
30: H4D4 Score: Infinite order: 32
31: H4E4 Score: Infinite order: 33
32: H4F4 Score: Infinite order: 34
33: H4G4 Score: Infinite order: 35
34: H4H5 Score: Infinite order: 36
35: H4H6 Score: Infinite order: 37
36: H4H7 Score: Infinite order: 38
37: G8A2 Score: Infinite order: 39
38: G8G2 Score: Infinite order: 40
39: G8B3 Score: Infinite order: 41
40: G8G3 Score: Infinite order: 42
41: G8C4 Score: Infinite order: 43
42: G8G4 Score: Infinite order: 44
43: G8D5 Score: Infinite order: 45
44: G8G5 Score: Infinite order: 46
45: G8E6 Score: Infinite order: 47
46: G8G6 Score: Infinite order: 48
47: G8F7 Score: Infinite order: 49
48: G8G7 Score: Infinite order: 50
49: G8H7 Score: Infinite order: 51
50: G8A8 Score: Infinite order: 52
51: G8B8 Score: Infinite order: 53
52: G8C8 Score: Infinite order: 54
53: G8D8 Score: Infinite order: 55
54: G8E8 Score: Infinite order: 56
55: G8F8 Score: Infinite order: 57
56: H8A1 Score: 2500 order: 9
57: H8B2 Score: 2500 order: 10
58: H8C3 Score: 2500 order: 11
59: H8D4 Score: 2500 order: 12
60: H8E5 Score: 2500 order: 13
61: H8F6 Score: 2500 order: 14
62: H8G7 Score: 2500 order: 15
Move Played: G1G6
. . . . . . Q B
. . . . . . . .
. . . . . . R .
k . . . . . . .
. . . . . . . R
. . . . . . . .
. . . . B . . .
. . K . . . . .
go
0: A5A4 Score: Illegal order: 0
1: A5B4 Score: Illegal order: 1
2: A5B5 Score: Illegal order: 2
3: A5A6 Score: Illegal order: 3
4: A5B6 Score: Illegal order: 4
Move Played: G1G6
. . . . . . Q B
. . . . . . . .
. . . . . . R .
k . . . . . . .
. . . . . . . R
. . . . . . . .
. . . . B . . .
. . K . . . . .
Tommy
-
Mike Sherwin
- Posts: 860
- Joined: Fri Aug 21, 2020 1:25 am
- Location: Planet Earth, Sol system
- Full name: Michael J Sherwin
Re: I don't want to give up
Hi Tommy,
I don't want to belabor my health problems. I may live another 10 years or I may be gone tomorrow. The most important short term goal I had was to demonstrate Statistical driven search. It was not a very good demonstration but at least other chess authors could get a glimpse into its potential. Hopefully I can soon show a more convincing demonstration!
And a more convincing demonstration will require what you posted above as well as a totally bug free (hopefully) engine. So now I will get back on track working on the things you have pointed out!
THANKS!
Mike
I don't want to belabor my health problems. I may live another 10 years or I may be gone tomorrow. The most important short term goal I had was to demonstrate Statistical driven search. It was not a very good demonstration but at least other chess authors could get a glimpse into its potential. Hopefully I can soon show a more convincing demonstration!
And a more convincing demonstration will require what you posted above as well as a totally bug free (hopefully) engine. So now I will get back on track working on the things you have pointed out!
THANKS!
Mike
-
TommyTC
- Posts: 38
- Joined: Thu Mar 30, 2017 8:52 am
Re: I don't want to give up
Hi Mike,
I'm still working with your code from Sep 29 after you inserted RootSearch. I've found a move generation bug.
From the starting position, "perft 1" to "perft 7" all match perfectly.
I then tested the "Kiwipete" position:
r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -
[d]r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -
I've never tried to fix a move generation bug before, but after a lot of investigation I tracked it down to 2 routines with bad code.
Here is a game that shows the bug:
1. h4 g5 2. hxg5 Nh6 3. gxh6 Bg7 4. hxg7
Bricabrac allows 4...0-0, which is illegal.
AtkByBlack() and AtkByWhite() each have a simlar bug.
AtkByBlack()
wPawnCapts[] is defined as an array indexed by a square containing a White pawn resulting in a bb of attacked squares for the White pawn.
ts is the "king square(s)" being checked, so it is always on the first rank of the castling side. Therefore wPawnCapts[ts] is always 0 here.
If AtkByBlack() and AtkByWhite() are going to be used ONLY for checking castling, then the following will work for AtkByBlack():
If they are going to be used for other purposes, then you might need something like:
=====
Other topics:
Currently Bricabrac doesn't support entering a move for pawn underpromotion (e.g., c7c8/r). At some point you should update GetCmd() to allow it.
You might want to implement "Perft" and "Fen" commands. Perhaps you are planning on implementing UCI and/or XBoard?
Kind Regards,
Tommy
I'm still working with your code from Sep 29 after you inserted RootSearch. I've found a move generation bug.
From the starting position, "perft 1" to "perft 7" all match perfectly.
I then tested the "Kiwipete" position:
r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -
[d]r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -
Code: Select all
Depth Nodes Bricabrac
1 48 48
2 2039 2039
3 97862 97898
Here is a game that shows the bug:
1. h4 g5 2. hxg5 Nh6 3. gxh6 Bg7 4. hxg7
Bricabrac allows 4...0-0, which is illegal.
AtkByBlack() and AtkByWhite() each have a simlar bug.
AtkByBlack()
Code: Select all
b = wPawnCapts[ts];
while (b) {
_BitScanForward64(&fs, b);
b ^= one << fs;
if (board[fs] == BP) return true;
}
ts is the "king square(s)" being checked, so it is always on the first rank of the castling side. Therefore wPawnCapts[ts] is always 0 here.
If AtkByBlack() and AtkByWhite() are going to be used ONLY for checking castling, then the following will work for AtkByBlack():
Code: Select all
if (
(board[ts + 7] == BP) ||
(board[ts + 9] == BP)
) {
return true;
}
Code: Select all
if (
((ts & 7) != 0) && (board[ts + 7] == BP) ||
(((ts+1) & 7) != 0) && (board[ts + 9] == BP)
) {
return true;
}
Other topics:
Currently Bricabrac doesn't support entering a move for pawn underpromotion (e.g., c7c8/r). At some point you should update GetCmd() to allow it.
You might want to implement "Perft" and "Fen" commands. Perhaps you are planning on implementing UCI and/or XBoard?
Kind Regards,
Tommy
-
Mike Sherwin
- Posts: 860
- Joined: Fri Aug 21, 2020 1:25 am
- Location: Planet Earth, Sol system
- Full name: Michael J Sherwin
Re: I don't want to give up
Hi Tommy,TommyTC wrote: ↑Sun Oct 04, 2020 9:29 pm Hi Mike,
I'm still working with your code from Sep 29 after you inserted RootSearch. I've found a move generation bug.
From the starting position, "perft 1" to "perft 7" all match perfectly.
I then tested the "Kiwipete" position:
r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -
[d]r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -I've never tried to fix a move generation bug before, but after a lot of investigation I tracked it down to 2 routines with bad code.Code: Select all
Depth Nodes Bricabrac 1 48 48 2 2039 2039 3 97862 97898
Here is a game that shows the bug:
1. h4 g5 2. hxg5 Nh6 3. gxh6 Bg7 4. hxg7
Bricabrac allows 4...0-0, which is illegal.
AtkByBlack() and AtkByWhite() each have a simlar bug.
AtkByBlack()wPawnCapts[] is defined as an array indexed by a square containing a White pawn resulting in a bb of attacked squares for the White pawn.Code: Select all
b = wPawnCapts[ts]; while (b) { _BitScanForward64(&fs, b); b ^= one << fs; if (board[fs] == BP) return true; }
ts is the "king square(s)" being checked, so it is always on the first rank of the castling side. Therefore wPawnCapts[ts] is always 0 here.
If AtkByBlack() and AtkByWhite() are going to be used ONLY for checking castling, then the following will work for AtkByBlack():If they are going to be used for other purposes, then you might need something like:Code: Select all
if ( (board[ts + 7] == BP) || (board[ts + 9] == BP) ) { return true; }=====Code: Select all
if ( ((ts & 7) != 0) && (board[ts + 7] == BP) || (((ts+1) & 7) != 0) && (board[ts + 9] == BP) ) { return true; }
Other topics:
Currently Bricabrac doesn't support entering a move for pawn underpromotion (e.g., c7c8/r). At some point you should update GetCmd() to allow it.
You might want to implement "Perft" and "Fen" commands. Perhaps you are planning on implementing UCI and/or XBoard?
Kind Regards,
Tommy
Aha, I understand. All I have to do is extend the pawn initialization code to generate pawn moves from the first and last ranks. I've tried to add checkmate and stalemate several times and it worked for two go commands and then the search breaks. I'm going to try again and if I can't get it to work I'm going to yell at it. But first I'll add the commands.
THANKS!
Mike
-
TommyTC
- Posts: 38
- Joined: Thu Mar 30, 2017 8:52 am
Re: I don't want to give up
Currently AtkByWhite() and AtkByBlack() are used only for checking castling privileges. If they are used for other purposes there is a problem:
These routines currently do not check for WC, WRC, BC, BRC. When those pieces attack a square, it is not detected.
Tommy
These routines currently do not check for WC, WRC, BC, BRC. When those pieces attack a square, it is not detected.
Tommy
-
TommyTC
- Posts: 38
- Joined: Thu Mar 30, 2017 8:52 am
Re: I don't want to give up
Another bug. The e.p. flag gets lost after "go" and then "undo".
I haven't had a chance to review your e.p. changes on 9/29/2020.
Tommy
I haven't had a chance to review your e.p. changes on 9/29/2020.
Code: Select all
TOMDEBUG: 3
Enter SEARCH DEPTH (sd):
1
r n b q k b n r
p p p p p p p p
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
P P P P P P P P
R N B Q K B N R
e2e4
r n b q k b n r
p p p p p p p p
. . . . . . . .
. . . . . . . .
. . . . P . . .
. . . . . . . .
P P P P . P P P
R N B Q K B N R
b8a6
r . b q k b n r
p p p p p p p p
n . . . . . . .
. . . . . . . .
. . . . P . . .
. . . . . . . .
P P P P . P P P
R N B Q K B N R
e4e5
r . b q k b n r
p p p p p p p p
n . . . . . . .
. . . . P . . .
. . . . . . . .
. . . . . . . .
P P P P . P P P
R N B Q K B N R
d7d5
r . b q k b n r
p p p . p p p p
n . . . . . . .
. . . p P . . .
. . . . . . . .
. . . . . . . .
P P P P . P P P
R N B Q K B N R
go
Move Played: F1A6
r . b q k b n r
p p p . p p p p
B . . . . . . .
. . . p P . . .
. . . . . . . .
. . . . . . . .
P P P P . P P P
R N B Q K . N R
u
r . b q k b n r
p p p . p p p p
n . . . . . . .
. . . p P . . .
. . . . . . . .
. . . . . . . .
P P P P . P P P
R N B Q K B N R
e5d6
r . b q k b n r
p p p . p p p p
n . . . . . . .
. . . p P . . .
. . . . . . . .
. . . . . . . .
P P P P . P P P
R N B Q K B N R
-
Mike Sherwin
- Posts: 860
- Joined: Fri Aug 21, 2020 1:25 am
- Location: Planet Earth, Sol system
- Full name: Michael J Sherwin
Re: I don't want to give up
Hi Tommy,TommyTC wrote: ↑Tue Oct 06, 2020 5:15 am Another bug. The e.p. flag gets lost after "go" and then "undo".
I haven't had a chance to review your e.p. changes on 9/29/2020.
TommyCode: Select all
TOMDEBUG: 3 Enter SEARCH DEPTH (sd): 1 r n b q k b n r p p p p p p p p . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P P P P P P P P R N B Q K B N R e2e4 r n b q k b n r p p p p p p p p . . . . . . . . . . . . . . . . . . . . P . . . . . . . . . . . P P P P . P P P R N B Q K B N R b8a6 r . b q k b n r p p p p p p p p n . . . . . . . . . . . . . . . . . . . P . . . . . . . . . . . P P P P . P P P R N B Q K B N R e4e5 r . b q k b n r p p p p p p p p n . . . . . . . . . . . P . . . . . . . . . . . . . . . . . . . P P P P . P P P R N B Q K B N R d7d5 r . b q k b n r p p p . p p p p n . . . . . . . . . . p P . . . . . . . . . . . . . . . . . . . P P P P . P P P R N B Q K B N R go Move Played: F1A6 r . b q k b n r p p p . p p p p B . . . . . . . . . . p P . . . . . . . . . . . . . . . . . . . P P P P . P P P R N B Q K . N R u r . b q k b n r p p p . p p p p n . . . . . . . . . . p P . . . . . . . . . . . . . . . . . . . P P P P . P P P R N B Q K B N R e5d6 r . b q k b n r p p p . p p p p n . . . . . . . . . . p P . . . . . . . . . . . . . . . . . . . P P P P . P P P R N B Q K B N R
Should be an easy fix!
I'm stuck on getline. I assumed that because it only takes characters to the delimiter and then throws the delimiter away that the next getline would continue where the last one left off but it does not seem to as it wants me to enter another command and hit enter again.
Please, how can I fix this?
Code: Select all
void GetCmd(Thread* t) {
s32 match, i, j = 0, fs, ts;
u64 n, cnt, epbit;
string data, movstr;
char mvstr[20];
match = false;
epbit = epbb[1];
PrintBoard(t);
std::cout << std::endl;
cout << "Enter Command: ";
getline(cin, data, ' ');
cnt = data.length();
if (cnt == 4 || cnt == 5) {
if (data[0] >= 'a' && data[0] <= 'h' &&
data[1] >= '1' && data[1] <= '8' &&
data[2] >= 'a' && data[2] <= 'h' &&
data[3] >= '1' && data[3] <= '8') {
epbb[0] = epbit;
n = GenMoves(t, &move[0]);
for (i = OO; i < n; i++) {
if (cnt == 5) {
if (data[5] == 'b') j = 0;
if (data[5] == 'r') j = 1;
if (data[5] == 'n') j = 2;
if (data[5] == 'q') j = 3;
if (promoType[wtm][j] != move[i].type) continue;
}
fs = move[i].fs;
ts = move[i].ts;
sprintf_s(mvstr, 20, "%c%d%c%d\n", (fs & 7) + 'a', (fs >> 3) + 1, (ts & 7) + 'a', (ts >> 3) + 1);
string movstr = mvstr;
if (!data.compare(movstr)) {
gameMoves[gamePly].fs = fs;
gameMoves[gamePly].ts = ts;
gameMoves[gamePly].type = move[i].type;
MakeMove(t, &gameMoves[gamePly]);
epbb[0] = epbit;
gamePly++;
ply--;
return;
}
}
return;
}
}
if (!data.compare("go")) {
bricabrac = BRICABRAC;
return;
}
if (gamePly && (!data.compare("u") || !data.compare("undo"))) {
gamePly--;
ply++;
TakeBack(t, &gameMoves[gamePly]);
return;
}
if (!data.compare("sd")) {
getline(cin, data, ' ');
sd = stoi(data, nullptr);
}
}Mike
-
Mike Sherwin
- Posts: 860
- Joined: Fri Aug 21, 2020 1:25 am
- Location: Planet Earth, Sol system
- Full name: Michael J Sherwin
Re: I don't want to give up
NVM, Tommy. I rediscovered cin. So many hours. So easy a solution. If only I had a memory I'd be dangerous, lol!