worked a bit on time managing

src/Minimax.h

@@ -2,7 +2,7 @@
 #define CHESSY_MINIMAX_H
 
 #include "MoveGeneration.h"
-#include "Search.h"
+//#include "Search.h"
 
 namespace chessy
 {

src/Search.h

@@ -41,12 +41,12 @@ public:
 };
 
 
-inline void aga() {
+/*inline void aga() {
     chessy::ChessGame cg;
     chessy::MinimaxN mm;
     chessy::Search<chessy::MinimaxN> search = { mm, cg };
     search.iterateAll(5, 7);
-}
+}*/
 
 
 template<typename T>
@@ -70,11 +70,9 @@ inline void chessy::Search<T>::iterateAll(Args&&... args)
     const Board temp = board;
     
     if (side == WHITE_SIDE)
-        iteratePawns<WHITE_SIDE, Args...>(std::forward<Args...>(args)...);
+        iteratePawns<Args...>(std::forward<Args>(args)...);
     else
-        iteratePawns<BLACK_SIDE, Args...>(std::forward<Args...>(args)...);
-
-
+        iteratePawns<Args...>(std::forward<Args>(args)...);
 
     Bitboard& ns = board.getKnights<side>();
     PositionSet knights { ns };
@@ -156,6 +154,7 @@ template<typename T>
 template<chessy::Side side, typename... Args>
 inline void chessy::Search<T>::iteratePawns(Args&&... args)
 {
+    const Board temp = board;
     PawnPushGenerator<side> mg{ game };
     for (Move push : mg) {
         Bitboard& pawns = board.getPawns<side>();

src/TimeManager.cpp

@@ -0,0 +1,43 @@
+#include "TimeManager.h"
+#include "UciParser.h"
+
+void TimeManager::startInfiniteSearch(void)
+{
+}
+
+
+void TimeManager::stop(void)
+{
+}
+
+
+void TimeManager::startSearch(void)
+{
+    startInfiniteSearch();
+}
+
+
+void FixedSearchTimer::startSearch(void)
+{
+    TimeManager::searchThread = 
+        std::thread{ &FixedSearchTimer::search, this };
+    startPoint = std::chrono::steady_clock::now();
+}
+
+
+void FixedSearchTimer::search(void)
+{
+    chessy::Move best;
+    int depth = 2;
+    while (true) {
+        best = minimax.calculateBest(depth);
+        ++depth;
+        
+        auto now = std::chrono::steady_clock::now();
+        if ((now - startPoint) > thinkTime) {
+            uci.sendCommand("bestmove", { best.asString() });
+            break;
+        }
+    }
+}
+

src/TimeManager.h

@@ -0,0 +1,57 @@
+#ifndef TIME_MANAGER_H
+#define TIME_MANAGER_H
+
+#include <chrono>
+#include <thread>
+
+#include "Minimax.h"
+
+namespace chessy
+{
+    class ChessGame;
+}
+
+class UciParser;
+
+
+class TimeManager
+{
+protected:
+    using Millisecs = std::chrono::milliseconds;
+    chessy::ChessGame& game;
+    chessy::MiniMax minimax;
+
+    std::thread searchThread;
+
+    UciParser& uci;
+
+public:
+    inline TimeManager(chessy::ChessGame& game, UciParser& uci) :
+        game{ game }, minimax{ game }, uci{ uci } {}
+    
+    void startInfiniteSearch(void);
+
+    virtual void stop(void);
+    virtual void startSearch(void);
+};
+
+
+class FixedSearchTimer :
+    public TimeManager
+{
+protected:
+    Millisecs thinkTime;
+    std::chrono::time_point<std::chrono::steady_clock> startPoint;
+public:
+    inline FixedSearchTimer(chessy::ChessGame& game, UciParser& uci) :
+        TimeManager{ game, uci } {}
+
+    inline Millisecs    getThinkTime(void) const    { return thinkTime; }
+    inline void         setThinkTime(Millisecs t)   { thinkTime = t; } 
+
+    virtual void startSearch(void) override;
+    virtual void search(void);
+};
+
+
+#endif // TIME_MANAGER_H

src/UciParser.cpp

@@ -15,6 +15,7 @@ const map<std::string, UciParser::CommandHandler> UciParser::commandHandlers = {
     {"ucinewgame",  &UciParser::ucinewgame },
     {"position",    &UciParser::position },
     {"go",          &UciParser::go },
+    {"stop",        &UciParser::stop },
     {"quit",        &UciParser::quit },
     {"getfen",      &UciParser::getfen},
 };
@@ -74,6 +75,7 @@ int UciParser::executeCommand(const string& command,
 void UciParser::sendCommand(const std::string& command,
     const std::vector<std::string>& args)
 {
+    std::unique_lock<std::mutex> lock { outStreamLock };
     cout << command;
     std::for_each(args.begin(), args.end(), [] (auto& x) { cout << " " << x; });
     cout << endl;
@@ -162,6 +164,12 @@ void UciParser::go(const vector<string>& args)
 }
 
 
+void UciParser::stop(const vector<string>& args)
+{
+
+}
+
+
 void UciParser::quit(const vector<string>& args)
 {
     quitting = true;

src/UciParser.h

@@ -6,8 +6,10 @@
 #include <string>
 #include <algorithm>
 #include <map>
+#include <mutex>
 
 #include "ChessGame.h"
+#include "TimeManager.h"
 #include "Minimax.h"
 
 
@@ -44,12 +46,16 @@ class UciParser
 
     std::istream& in;
     std::ostream& out;
+    std::mutex outStreamLock;
+
     OptionsManager optionsManager;
 
     bool quitting = false;
 
     chessy::ChessGame cg;
-    chessy::MiniMax minimax { cg };
+    chessy::MiniMax minimax{ cg };
+
+    FixedSearchTimer fst{ cg, *this };
 public:
     inline UciParser(std::istream& in = std::cin, std::ostream& out = std::cout) :
         in{ in }, out{ out } {}
@@ -72,6 +78,7 @@ public:
     virtual void ucinewgame     (const std::vector<std::string>& args);
     virtual void position       (const std::vector<std::string>& args);
     virtual void go             (const std::vector<std::string>& args);
+    virtual void stop           (const std::vector<std::string>& args);
     virtual void quit           (const std::vector<std::string>& args);
 
     // engine-specific extension commands

src/main.cpp

@@ -8,8 +8,6 @@ using namespace chessy;
 
 auto main(int argc, char** argv) -> int
 {
-    aga();
-
     UciParser uciParser;
     uciParser.parse(cin, cout);
     return 0;