chore: add version message

Author: UndefinedCpp

build.py

@@ -6,11 +6,12 @@
 parser.add_argument('--optimize', '-O', action='store_true',
                     help='Optimize the build', default=True)
 parser.add_argument('--arch', '-a', type=str, default='native')
-parser.add_argument('--target', type=str, default='engine.exe')
+parser.add_argument('--target', type=str, default='engine')
 parser.add_argument('--run', '-r', action='store_true',
                     help='Run the program after building', default=False)
 parser.add_argument('--static', action='store_true')
 parser.add_argument('--iterative', action='store_true')
+parser.add_argument('--release', action='store_true')
 
 SOURCE_DIR = './src'
 
@@ -28,6 +29,10 @@
         if os.path.exists('./build/engine.exe'):
             os.rename('./build/engine.exe', './build/engine.old.exe')
 
+    target_name = f'./build/{args.target}.{args.arch}.exe' \
+        if args.release \
+        else f'./build/{args.target}.exe'
+
     command = [
         'g++',
         '-O3' if args.optimize else '',
@@ -36,9 +41,9 @@
         '-std=c++17',
         f'-march={args.arch}',
         '-o',
-        f'./build/{args.target}',
+        target_name,
     ]
-    if args.static:
+    if args.static or args.release:
         command.extend([
             '-static-libstdc++',
             '-static-libgcc',

src/main.cpp

@@ -5,8 +5,9 @@
 using namespace std;
 
 int main() {
-    cout << "Emerald Chess Engine by UndefinedCpp, indev version" << endl;
-    tt.init(1024 * 1024); // temporary initialize transposition table
+    cout << "Emerald Chess Engine by UndefinedCpp, version " << ENGINE_VERSION
+         << endl;
+    tt.init(8 * 1024 * 1024); // todo refactor, currently fixed at 128MB
 
     std::string input;
     while (std::getline(std::cin, input)) {

src/search.cpp

@@ -94,17 +94,17 @@ Value Searcher::qsearch(Value alpha, Value beta, int plyRemaining,
 template <NodeType NT>
 Value Searcher::negamax(Value alpha, Value beta, int plyRemaining,
                         int plyFromRoot, bool canNullMove) {
+    // Check game status
+    const auto [gameOver, gameResultValue] = checkGameStatus(pos);
+    if (gameOver) {
+        return gameResultValue.addPly(plyFromRoot);
+    }
     // Check time
     if (checkTime()) {
         searchAborted = true;
         return 0;
     }
 
-    // Check game status
-    const auto [gameOver, gameResultValue] = checkGameStatus(pos);
-    if (gameOver) {
-        return gameResultValue.addPly(plyFromRoot);
-    }
     diagnosis.nodes++;
 
     if (plyFromRoot >= diagnosis.seldepth) {
@@ -137,9 +137,13 @@ Value Searcher::negamax(Value alpha, Value beta, int plyRemaining,
 
     // Set up move ordering
     MoveOrderer<OrderMode::DEFAULT> orderer;
-    Move ttHashMove = entry ? entry->move() : Move::NO_MOVE; // note +11.59 elo
-    orderer.init(pos, &killerMoves[plyFromRoot],
-                 ttHashMove.isValid() ? &ttHashMove : nullptr);
+
+    if (entry) { // Hash move from transposition table if available
+        Move ttHashMove = entry->move();
+        orderer.init(pos, &killerMoves[plyFromRoot], &ttHashMove);
+    } else {
+        orderer.init(pos, &killerMoves[plyFromRoot]);
+    }
 
     Move bestMove(Move::NO_MOVE);
     Move m;
@@ -166,6 +170,7 @@ Value Searcher::negamax(Value alpha, Value beta, int plyRemaining,
             }
         }
 
+        // Principal Variation Search
         pos.makeMove(m);
         Value eval;
         if (movesSearched == 0) {
@@ -189,13 +194,6 @@ Value Searcher::negamax(Value alpha, Value beta, int plyRemaining,
             // Update killer and history heuristics for non-capture moves
             if (!pos.isCapture(m)) {
                 this->killerMoves[plyFromRoot].add(m);
-
-                // // todo always refactor this
-                // int bonus = std::clamp(plyRemaining * plyRemaining, -500,
-                // 500); int &ref =
-                //     this->historyHeuristics[(int)pos.sideToMove()]
-                //                            [m.from().index()][m.to().index()];
-                // ref += bonus - ref * std::abs(bonus) / 500;
             }
             return beta;
         }
@@ -264,38 +262,40 @@ std::pair<Move, Value> Searcher::search() {
 
     const auto timeBegin = std::chrono::steady_clock::now();
     startTime = timeBegin;
-    diagnosis.nodes = 0;
-    diagnosis.qnodes = 0;
-    result = negamax_root(1, MATE_VALUE, MATED_VALUE);
-    Value guessValue = result.second;
-
-    for (int depth = 2; depth <= 32; ++depth) {
-        result = negamax_root(depth, MATE_VALUE, MATED_VALUE);
-        if (searchAborted) {
-            break;
-        }
-
-        pvMoveFromIteration = result.first;
-        pvScoreFromIteration = result.second;
-        guessValue = pvScoreFromIteration;
 
+    for (int depth = 1; depth <= 32; ++depth) {
         const auto timeEnd = std::chrono::steady_clock::now();
         const uint32_t timeElapsed =
             std::chrono::duration_cast<std::chrono::milliseconds>(timeEnd -
                                                                   timeBegin)
                 .count();
-        // Print uci output
-        std::cout << "info depth " << depth << " score " << result.second
-                  << " seldepth " << (int)diagnosis.seldepth << " hashfull "
-                  << tt.hashfull() << " time " << timeElapsed << " nodes "
-                  << (int)diagnosis.nodes << " pv "
-                  << chess::uci::moveToUci(pvMoveFromIteration) << std::endl;
-        // std::cout << "info string non-qs nodes: "
-        //           << (int)(diagnosis.nodes - diagnosis.qnodes) << std::endl;
-
         if (timeElapsed > maxThinkingTime) {
             break;
         }
+
+        result = negamax_root(depth, MATE_VALUE, MATED_VALUE);
+        if (searchAborted) {
+            break;
+        }
+
+        // Print uci output
+        if (timeElapsed >= 1) {
+            uint64_t nps = diagnosis.nodes * 1000 / timeElapsed;
+            std::cout << "info depth " << depth << " score " << result.second
+                      << " seldepth " << (int)diagnosis.seldepth << " hashfull "
+                      << tt.hashfull() << " time " << timeElapsed << " nodes "
+                      << (int)diagnosis.nodes << " nps " << nps << " pv "
+                      << chess::uci::moveToUci(pvMoveFromIteration)
+                      << std::endl;
+        } else {
+            std::cout << "info depth " << depth << " score " << result.second
+                      << " seldepth " << (int)diagnosis.seldepth << " hashfull "
+                      << tt.hashfull() << " time " << timeElapsed << " nodes "
+                      << (int)diagnosis.nodes << std::endl;
+        }
+
+        pvMoveFromIteration = result.first;
+        pvScoreFromIteration = result.second;
     }
     std::cout << std::flush;
     return {pvMoveFromIteration, pvScoreFromIteration};

src/timemgr.cpp

@@ -1,23 +1,25 @@
 #include "timemgr.h"
 #include <algorithm>
+#include <cmath>
 
 void TimeManager::update(uint32_t remainingTime, uint32_t increment) {
     _remainingTime = remainingTime;
     _increment = increment;
 }
 
 uint32_t TimeManager::spareTime(int ply) {
-    if (_remainingTime <= 500) {
-        return _increment;
+    if (_remainingTime <= 1000) {
+        float ratio = _remainingTime / 1000.0f;
+        return (_remainingTime + _increment) * ratio * ratio / 4.0;
     }
-    if (ply >= 35) {
+    if (ply >= 40) {
         if (_remainingTime <= 100) {
             return _increment / 2;
         } else {
             return std::max(20u, _remainingTime / 4);
         }
     } else {
         return std::max(_increment - 1,
-                        _remainingTime / (35 - ply) + _increment);
+                        _remainingTime / (40 - ply) + _increment);
     }
 }

src/types.h

@@ -21,4 +21,4 @@ struct KillerHeuristics {
     bool has(Move move) {
         return move.move() == killer1 || move.move() == killer2;
     }
-};
+};

src/uci.cpp

@@ -21,7 +21,7 @@ void execute(const std::string &command) {
 
     // <Command> uci
     if (token == "uci") {
-        std::cout << "id name Emerald" << std::endl;
+        std::cout << "id name Emerald " << ENGINE_VERSION << std::endl;
         std::cout << "id author UndefinedCpp" << std::endl;
         // TODO Send options
         std::cout << "uciok" << std::endl;

src/uci.h

@@ -4,6 +4,8 @@
 #include <sstream>
 #include <string>
 
+#define ENGINE_VERSION "0.1.1"
+
 namespace uci {
 
 void execute(const std::string &command);