1. rewritten evaluation (missing PSQT here)

2. Enhanced search, move ordering and time management

Author: winapiadmin

.gitignore

@@ -2,7 +2,6 @@
 *
 
 # But not these directories and files
-!*/
 !*.cpp
 !*.hpp
 !*.h

eval.cpp

@@ -218,5 +218,10 @@ namespace chess
 #define MAX_SCORE_CP 31000
 #define MATE(i) MAX_MATE-i
 #define MATE_DISTANCE(i) (i - MAX_MATE)
-int eval(chess::Position &board);
-constexpr int16_t ASPIRATION_DELTA = 30;
+int16_t eval(const chess::Position &board);
+inline int16_t eval(chess::Position &board) {
+    return eval(static_cast<const chess::Position&>(board));
+}
+constexpr int16_t ASPIRATION_DELTA = 30;
+int16_t piece_value(chess::PieceType p);
+int16_t passed(const chess::Position &pos);

eval.h

@@ -15,12 +15,8 @@
 using namespace std;
 
 // Constants
-#define MAX_SCORE_CP 31000
-#define MATE(ply) (32000 - (ply))
 #define IS_MATE_SCORE(score) (abs(score) >= MAX_SCORE_CP)
-#define MATE_DISTANCE(score) (MATE(0) - abs(score))
 constexpr unsigned INFINITE_TIME = std::numeric_limits<unsigned>::max();
-constexpr unsigned DEFAULT_TIME_LIMIT = 5000;
 
 // Thread handle
 static std::thread search_thread;
@@ -32,7 +28,7 @@ void run_search(chess::Position board, int depth, unsigned time_limit_ms, bool i
 
     search::tt.newSearch();
     search::start_time = std::chrono::high_resolution_clock::now();
-    search::time_limit = std::chrono::milliseconds((int)(time_limit_ms*0.2));
+    search::time_limit = std::chrono::milliseconds((int)(time_limit_ms*0.01));
     search::PV stablePV;
 
     clock_t t1 = clock();
@@ -58,7 +54,7 @@ void run_search(chess::Position board, int depth, unsigned time_limit_ms, bool i
             score = search::alphaBeta(board, alpha, beta, d);
         }
 
-        if (score > prev_score)
+        if (search::pv.cmove>0)
         {
             memcpy(&stablePV, &search::pv, sizeof(search::PV));
         }
@@ -73,7 +69,7 @@ void run_search(chess::Position board, int depth, unsigned time_limit_ms, bool i
         if (!IS_MATE_SCORE(score))
             cout << " cp " << score;
         else
-            cout << " mate " << (score < 0 ? "-" : "") << ((MATE_DISTANCE(score) + 1) / 2);
+            cout << " mate " << ((MATE_DISTANCE(score) + 1) / 2);
         cout << " time " << int(elapsed_ms)
              << " nodes " << search::nodes
              << " nps " << int(search::nodes / max(elapsed_ms / 1000.0, 1e-3))
@@ -202,11 +198,14 @@ int main()
             }
 
             search::stop_requested = false;
-            unsigned time_limit_ms = infinite ? INFINITE_TIME : (movetime >= 0 ? movetime : DEFAULT_TIME_LIMIT);
+            unsigned time_limit_ms = INFINITE_TIME;
+            if (!infinite&&movetime>=0){
+                time_limit_ms=movetime;
+            }
             chess::Position board_copy = board;
 
             search_thread = std::thread(run_search, board_copy, depth, time_limit_ms, infinite);
-            //search_thread.detach();
+            search_thread.detach();
         }
         else if (token == "d")
         {
@@ -219,9 +218,6 @@ int main()
 
             board.setFen("rnb1kbnr/pppppppp/8/8/8/8/PPPPPPP1/RNBQKBNR w KQkq - 0 1");
             cout << "White up a queen: " << eval(board) << endl;
-
-            board.setFen("7k/8/8/8/8/8/8/7R b - - 0 1");
-            cout << "Mate Eval: " << eval(board) << endl;
         }
     }
 

main.cpp

