Apply clang-format

Author: actions-user

eval.cpp

@@ -1,7 +1,7 @@
 #include "eval.h"
 #include "tune.h"
-#include <position.h>
 #include <iostream>
+#include <position.h>
 using namespace chess;
 using namespace engine::eval;
 
@@ -114,7 +114,7 @@ Value mgMobility[] = {
 };
 
 Value egMobility[] = {0, 0, 2, 5, 3, 2, 0};
-Value spaceWeight=28;
+Value spaceWeight = 28;
 // tuning slop here
 Value eval(const chess::Board &board) {
   constexpr int KnightPhase = 1;
@@ -128,10 +128,10 @@ Value eval(const chess::Board &board) {
   int egScore = 0;
   int phase = 0;
   {
-    mgScore=egScore=board.sideToMove() == WHITE?spaceWeight:0;
-    Bitboard occ = board.occ(), occ2=occ;
+    mgScore = egScore = board.sideToMove() == WHITE ? spaceWeight : 0;
+    Bitboard occ = board.occ(), occ2 = occ;
     while (occ) {
-      Square sq = (Square)pop_lsb(occ),_sq=sq;
+      Square sq = (Square)pop_lsb(occ), _sq = sq;
       auto p = board.at(sq);
       int _sign = 1;
       if (color_of(p) == BLACK) {
@@ -296,12 +296,14 @@ Value eval(const chess::Board &board) {
     int endF = std::min(7, (int)kf + 1);
     for (int adjF = startF; adjF <= endF; adjF++) {
       if (c == WHITE) {
-        for (int r = rank_of(kingSq) + 1; r <= std::min(7, rank_of(kingSq) + 3); r++) {
+        for (int r = rank_of(kingSq) + 1; r <= std::min(7, rank_of(kingSq) + 3);
+             r++) {
           if (pawns & (Bitboard(1) << make_sq((File)adjF, (Rank)r)))
             shelter += 10 - (r - rank_of(kingSq) - 1) * 3;
         }
       } else {
-        for (int r = rank_of(kingSq) - 1; r >= std::max(0, rank_of(kingSq) - 3); r--) {
+        for (int r = rank_of(kingSq) - 1; r >= std::max(0, rank_of(kingSq) - 3);
+             r--) {
           if (pawns & (Bitboard(1) << make_sq((File)adjF, (Rank)r)))
             shelter += 10 - (rank_of(kingSq) - r - 1) * 3;
         }
@@ -317,9 +319,8 @@ Value eval(const chess::Board &board) {
   return finalScore;
 }
 Value piece_value(PieceType pt) {
-  Value pieces[] = {0, PawnValue, KnightValue,
-                    BishopValue, RookValue, QueenValue,
-                    KingValue};
+  Value pieces[] = {0,         PawnValue,  KnightValue, BishopValue,
+                    RookValue, QueenValue, KingValue};
   return pieces[pt];
 }
 } // namespace engine::eval

main.cpp

@@ -11,11 +11,10 @@ int main() {
   std::cout << std::unitbuf;
   std::cout << "cppchess_engine version " << BUILD_VERSION << '\n';
   options.add("Move Overhead", Option(10, 0, 1000));
-  options.add("Hash", Option(16, 1, 1 << 25,
-                             [](const Option &o) {
-                               search::tt.resize(int(o));
-                               return std::nullopt;
-                             }));
+  options.add("Hash", Option(16, 1, 1 << 25, [](const Option &o) {
+                search::tt.resize(int(o));
+                return std::nullopt;
+              }));
 
   options.add("Clear Hash", Option(+[](const Option &) {
                 search::tt.clear();

movepick.cpp

@@ -7,7 +7,7 @@ using engine::eval::piece_value;
 namespace engine::movepick {
 
 void orderMoves(chess::Board &board, chess::Movelist &moves, chess::Move ttMove,
-                int ply, const engine::search::Session& session) {
+                int ply, const engine::search::Session &session) {
   std::vector<std::pair<chess::Move, Value>> scoredMoves;
   scoredMoves.reserve(moves.size());
 

movepick.h

@@ -1,8 +1,9 @@
 #pragma once
 #include <fwd_decl.h>
-namespace engine::search{
+namespace engine::search {
 struct Session;
 } // namespace engine::search
 namespace engine::movepick {
-void orderMoves(chess::Board &, chess::Movelist &, chess::Move, int, const engine::search::Session&);
+void orderMoves(chess::Board &, chess::Movelist &, chess::Move, int,
+                const engine::search::Session &);
 } // namespace engine::movepick

search.cpp

@@ -354,28 +354,29 @@ void search::search(const chess::Board &board,
 
     // Aspiration windows
     if (i >= 3 && prevScore != VALUE_NONE) {
-        Value delta = Value(17);
-        Value alpha = std::max(prevScore - delta, -VALUE_INFINITE);
-        Value beta = std::min(prevScore + delta, VALUE_INFINITE);
-
-        score_ = doSearch(board_, i, alpha, beta, session);
-
-        if (score_ != VALUE_NONE) {
-            if (score_ <= alpha) {
-                alpha = -VALUE_INFINITE;
-                score_ = doSearch(board_, i, alpha, beta, session);
-            }
-            if (score_ >= beta && score_ != VALUE_NONE) {
-                beta = VALUE_INFINITE;
-                score_ = doSearch(board_, i, alpha, beta, session);
-            }
-            if ((score_ <= alpha || score_ >= beta) && score_ != VALUE_NONE)
-                score_ = doSearch(board_, i, -VALUE_INFINITE, VALUE_INFINITE, session);
-        } else {
-            score_ = doSearch(board_, i, -VALUE_INFINITE, VALUE_INFINITE, session);
+      Value delta = Value(17);
+      Value alpha = std::max(prevScore - delta, -VALUE_INFINITE);
+      Value beta = std::min(prevScore + delta, VALUE_INFINITE);
+
+      score_ = doSearch(board_, i, alpha, beta, session);
+
+      if (score_ != VALUE_NONE) {
+        if (score_ <= alpha) {
+          alpha = -VALUE_INFINITE;
+          score_ = doSearch(board_, i, alpha, beta, session);
         }
-    } else {
+        if (score_ >= beta && score_ != VALUE_NONE) {
+          beta = VALUE_INFINITE;
+          score_ = doSearch(board_, i, alpha, beta, session);
+        }
+        if ((score_ <= alpha || score_ >= beta) && score_ != VALUE_NONE)
+          score_ =
+              doSearch(board_, i, -VALUE_INFINITE, VALUE_INFINITE, session);
+      } else {
         score_ = doSearch(board_, i, -VALUE_INFINITE, VALUE_INFINITE, session);
+      }
+    } else {
+      score_ = doSearch(board_, i, -VALUE_INFINITE, VALUE_INFINITE, session);
     }
     prevScore = score_;
     if (session.tm.elapsed() >= session.tm.optimum() ||