uci.cpp

#include <iostream>
#include <string>
#include "uci.h"
#include "search.h"
#include "fenstring.h"
#include "board.h"
#include "stopwatch.h"
#include "benchmark.h"
#include "evaluation.h"
#include "moveselector.h"
#include "movegenerator.h"
#include "searchinfo.h"
#include "csv.h"
//#include "tuner.h"
#include <fstream>

namespace Napoleon
{
using namespace std;

Board Uci::board;
thread Uci::search;

void Uci::Start()
{
  const std::string model_path = "./models/model.onnx";
  int gpu_device = 0;
  bool exit = false;
  string line;
  string cmd;
  Search::Table.SetSize(512);
  Search::InitializeThreads();
  Evaluation::init(model_path, gpu_device);

  SendCommand<Command::Generic>("--------Napoleon Engine--------");
  cout.setf(ios::unitbuf);// Make sure that the outputs are sent straight away to the GUI

  while(!exit && getline(cin, line))
  {
    istringstream stream(line);
    stream >> cmd;

    if (cmd == "uci")
    {
      SendCommand<Command::Generic>("id name Napoleon");
      SendCommand<Command::Generic>("id author Marco Pampaloni");
      SendCommand<Command::Generic>("option name Hash type spin default 1 min 1 max 131072"); // max 128 GB
      SendCommand<Command::Generic>("option name Threads type spin default 1 min 1 max 8");

      for (auto i=0; i<Search::Parameters::MAX; i++)
      {
        SendCommand<Command::Generic>("option name " + Search::param_name[i] + " type spin default 1 min 1 max 1024");
      }
      SendCommand<Command::Generic>("uciok");
    }
    else if (cmd == "setoption")
    {
      string token;
      stream >> token; // "name"
      stream >> token;

      if(token == "Hash")
      {
        stream >> token; // "value"
        stream >> token;
        Search::Table.SetSize(std::stoi(token));
      }
      else if (token == "Threads") 
      {
        int parallel_threads;
        stream >> token; // "value"
        stream >> parallel_threads;
        Search::InitializeThreads(parallel_threads);
      }
      else if (token == "PstPawnMg") // evaluation parameters
      {
        stream >> token; // "value"
        int i=0;
        int val;
        while (stream >> val)
          PieceSquareTable[PieceType::Pawn][Opening][i++] = val;
      }
      else if (token == "Record") 
      {
        Search::positions_dataset = new ofstream();
        Search::positions_dataset->open("positions_dataset.csv", ios::out | ios::app);
        Search::record_positions = true;
      }
      else
    {
        for (auto i=0; i<Search::Parameters::MAX; i++)
        {
          if (token == Search::param_name[i])
          {
            stream >> token; // "value"
            stream >> Search::param[i];
            break;
          }
        }
      }
    }
    else if (cmd == "quit")
    {
      SendCommand<Command::Generic>("Bye Bye");
      Search::KillThreads();
      exit = true;
      if (Search::record_positions) {
        Search::positions_dataset->close();
      }
    }
    else if (cmd == "isready")
    {
      SendCommand<Command::Generic>("readyok");
    }
    else if (cmd == "ucinewgame")
    {
      Search::Table.Clear();
    }
    else if (cmd == "stop")
    {
      Search::StopThinking();
    }
    else if (cmd == "perft")
    {
      Benchmark bench(board);

      int depth;
      stream >> depth;

      StopWatch watch = StopWatch::StartNew();

      cout << "Perft(" << depth << "): ";
      cout << "Total Nodes: " << bench.Perft(depth) << endl;
      cout << "Time (ms): " << watch.ElapsedMilliseconds() << endl;
    }
    else if (cmd == "position")
    {
      //Search::StopThinking();
      Move move;
      string token;
      stream >> token;

      if (token == "startpos")
      {
        board.LoadGame();
        stream >> token;
      }
      else if (token == "fen")
      {
        string fen;
        while (stream >> token && token != "moves")
          fen += token + " ";

        board.LoadGame(fen);
      }

      while (stream >> token && !(move = board.ParseMove(token)).IsNull())
      {
        board.MakeMove(move);
      }
    }
    else if (cmd == "ECM")
    {
      int depth;
      stream >> depth;

      Benchmark bench(board);
      bench.Start(depth);
    }
    else if (cmd == "disp")
    {
      board.Display();
    }
    else if (cmd == "eval")
    {
      Evaluation::PrintEval(board);
      std::cout << Evaluation::Evaluate(board) << std::endl;
    }
    else if (cmd == "nneval") {
      Evaluation::PrintEval(board);
      std::cout << Evaluation::evaluateNN(board) << std::endl;
    }
    else if (cmd == "go")
    {
      //if (Search::StopSignal)
      go(stream);
    }
    else if (cmd == "ponderhit")
    {
      Search::PonderHit = true;
    }
    else if (cmd == "csv")
    {
      std::cout << board.ToCsv() << std::endl;
    }
    else if (cmd == "preprocess")
    {
      std::string token;
      std::string inpath;
      std::string outpath;
      while(stream >> token) {

        if (token == "in") {
          stream >> inpath;
        }
        if (token == "out") {
          stream >> outpath;
        }
      }
      preprocess_csv(inpath, outpath, true);
      std::cout << std::endl;
    }
    else if (cmd == "moves")
    {
      SearchInfo searchInfo;
      searchInfo.NewSearch();
      MoveSelector moves(board, searchInfo);
      MoveGenerator::GetLegalMoves(moves.moves, moves.count, board);
      for (auto move = moves.First(); !move.IsNull(); move = moves.Next()) {
        std::cout << move.ToAlgebraic() << " ";
      }
      std::cout << std::endl;
    }
    /*
            else if (cmd == "tune")
            {
                Tuner tuner;
                tuner.Tune();
            }
            */
  }
}

void Uci::go(istringstream& stream)
{
  string token;
  SearchType type = SearchType::TimePerGame;
  bool san = false;

  while(stream >> token)
  {
    if (token == "depth")
    {
      stream >> Search::depth_limit;
      type = SearchType::Infinite;
    }
    else if (token == "movetime")
    {
      stream >> Search::MoveTime;
      type = SearchType::TimePerMove;
    }

    else if (token == "wtime")
    {
      stream >> Search::GameTime[PieceColor::White];
      //type = SearchType::TimePerGame;
    }
    else if (token == "btime")
    {
      stream >> Search::GameTime[PieceColor::Black];
      //type = SearchType::TimePerGame;
    }
    else if (token == "infinite")
    {
      type = SearchType::Infinite;
    }
    else if (token == "ponder")
    {
      type = SearchType::Ponder;
    }

  }

  search = thread(Search::StartThinking, type, ref(board), true, san);
  search.detach();
}

}