@@ -15,6 +15,114 @@
 #include "move_ordering.hpp"
 namespace move_ordering
 {
+chess::Square getLeastValuable(chess::Bitboard attackers, const chess::Position &board, chess::Color side)
+{
+  static const std::array<int, 6> pieceOrder = {
+    (int)chess::PieceType::PAWN,
+    (int)chess::PieceType::KNIGHT,
+    (int)chess::PieceType::BISHOP,
+    (int)chess::PieceType::ROOK,
+    (int)chess::PieceType::QUEEN,
+    (int)chess::PieceType::KING
+  };
+
+  for (int pt : pieceOrder)
+  {
+    while(attackers)
+    {
+	chess::Square sq=attackers.pop();
+      if (board.at(sq).type() == (chess::PieceType::underlying)pt &&
+          board.at(sq).color() == side)
+        return sq;
+    }
+  }
+
+  // fallback — if no attacker found (shouldn't happen)
+  return chess::Square::NO_SQ;
+}
+chess::Bitboard recomputeAttackers(chess::Square target, chess::Bitboard occupied, const chess::Board& board)
+{
+	chess::Bitboard attackers = 0;
+
+  while (occupied)
+  {
+    auto sq=occupied.pop();
+    const chess::Piece piece = board.at(sq);
+    if (piece == chess::Piece::NONE) continue;
+
+    chess::Color c = piece.color();
+    chess::PieceType pt = piece.type();
+
+    switch (pt)
+    {
+	    case (int)chess::PieceType::PAWN:
+        if (chess::attacks::pawn(c, sq).check(target.index()))
+          attackers |= chess::Bitboard::fromSquare(sq);
+        break;
+
+	    case (int)chess::PieceType::KNIGHT:
+        if (chess::attacks::knight(sq).check(target.index()))
+          attackers |= chess::Bitboard::fromSquare(sq);
+        break;
+
+	    case (int)chess::PieceType::BISHOP:
+        if (chess::attacks::bishop(sq, occupied).check(target.index()))
+          attackers |= chess::Bitboard::fromSquare(sq);
+        break;
+
+	    case (int)chess::PieceType::ROOK:
+        if (chess::attacks::rook(sq, occupied).check(target.index()))
+          attackers |= chess::Bitboard::fromSquare(sq);
+        break;
+
+	    case (int)chess::PieceType::QUEEN:
+        if (chess::attacks::queen(sq, occupied).check(target.index()))
+          attackers |= chess::Bitboard::fromSquare(sq);
+        break;
+
+	    case (int)chess::PieceType::KING:
+        if (chess::attacks::king(sq).check(target.index()))
+          attackers |= chess::Bitboard::fromSquare(sq);
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  return attackers;
+}
+int see(const chess::Position &board, chess::Move move)
+{
+  int to = move.to().index();
+  int gain[32], d = 0;
+  chess::Bitboard occupied = board.occ();
+  chess::Color stm = board.sideToMove();
+  gain[0] = piece_value(board.at(to).type());
+  chess::Bitboard attackers = chess::attacks::attackers(board, ~stm, move.to());
+  
+  while (attackers)
+  {
+    chess::Square from = getLeastValuable(attackers, board, stm);
+    if (from == chess::Square::NO_SQ) break; // safety check
+
+    gain[++d] = piece_value(board.at(from).type()) - gain[d - 1];
+
+    if (std::max(-gain[d - 1], gain[d]) < 0)
+      break;
+
+    occupied ^= 1ULL << from.index();
+    attackers = recomputeAttackers(to, occupied, board);
+    stm = ~stm;
+  }
+
+  for (int i = d - 1; i >= 0; --i)
+  {
+    gain[i] = -std::max(-gain[i], gain[i + 1]);
+  }
+
+  return gain[0];
+}
 
   void moveOrder(chess::Position &board, chess::Movelist &moves, int ply)
   {
@@ -36,9 +144,9 @@ namespace move_ordering
       // Capture scoring
       if (board.isCapture(move))
       {
-        auto victim = board.at(move.to()).type();
-        auto attacker = board.at(move.from()).type();
-        score += SCORE_CAPTURE + mvvLva(victim, attacker);
+        //auto victim = board.at(move.to()).type();
+        //auto attacker = board.at(move.from()).type();
+        score += SCORE_CAPTURE + see(board, move);
       }
 
       // Counter move bonus (simple equality check)
@@ -58,7 +166,7 @@ namespace move_ordering
 
       // Promotion bonus
       if (move.typeOf() == chess::Move::PROMOTION)
-        score += std::vector<int>{100,300,320,500,900}[(int)move.promotionType()-1];
+        score += piece_value(move.promotionType());
 
       // Set the score
       move.setScore(score);
@@ -70,4 +178,4 @@ namespace move_ordering
                 return a.score() > b.score();
               });
   }
-}
+}