moves;
+ const moveT* move = CurrentMove;
+ while ((move = move->getPrevMove())) {
+ if (move->moveData.isNullMove()) {
+ Position lastValidPos = *currentPos();
+ for (const moveT* m : moves) {
+ lastValidPos.UndoSimpleMove(&m->moveData);
+ }
+ lastValidPos.PrintFEN(FEN, FEN_ALL_FIELDS);
+ break;
+ }
+ moves.emplace_back(move);
+ }
+
+ if (*FEN || HasNonStandardStart(FEN)) {
+ res.replace(9, 4, "fen ");
+ res.replace(13, 4, FEN);
+ }
+
+ const auto allocSpeedup = res.size();
+ res.resize(allocSpeedup + moves.size() * 6);
+ auto it = res.data() + allocSpeedup;
+ for (auto m = moves.crbegin(), end = moves.crend(); m != end; ++m) {
+ *it++ = ' ';
+ it = (*m)->moveData.toLongNotation(it);
+ }
+ res.resize(std::distance(res.data(), it)); // shrink
+ return res;
+}
+
///////////////////////////////////////////////////////////////////////////
// The following functions modify the moves graph in order to add or delete
// moves. Promoting variations also modifies the moves graph.
@@ -886,19 +878,14 @@ unsigned Game::GetPgnOffset() const {
// Game::AddMove():
// Add a move at current position and do it.
//
-errorT Game::AddMove(const simpleMoveT* sm) {
- ASSERT(sm != NULL);
-
+errorT Game::AddMove(simpleMoveT const& sm) {
// We must be at the end of a game/variation to add a move:
if (!CurrentMove->endMarker())
Truncate();
CurrentMove->setNext(NewMove(END_MARKER));
CurrentMove->marker = NO_MARKER;
- CurrentMove->moveData.from = sm->from;
- CurrentMove->moveData.to = sm->to;
- CurrentMove->moveData.promote = sm->promote;
- CurrentMove->moveData.movingPiece = sm->movingPiece;
+ CurrentMove->moveData = sm;
if (VarDepth == 0)
++NumHalfMoves;
@@ -962,16 +949,18 @@ errorT Game::MainVariation() {
root->swapLine(*parent.second->next);
ASSERT(VarDepth);
- --VarDepth;
-
- // Now, the information about the material at the end of the
- // game, pawn promotions, will be wrong if the variation was
- // promoted to an actual game move, so call MakeHomePawnList()
- // to go through the game moves and ensure it is correct.
- auto location = currentLocation();
- byte tempPawnList[9];
- MakeHomePawnList(tempPawnList);
- restoreLocation(location);
+ if (--VarDepth == 0) { // Recalculate NumHalfMoves
+ const auto count_moves = [](auto move) {
+ int res = 0;
+ while (!move->endMarker()) {
+ ++res;
+ move = move->next;
+ }
+ return res;
+ };
+ ASSERT(FirstMove->startMarker() && FirstMove->next);
+ NumHalfMoves = count_moves(FirstMove->next);
+ }
return OK;
}
@@ -1033,70 +1022,15 @@ void Game::TruncateStart() {
NumHalfMoves -= GetCurrentPly();
StartPos = std::move(pos);
*CurrentPos = *StartPos;
- FirstMove->setNext(CurrentMove);
-}
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Game::MakeHomePawnList():
-// Is passed an array of 9 bytes and fills it with the game's
-// home pawn delta information.
-// This function also ensures that other information about the
-// game that will be stored in the index file and used to speed
-// up searches (material at end of game, etc) is up to date.
-
-bool Game::MakeHomePawnList(byte* pbPawnList) {
- ASSERT(pbPawnList != nullptr);
- // We zero out the list first:
- std::fill_n(pbPawnList, 9, 0);
-
- uint count = 0;
- uint halfByte = 0;
- errorT err = OK;
- uint hpOld = HPSIG_StdStart; // All 16 pawns are on their home squares.
- byte* pbList = pbPawnList +1;
-
- NumHalfMoves = 0;
- PromotionsFlag = false;
- bool UnderPromosFlag = false;
- MoveToPly(0);
-
- while (err == OK) {
- uint hpNew = CurrentPos->GetHPSig();
- uint changed = hpOld - hpNew;
- if (changed != 0 && !HasNonStandardStart()) {
- // Find the idx of the moved pawn
- uint changeValue = 0;
- while (1) {
- changed = changed >> 1;
- if (changed == 0) break;
- changeValue++;
- }
+ FirstMove->setNext(CurrentMove);
- // There are only 16 pawns, so we can store two pawn moves
- // in every byte
- if (halfByte == 0) {
- *pbList = (changeValue << 4); halfByte = 1;
- } else {
- *pbList |= (changeValue & 15); pbList++; halfByte = 0;
- }
- hpOld = hpNew;
- count++;
+ // Do all the moves to update moveData.pieceNum to the new StartPos
+ do {
+ if (!CurrentMove->startMarker() && !CurrentMove->endMarker()) {
+ CurrentPos->fillMove(CurrentMove->moveData);
}
- if (CurrentMove->marker != END_MARKER) {
- if (CurrentMove->moveData.promote != EMPTY) {
- PromotionsFlag = true;
- if (piece_Type(CurrentMove->moveData.promote) != QUEEN) {
- UnderPromosFlag = true;
- }
- }
- }
- err = MoveForward();
- if (err == OK) { NumHalfMoves++; }
- }
- // First byte in pawnlist array stores the count:
- pbPawnList[0] = (byte) count;
-
- return UnderPromosFlag;
+ } while (MoveForwardInPGN() == OK);
+ MoveToStart();
}
namespace {
@@ -1125,9 +1059,9 @@ int calcHomePawnMask (pieceT pawn, const
// Used by Game::MaterialMatch() to test patterns.
// Returns 1 if all the patterns in the list match, 0 otherwise.
//
-int patternsMatch(const Position* pos, patternT* ptn) {
+int patternsMatch(const Position* pos, patternT* ptn, size_t ptn_size) {
const pieceT* board = pos->GetBoard();
- while (ptn != NULL) {
+ for (auto ptn_end = ptn + ptn_size; ptn != ptn_end; ++ptn) {
if (ptn->rankMatch == NO_RANK) {
if (ptn->fyleMatch == NO_FYLE) { // Nothing to test!
@@ -1156,9 +1090,6 @@ int patternsMatch(const Position* pos, p
if (found != ptn->flag) { return 0; }
}
}
-
- // If we get this far, this pattern matched. Try the next one:
- ptn = ptn->next;
}
// If we reach here, all patterns matched:
@@ -1172,29 +1103,17 @@ int patternsMatch(const Position* pos, p
// counts, to specify the maximum and minimum number of counts
// of each type of piece.
//
-bool
-Game::MaterialMatch (ByteBuffer * buf, byte * min, byte * max,
- patternT * patterns, int minPly, int maxPly,
- int matchLength, bool oppBishops, bool sameBishops,
- int minDiff, int maxDiff)
-{
- // If buf is NULL, the game is in memory. Otherwise, Decode only
- // the necessary moves:
- errorT err = OK;
-
- if (buf == NULL) {
- MoveToPly(0);
- } else {
- Clear();
- err = DecodeStart (buf);
- KeepDecodedMoves = false;
- }
-
+bool Game::MaterialMatch(bool PromotionsFlag, ByteBuffer& buf, byte* min,
+ byte* max, patternT* patterns, size_t ptn_size,
+ int minPly, int maxPly, int matchLength,
+ bool oppBishops, bool sameBishops, int minDiff,
+ int maxDiff) {
ASSERT (matchLength >= 1);
int matchesNeeded = matchLength;
int matDiff;
uint plyCount = 0;
+ errorT err = DecodeSkipTags(&buf);
while (err == OK) {
bool foundMatch = false;
byte wMinor, bMinor;
@@ -1276,7 +1195,7 @@ Game::MaterialMatch (ByteBuffer * buf, b
if (matDiff < minDiff || matDiff > maxDiff) { goto Next_Move; }
// At this point, the Material matches; do the patterns match?
- if (patterns == NULL || patternsMatch(currentPos(), patterns)) {
+ if (ptn_size == 0 || patternsMatch(currentPos(), patterns, ptn_size)) {
foundMatch = true;
matchesNeeded--;
if (matchesNeeded <= 0) { return true; }
@@ -1289,13 +1208,12 @@ Game::MaterialMatch (ByteBuffer * buf, b
if (! PromotionsFlag) { return false; }
Next_Move:
- if (buf == NULL) {
- MoveForward();
- if (CurrentMove->marker == END_MARKER) {
- err = ERROR_EndOfMoveList;
+ {
+ simpleMoveT sm;
+ err = DecodeNextMove(&buf, sm);
+ if (err == OK) {
+ CurrentPos->DoSimpleMove(sm);
}
- } else {
- err = DecodeNextMove (buf, NULL);
}
plyCount++;
if (! foundMatch) { matchesNeeded = matchLength; }
@@ -1314,26 +1232,21 @@ Game::MaterialMatch (ByteBuffer * buf, b
// true if the game could never match even with extra moves.
//
bool
-Game::ExactMatch (Position * searchPos, ByteBuffer * buf, simpleMoveT * sm,
- gameExactMatchT searchType, bool * neverMatch)
+Game::ExactMatch (Position * searchPos, ByteBuffer * buf,
+ gameExactMatchT searchType)
{
// If buf is NULL, the game is in memory. Otherwise, Decode only
// the necessary moves:
errorT err = OK;
if (buf == NULL) {
- MoveToPly(0);
+ MoveToStart();
} else {
- Clear ();
- err = DecodeStart (buf);
- KeepDecodedMoves = false;
+ err = DecodeSkipTags(buf);
}
- uint plyCount = 0;
- //uint skip = 0; // Just for statistics on number of moves skipped.
uint search_whiteHPawns = 0;
uint search_blackHPawns = 0;
- uint current_whiteHPawns, current_blackHPawns;
bool check_pawnMaskWhite, check_pawnMaskBlack;
bool doHomePawnChecks = false;
@@ -1353,11 +1266,6 @@ Game::ExactMatch (Position * searchPos,
}
}
- // If neverMatch is null, point it at a dummy value
- bool dummy;
- if (neverMatch == NULL) { neverMatch = &dummy; }
- *neverMatch = false;
-
if (searchType == GAME_EXACT_MATCH_Exact ||
searchType == GAME_EXACT_MATCH_Pawns) {
doHomePawnChecks = true;
@@ -1371,7 +1279,6 @@ Game::ExactMatch (Position * searchPos,
const pieceT* board = searchPos->GetBoard();
const pieceT* b1 = currentBoard;
const pieceT* b2 = board;
- bool found = true;
// If NO_SPEEDUPS is defined, a slower search is done without
// optimisations that detect insufficient material.
@@ -1379,13 +1286,11 @@ Game::ExactMatch (Position * searchPos,
// Insufficient material optimisation:
if (searchPos->GetCount(WHITE) > CurrentPos->GetCount(WHITE) ||
searchPos->GetCount(BLACK) > CurrentPos->GetCount(BLACK)) {
- *neverMatch = true;
return false;
}
// Insufficient pawns optimisation:
if (searchPos->PieceCount(WP) > CurrentPos->PieceCount(WP) ||
searchPos->PieceCount(BP) > CurrentPos->PieceCount(BP)) {
- *neverMatch = true;
return false;
}
@@ -1396,26 +1301,24 @@ Game::ExactMatch (Position * searchPos,
// not equal to search_xxHPawns.
// We do not do this optimisation for a pawn files search,
// because the exact pawn squares are not important there.
-
- if (searchType != GAME_EXACT_MATCH_Fyles) {
if (check_pawnMaskWhite) {
- current_whiteHPawns = calcHomePawnMask (WP, currentBoard);
+ auto current_whiteHPawns = calcHomePawnMask (WP, currentBoard);
if ((current_whiteHPawns & search_whiteHPawns)
!= search_whiteHPawns) {
- *neverMatch = true;
return false;
}
+ check_pawnMaskWhite = false;
}
if (check_pawnMaskBlack) {
- current_blackHPawns = calcHomePawnMask (BP, currentBoard);
+ auto current_blackHPawns = calcHomePawnMask (BP, currentBoard);
if ((current_blackHPawns & search_blackHPawns)
!= search_blackHPawns) {
- *neverMatch = true;
return false;
}
+ check_pawnMaskBlack = false;
}
- }
#endif // #ifndef NO_SPEEDUPS
+ bool found = true;
// Not correct color: skip to next move
if (searchPos->GetToMove() != CurrentPos->GetToMove()) {
@@ -1477,62 +1380,31 @@ Game::ExactMatch (Position * searchPos,
}
if (found) {
- // Found a match! Set the returned next-move:
- if (sm) { // We need to decode the next move.
- if (buf == NULL) {
- MoveForward();
- if (CurrentMove->marker == END_MARKER) {
- // Position matched at last move in the game.
- sm->from = sm->to = NULL_SQUARE;
- sm->promote = EMPTY;
- } else {
- *sm = CurrentMove->prev->moveData;
- MoveBackup();
- }
- } else {
- err = DecodeNextMove (buf, sm);
- if (err != OK) {
- // Position matched at last move in the game.
- sm->from = sm->to = NULL_SQUARE;
- sm->promote = EMPTY;
- } else {
- // Backup to the matching position:
- CurrentPos->UndoSimpleMove (sm);
- }
- }
- }
return true;
}
Move_Forward:
-#ifndef NO_SPEEDUPS
- if (doHomePawnChecks) {
- check_pawnMaskWhite = false;
- check_pawnMaskBlack = false;
- rankT rTo = square_Rank (CurrentMove->moveData.to);
- rankT rFrom = square_Rank (CurrentMove->moveData.from);
- // We only re-check the home pawn masks when something moves
- // to or from the 2nd/7th rank:
- if (rTo == RANK_2 || rFrom == RANK_2) {
- check_pawnMaskWhite = true;
- }
- if (rTo == RANK_7 || rFrom == RANK_7) {
- check_pawnMaskBlack = true;
- }
- }
-#endif
if (buf == NULL) {
- MoveForward ();
- if (CurrentMove->marker == END_MARKER) {
- err = ERROR_EndOfMoveList;
- }
+ err = MoveForward();
} else {
- err = DecodeNextMove (buf, NULL);
- if (err != OK && err != ERROR_EndOfMoveList) {
- return false;
+ simpleMoveT nextMove;
+ err = DecodeNextMove(buf, nextMove);
+ if (err == OK) {
+ CurrentPos->DoSimpleMove(nextMove);
+ if (doHomePawnChecks) {
+ rankT rTo = square_Rank (nextMove.to);
+ rankT rFrom = square_Rank (nextMove.from);
+ // We only re-check the home pawn masks when something moves
+ // to or from the 2nd/7th rank:
+ if (rTo == RANK_2 || rFrom == RANK_2) {
+ check_pawnMaskWhite = true;
+ }
+ if (rTo == RANK_7 || rFrom == RANK_7) {
+ check_pawnMaskBlack = true;
+ }
+ }
}
}
- plyCount++;
}
return false;
}
@@ -1642,7 +1514,7 @@ Game::GetPartialMoveList (DString * outS
// unaltered:
auto location = currentLocation();
- MoveToPly(0);
+ MoveToStart();
char temp [80];
for (uint i=0; i < plyCount; i++) {
if (CurrentMove->marker == END_MARKER) {
@@ -1695,14 +1567,14 @@ void Game::GetSAN(char* str) {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Game::GetPrevSAN():
-// Print the SAN representation of the current move to a string.
+// Print the SAN representation of the previous move to a string.
// Prints an empty string ("") if not at a move.
void
Game::GetPrevSAN (char * str)
{
ASSERT (str != NULL);
moveT * m = CurrentMove->prev;
- if (m->marker == START_MARKER || m->marker == END_MARKER) {
+ if (m->startMarker() || m->endMarker()) {
str[0] = 0;
return;
}
@@ -1720,14 +1592,11 @@ Game::GetPrevSAN (char * str)
// Prints an empty string ("") if not at a move.
void Game::GetPrevMoveUCI(char* str) const {
ASSERT(str != NULL);
- moveT* m = CurrentMove->prev;
- if (m->marker == START_MARKER) {
- str[0] = 0;
- } else {
- Position pos(*CurrentPos);
- pos.UndoSimpleMove(&m->moveData);
- pos.MakeUCIString(&m->moveData, str);
- }
+ const auto m = CurrentMove->prev;
+ if (!m->startMarker())
+ str = m->moveData.toLongNotation(str);
+
+ *str = '\0';
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1738,50 +1607,12 @@ void
Game::GetNextMoveUCI (char * str)
{
ASSERT (str != NULL);
- moveT * m = CurrentMove;
- if (m->marker == START_MARKER || m->marker == END_MARKER) {
- str[0] = 0;
- return;
- }
- CurrentPos->MakeUCIString (&(m->moveData), str);
-}
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// commentEmpty:
-// Called by WriteMoveList to check there is really
-// something to print given display options.
-// comment is supposed to be non null
-bool
-Game::CommentEmpty ( const char * comment)
-{
- char * s = NULL;
- bool ret = false;
+ if (!CurrentMove->endMarker())
+ str = CurrentMove->moveData.toLongNotation(str);
- if (comment == NULL)
- return true;
-
- if (comment[0] == '\0')
- return true;
-
- if (PgnStyle & PGN_STYLE_STRIP_MARKS) {
- s = strDuplicate (comment);
- strTrimMarkCodes (s);
- char * tmp = s;
- bool empty = true;
- while (tmp[0] != 0) {
- if (tmp[0] != ' ') {
- empty = false;
- break;
- }
- tmp++;
- }
- ret = empty;
-
- delete[] s;
- }
-
- return ret;
+ *str = '\0';
}
+
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// writeComment:
// Called by WriteMoveList to write a single comment.
@@ -1789,16 +1620,7 @@ void
Game::WriteComment (TextBuffer * tb, const char * preStr,
const char * comment, const char * postStr)
{
-
- char * s = NULL;
-
- if (PgnStyle & PGN_STYLE_STRIP_MARKS) {
- s = strDuplicate (comment);
- strTrimMarkCodes (s);
- } else {
- s = (char *) comment;
- }
-
+ const char* s = comment;
if (s[0] != '\0') {
if (IsColorFormat()) {
@@ -1824,10 +1646,6 @@ Game::WriteComment (TextBuffer * tb, con
if (IsColorFormat()) { tb->PrintString (""); }
}
-
- if (PgnStyle & PGN_STYLE_STRIP_MARKS) {
- delete[] s;
- }
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1892,12 +1710,18 @@ errorT Game::WriteMoveList(TextBuffer* t
postCommentStr = "";
}
+ std::string strippedComment;
// If this is a variation and it starts with a comment, print it:
- if ((VarDepth > 0 || CurrentMove->prev == FirstMove) &&
- ! CurrentMove->prev->comment.empty()) {
- if (PgnStyle & PGN_STYLE_COMMENTS) {
- WriteComment (tb, preCommentStr, CurrentMove->prev->comment.c_str(),
- postCommentStr);
+ if ((VarDepth > 0 || CurrentMove->prev == FirstMove) &&
+ (PgnStyle & PGN_STYLE_COMMENTS)) {
+ const char* comment = CurrentMove->prev->comment.c_str();
+ if (*comment && (PgnStyle & PGN_STYLE_STRIP_MARKS)) {
+ strippedComment = m->comment;
+ strTrimMarkCodes(strippedComment.data());
+ comment = strippedComment.data();
+ }
+ if (*comment) {
+ WriteComment(tb, preCommentStr, comment, postCommentStr);
tb->PrintSpace();
if (!VarDepth) {
tb->ClearTranslation ('\n');
@@ -2109,7 +1933,13 @@ errorT Game::WriteMoveList(TextBuffer* t
printMoveNum = true;
}
- if (!m->comment.empty() && ! CommentEmpty(m->comment.c_str()) ) {
+ const char* comment = m->comment.c_str();
+ if (*comment && (PgnStyle & PGN_STYLE_STRIP_MARKS)) {
+ strippedComment = m->comment;
+ strTrimMarkCodes(strippedComment.data());
+ comment = strippedComment.data();
+ }
+ if (*comment) {
if (!inComment && IsPlainFormat() &&
(PgnStyle & PGN_STYLE_NO_NULL_MOVES)) {
// If this move has no variations, but the next move
@@ -2149,7 +1979,7 @@ errorT Game::WriteMoveList(TextBuffer* t
}
}
- WriteComment (tb, preCommentStr, m->comment.c_str(), postCommentStr);
+ WriteComment(tb, preCommentStr, comment, postCommentStr);
if ((PgnStyle & PGN_STYLE_INDENT_COMMENTS) && VarDepth == 0) {
if (IsColorFormat()) {
@@ -2161,7 +1991,7 @@ errorT Game::WriteMoveList(TextBuffer* t
} else {
tb->PrintSpace();
}
- if (printDiagrams && strIsPrefix ("#", m->comment.c_str())) {
+ if (printDiagrams && strIsPrefix ("#", comment)) {
if (IsLatexFormat()) {
tb->PrintString ("\n\\begin{diagram}\n");
}
@@ -2215,11 +2045,10 @@ errorT Game::WriteMoveList(TextBuffer* t
for (uint i=0; i < m->numVariations; i++) {
if (PgnStyle & PGN_STYLE_INDENT_VARS) {
if (IsColorFormat()) {
- switch (VarDepth) {
- case 0: tb->PrintString (""); break;
- case 1: tb->PrintString (""); break;
- case 2: tb->PrintString (""); break;
- case 3: tb->PrintString (""); break;
+ if (VarDepth < 19) {
+ char tmp_str[16];
+ sprintf(tmp_str, "", VarDepth + 1);
+ tb->PrintString(tmp_str);
}
} else {
tb->SetIndent (tb->GetIndent() + 4); tb->Indent();
@@ -2267,11 +2096,10 @@ errorT Game::WriteMoveList(TextBuffer* t
}
if (PgnStyle & PGN_STYLE_INDENT_VARS) {
if (IsColorFormat()) {
- switch (VarDepth) {
- case 0: tb->PrintString ("
"); break;
- case 1: tb->PrintString ("
"); break;
- case 2: tb->PrintString ("
"); break;
- case 3: tb->PrintString ("
"); break;
+ if (VarDepth < 19) {
+ char tmp_str[16];
+ sprintf(tmp_str, "
", VarDepth + 1);
+ tb->PrintString(tmp_str);
}
} else {
tb->SetIndent (tb->GetIndent() - 4); tb->Indent();
@@ -2536,7 +2364,7 @@ errorT Game::WritePGN(TextBuffer* tb) {
tb->PrintString (newline);
}
- MoveToPly(0);
+ MoveToStart();
if (IsHtmlFormat()) { tb->PrintString (""); }
NumMovesPrinted = 1;
@@ -2580,113 +2408,67 @@ Game::WriteToPGN(uint lineWidth, bool Ne
// index file entry and a namebase that stores the
// player/site/event/round names.
//
-errorT
-Game::LoadStandardTags (const IndexEntry* ie, const NameBase* nb)
-{
- ASSERT (ie != NULL && nb != NULL);
- SetEventStr (ie->GetEventName (nb));
- SetSiteStr (ie->GetSiteName (nb));
- SetWhiteStr (ie->GetWhiteName (nb));
- SetBlackStr (ie->GetBlackName (nb));
- SetRoundStr (ie->GetRoundName (nb));
- SetDate (ie->GetDate());
- SetEventDate (ie->GetEventDate());
- SetWhiteElo (ie->GetWhiteElo());
- SetBlackElo (ie->GetBlackElo());
- WhiteEstimateElo = nb->GetElo (ie->GetWhite());
- BlackEstimateElo = nb->GetElo (ie->GetBlack());
- SetWhiteRatingType (ie->GetWhiteRatingType());
- SetBlackRatingType (ie->GetBlackRatingType());
- SetResult (ie->GetResult());
- SetEco (ie->GetEcoCode());
- ie->GetFlagStr (ScidFlags, NULL);
- return OK;
+void Game::LoadStandardTags(IndexEntry const& ie, TagRoster const& tags) {
+ SetEventStr(tags.event);
+ SetSiteStr(tags.site);
+ SetWhiteStr(tags.white);
+ SetBlackStr(tags.black);
+ SetRoundStr(tags.round);
+ SetDate(ie.GetDate());
+ SetEventDate(ie.GetEventDate());
+ SetWhiteElo(ie.GetWhiteElo());
+ SetBlackElo(ie.GetBlackElo());
+ SetWhiteRatingType(ie.GetWhiteRatingType());
+ SetBlackRatingType(ie.GetBlackRatingType());
+ SetResult(ie.GetResult());
+ SetEco(ie.GetEcoCode());
+ ie.GetFlagStr(ScidFlags, NULL);
}
eloT
-Game::GetAverageElo ()
-{
- eloT white = WhiteElo;
- eloT black = BlackElo;
- if (white == 0) { white = WhiteEstimateElo; }
- if (black == 0) { black = BlackEstimateElo; }
- return (white + black) / 2;
-}
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// makeMoveByte(): inline routine used for encoding most moves.
-//
-static inline byte
-makeMoveByte (byte pieceNum, byte value)
-{
- ASSERT (pieceNum <= 15 && value <= 15);
- return (byte)((pieceNum & 15) << 4) | (byte)(value & 15);
+Game::GetAverageElo () {
+ auto white = WhiteElo;
+ auto black = BlackElo;
+ return (white == 0 || black == 0) ? 0 : (white + black) / 2;
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// encodeKing(): encoding of King moves.
//
-static inline void
-encodeKing (ByteBuffer * buf, simpleMoveT * sm)
-{
+static byte encodeKing(squareT from, int to) {
// Valid King difference-from-old-square values are:
// -9, -8, -7, -1, 1, 7, 8, 9, and -2 and 2 for castling.
// To convert this to a val in the range [1-10], we add 9 and
// then look up the val[] table.
// Coded values 1-8 are one-square moves; 9 and 10 are Castling.
-
- ASSERT(sm->pieceNum == 0); // Kings MUST be piece Number zero.
- int diff = (int) sm->to - (int) sm->from;
static const byte val[] = {
/* -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7 8 9 */
1, 2, 3, 0, 0, 0, 0, 9, 4, 0, 5, 10, 0, 0, 0, 0, 6, 7, 8
};
+ auto diff = to - from;
+ static_assert(std::is_same_v);
// If target square is the from square, it is the null move, which
// is represented as a king move to its own square and is encoded
// as the byte value zero.
- if (sm->to == sm->from) {
- buf->PutByte (makeMoveByte (0, 0));
- return;
- }
+ ASSERT((to == from && val[diff+9] == 0) || val[diff+9] != 0);
// Verify we have a valid King move:
- ASSERT(diff >= -9 && diff <= 9 && val[diff+9] != 0);
- buf->PutByte (makeMoveByte (0, val [diff + 9]));
-}
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// decodeKing(): decoding of King moves.
-//
-static inline errorT
-decodeKing (byte val, simpleMoveT * sm)
-{
- static const int sqdiff[] = {
- 0, -9, -8, -7, -1, 1, 7, 8, 9, -2, 2
- };
-
- if (val == 0) {
- sm->to = sm->from; // Null move
- return OK;
- }
-
- if (val < 1 || val > 10) { return ERROR_Decode; }
- sm->to = sm->from + sqdiff[val];
- return OK;
+ ASSERT(diff >= -9 && diff <= 9);
+ return val[diff + 9];
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// encodeKnight(): encoding Knight moves.
//
-static inline void
-encodeKnight (ByteBuffer * buf, simpleMoveT * sm)
-{
+static byte encodeKnight(squareT from, squareT to) {
// Valid Knight difference-from-old-square values are:
// -17, -15, -10, -6, 6, 10, 15, 17.
// To convert this to a value in the range [1-8], we add 17 to
// the difference and then look up the val[] table.
- int diff = (int) sm->to - (int) sm->from;
+ auto diff = to - from;
+ static_assert(std::is_same_v);
static const byte val[] = {
/* -17 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 */
1, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0,
@@ -2697,175 +2479,74 @@ encodeKnight (ByteBuffer * buf, simpleMo
// Verify we have a valid knight move:
ASSERT (diff >= -17 && diff <= 17 && val[diff + 17] != 0);
- buf->PutByte (makeMoveByte (sm->pieceNum, val [diff + 17]));
-}
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// decodeKnight(): decoding Knight moves.
-//
-static inline errorT
-decodeKnight (byte val, simpleMoveT * sm)
-{
- static const int sqdiff[] = {
- 0, -17, -15, -10, -6, 6, 10, 15, 17
- };
- if (val < 1 || val > 8) { return ERROR_Decode; }
- sm->to = sm->from + sqdiff[val];
- return OK;
+ return val[diff + 17];
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// encodeRook(): encoding rook moves.
//
-static inline void
-encodeRook (ByteBuffer * buf, simpleMoveT * sm)
-{
+static byte encodeRook(squareT from, squareT to) {
// Valid Rook moves are to same rank, OR to same fyle.
// We encode the 8 squares on the same rank 0-8, and the 8
// squares on the same fyle 9-15. This means that for any particular
// rook move, two of the values in the range [0-15] will be
// meaningless, as they will represent the from-square.
- ASSERT (sm->from <= H8 && sm->to <= H8);
- byte val;
-
// Check if the two squares share the same rank:
- if (square_Rank(sm->from) == square_Rank(sm->to)) {
- val = square_Fyle(sm->to);
- } else {
- val = 8 + square_Rank(sm->to);
+ if (square_Rank(from) == square_Rank(to)) {
+ return square_Fyle(to);
}
- buf->PutByte (makeMoveByte (sm->pieceNum, val));
-}
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// decodeRook(): decoding Rook moves.
-//
-static inline errorT
-decodeRook (byte val, simpleMoveT * sm)
-{
- if (val >= 8) {
- // This is a move along a Fyle, to a different rank:
- sm->to = square_Make (square_Fyle(sm->from), (val - 8));
- } else {
- sm->to = square_Make (val, square_Rank(sm->from));
- }
- return OK;
+ return 8 + square_Rank(to);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// encodeBishop(): encoding Bishop moves.
//
-static inline void
-encodeBishop (ByteBuffer * buf, simpleMoveT * sm)
-{
+static byte encodeBishop(squareT from, squareT to) {
// We encode a Bishop move as the Fyle moved to, plus
// a one-bit flag to indicate if the direction was
// up-right/down-left or vice versa.
- ASSERT (sm->to <= H8 && sm->from <= H8);
- byte val;
- val = square_Fyle(sm->to);
- int rankdiff = (int)square_Rank(sm->to) - (int)square_Rank(sm->from);
- int fylediff = (int)square_Fyle(sm->to) - (int)square_Fyle(sm->from);
+ auto rankdiff = square_Rank(to) - square_Rank(from);
+ auto fylediff = square_Fyle(to) - square_Fyle(from);
+ static_assert(std::is_same_v);
+ static_assert(std::is_same_v);
// If (rankdiff * fylediff) is negative, it's up-left/down-right:
- if (rankdiff * fylediff < 0) { val += 8; }
+ if (rankdiff * fylediff < 0)
+ return square_Fyle(to) + 8;
- buf->PutByte (makeMoveByte (sm->pieceNum, val));
-}
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// decodeBishop(): decoding Bishop moves.
-//
-static inline errorT
-decodeBishop (byte val, simpleMoveT * sm)
-{
- byte fyle = (val & 7);
- int fylediff = (int)fyle - (int)square_Fyle(sm->from);
- if (val >= 8) {
- // It is an up-left/down-right direction move.
- sm->to = sm->from - 7 * fylediff;
- } else {
- sm->to = sm->from + 9 * fylediff;
- }
- if (sm->to > H8) { return ERROR_Decode;}
- return OK;
+ return square_Fyle(to);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// encodeQueen(): encoding Queen moves.
//
-static inline void
-encodeQueen (ByteBuffer * buf, simpleMoveT * sm)
-{
+static byte encodeQueen(squareT from, squareT to, byte& multibyte) {
// We cannot fit all Queen moves in one byte, so Rooklike moves
// are in one byte (encoded the same way as Rook moves),
// while diagonal moves are in two bytes.
+ if (square_Rank(from) == square_Rank(to)) // Rook-horizontal move:
+ return square_Fyle(to);
- ASSERT (sm->to <= H8 && sm->from <= H8);
- byte val;
-
- if (square_Rank(sm->from) == square_Rank(sm->to)) {
- // Rook-horizontal move:
-
- val = square_Fyle(sm->to);
- buf->PutByte (makeMoveByte (sm->pieceNum, val));
+ if (square_Fyle(from) == square_Fyle(to)) // Rook-vertical move:
+ return 8 + square_Rank(to);
- } else if (square_Fyle(sm->from) == square_Fyle(sm->to)) {
- // Rook-vertical move:
-
- val = 8 + square_Rank(sm->to);
- buf->PutByte (makeMoveByte (sm->pieceNum, val));
-
- } else {
- // Diagonal move:
- ASSERT(std::abs(sm->to / 8 - sm->from / 8) ==
- std::abs(sm->to % 8 - sm->from % 8));
-
- // First, we put a rook-horizontal move to the from square (which
- // is illegal of course) to indicate it is NOT a rooklike move:
-
- val = square_Fyle(sm->from);
- buf->PutByte (makeMoveByte (sm->pieceNum, val));
-
- // Now we put the to-square in the next byte. We add a 64 to it
- // to make sure that it cannot clash with the Special tokens (which
- // are in the range 0 to 15, since they are special King moves).
-
- buf->PutByte (sm->to + 64);
- }
-}
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// decodeQueen(): decoding Queen moves.
-//
-static inline errorT
-decodeQueen (ByteBuffer * buf, byte val, simpleMoveT * sm)
-{
- if (val >= 8) {
- // Rook-vertical move:
- sm->to = square_Make (square_Fyle(sm->from), (val - 8));
-
- } else if (val != square_Fyle(sm->from)) {
- // Rook-horizontal move:
- sm->to = square_Make (val, square_Rank(sm->from));
-
- } else {
- // Diagonal move: coded in TWO bytes.
- val = buf->GetByte();
- if (val < 64 || val > 127) { return ERROR_Decode; }
- sm->to = val - 64;
- }
- return OK;
+ // Diagonal move:
+ ASSERT(std::abs(to / 8 - from / 8) == std::abs(to % 8 - from % 8));
+ // First, we put a rook-horizontal move to the from square (which
+ // is illegal of course) to indicate it is NOT a rooklike move:
+ // Now we put the to-square in the next byte. We add a 64 to it
+ // to make sure that it cannot clash with the Special tokens (which
+ // are in the range 0 to 15, since they are special King moves).
+ multibyte = to + 64;
+ return square_Fyle(from);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// encodePawn(): encoding Pawn moves.
//
-static inline void
-encodePawn (ByteBuffer * buf, simpleMoveT * sm)
-{
+static byte encodePawn(squareT from, squareT to, pieceT promo) {
// Pawn moves require a promotion encoding.
// The pawn moves are:
// 0 = capture-left,
@@ -2878,12 +2559,13 @@ encodePawn (ByteBuffer * buf, simpleMove
// 15 = forward TWO squares.
byte val;
- int diff = (int)(sm->to) - (int)(sm->from);
+ auto diff = to - from;
+ static_assert(std::is_same_v);
if (diff < 0) { diff = -diff; }
if (diff == 16) { // Move forward two squares
val = 15;
- ASSERT (sm->promote == EMPTY);
+ ASSERT (promo == EMPTY);
} else {
if (diff == 7) { val = 0; }
@@ -2892,48 +2574,16 @@ encodePawn (ByteBuffer * buf, simpleMove
ASSERT (diff == 9);
val = 2;
}
- if (sm->promote != EMPTY) {
+ if (promo != EMPTY) {
// Handle promotions.
// sm->promote must be Queen=2,Rook=3, Bishop=4 or Knight=5.
// We add 3 for Queen, 6 for Rook, 9 for Bishop, 12 for Knight.
- ASSERT (sm->promote >= QUEEN && sm->promote <= KNIGHT);
- val += 3 * ((sm->promote) - 1);
+ ASSERT (promo >= QUEEN && promo <= KNIGHT);
+ val += 3 * ((promo) - 1);
}
}
- buf->PutByte (makeMoveByte (sm->pieceNum, val));
-}
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// decodePawn(): decoding Pawn moves.
-//
-static inline errorT
-decodePawn (byte val, simpleMoveT * sm, colorT toMove)
-{
- static const int
- toSquareDiff [16] = {
- 7,8,9, 7,8,9, 7,8,9, 7,8,9, 7,8,9, 16
- };
-
- static const pieceT
- promoPieceFromVal [16] = {
- EMPTY,EMPTY,EMPTY,
- QUEEN,QUEEN,QUEEN,
- ROOK,ROOK,ROOK,
- BISHOP,BISHOP,BISHOP,
- KNIGHT,KNIGHT,KNIGHT,
- EMPTY
- };
-
- if (toMove == WHITE) {
- sm->to = sm->from + toSquareDiff[val];
- } else {
- sm->to = sm->from - toSquareDiff[val];
- }
-
- sm->promote = promoPieceFromVal[val];
-
- return OK;
+ return val;
}
@@ -2955,15 +2605,6 @@ decodePawn (byte val, simpleMoveT * sm,
// a game must end with the end-game token.
-// The inline routine isSpecialMoveCode() returns true is a byte value
-// has the value of a special non-move token:
-inline bool
-isSpecialMoveCode (byte val)
-{
- return (val <= ENCODE_LAST && val >= ENCODE_FIRST);
-}
-
-
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// decodeMove():
// Decode a move from a bytebuffer. Assumes the byte val is an
@@ -2974,344 +2615,278 @@ isSpecialMoveCode (byte val)
//
static errorT decodeMove(ByteBuffer* buf, simpleMoveT* sm, byte val,
const Position* pos) {
- const squareT* sqList = pos->GetList(pos->GetToMove());
- sm->from = sqList[val >> 4];
- if (sm->from > H8) { return ERROR_Decode; }
-
- const pieceT* board = pos->GetBoard();
- sm->movingPiece = board[sm->from];
- sm->promote = EMPTY;
+ const colorT toMove = pos->GetToMove();
+ const squareT from = pos->GetList(toMove)[val >> 4];
+ if (from > H8)
+ return ERROR_Decode;
+
+ const auto ptype = piece_Type(pos->GetPiece(from));
+ const auto [to, promo] = buf->decodeMove(toMove, ptype, from, val);
+ if (to < 0 || to > 63)
+ return ERROR_Decode;
+
+ if (to == from) {
+ if (promo == INVALID_PIECE)
+ return ERROR_Decode;
- errorT err = OK;
- pieceT pt = piece_Type (sm->movingPiece);
- switch (pt) {
- case PAWN:
- err = decodePawn (val & 15, sm, pos->GetToMove());
- break;
- case KNIGHT:
- err = decodeKnight (val & 15, sm);
- break;
- case ROOK:
- err = decodeRook (val & 15, sm);
- break;
- case BISHOP:
- err = decodeBishop (val & 15, sm);
- break;
- case KING:
- err = decodeKing (val & 15, sm);
- break;
- // For queen moves: Rook-like moves are in 1 byte, diagonals are in 2.
- case QUEEN:
- err = decodeQueen (buf, val & 15, sm);
- break;
- default:
- err = ERROR_Decode;
- }
- return err;
+ if (promo != PAWN && !pos->canCastle(promo == KING))
+ return ERROR_Decode;
+ } else {
+ if (to == pos->GetKingSquare(WHITE) || to == pos->GetKingSquare(BLACK))
+ return ERROR_Decode;
+ }
+ pos->makeMove(from, to, promo, *sm);
+ return OK;
}
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Game::EncodeMove():
-// Encode one move and output it to the bytebuffer.
-//
-static void encodeMove(ByteBuffer* buf, moveT* m) {
- simpleMoveT* sm = &(m->moveData);
- pieceT pt = piece_Type(sm->movingPiece);
-
- typedef void encodeFnType (ByteBuffer *, simpleMoveT *);
- static encodeFnType * encodeFn[] = {
- NULL /* 0 */,
- encodeKing /*1=KING*/,
- encodeQueen /*2=QUEEN*/,
- encodeRook /*3=ROOK*/,
- encodeBishop /*4=BISHOP*/,
- encodeKnight /*5=KNIGHT*/,
- encodePawn /*6=PAWN*/
- };
- ASSERT (pt >= KING && pt <= PAWN);
- (encodeFn[pt]) (buf, sm);
+template