Made plenty of changes in this commit guys...

*Removed const from minimax search functions, due to Heuristics object passing in BitBoards

*moved Heuristics into seperate class

include/BitBoard.h

@@ -16,7 +16,15 @@ typedef std::vector<std::unique_ptr<Move>> vmup;
 
 class BitBoard
 {
-private:
+
+  /* Class member variables */
+  uint32_t m_blackPieces = 0x41C71C3;
+  uint32_t m_whitePieces = 0xE3820C38;
+  uint32_t m_kings = 0;
+
+  bool m_isBlacksTurn = true;
+
+ public:
   /* Static bit masks */
 
   // Used to determine whether a move from that direction is valid
@@ -36,50 +44,24 @@ class BitBoard
       0x10410004,
       0x20820008,
       0x41104010,
-      0x82100820};
+      0x82000820};
     return r[index];
   }
 
-  static const uint32_t whiteKingSpots = 0x00041041;
-  static const uint32_t blackKingSpots = 0x82000820;
+  static const uint32_t whiteKingSpots = 0x00041041; // rowMask(0)
+  static const uint32_t blackKingSpots = 0x82000820; // rowMask(7)
 
   // Used for determing board from move
   static const uint32_t topCorner = 0xC3C;
 
-  /* Class member variables */
-  uint32_t m_blackPieces = 0x41C71C3;
-  uint32_t m_whitePieces = 0xE3820C38;
-  uint32_t m_kings = 0;
-
-  bool m_isBlacksTurn = true;
-
-  //  static constexpr uint32_t rowMask[8];
   /* Class member functions */
 
   // These are basic 32 bit rotation functions
   // Details here: http://stackoverflow.com/questions/776508/best-practices-for-circular-shift-rotate-operations-in-c
   uint32_t rotl32 (uint32_t n, unsigned int c) const;
   uint32_t rotr32 (uint32_t n, unsigned int c) const;
 
-  const uint32_t playerPieces() const;
-
-  const int count(uint32_t i) const;
-
-  // Heuristic functions
-  int evalScore;
-  void evalHueristics();
-
-  int h1() const;
-  int h2() const;
-  int h3() const;
-  int h4() const;
-  int h5() const;
-  int h6() const;
-  int h7() const;
-  int h8() const;
-  int h9() const;
-  int h10() const;
-
+ private:
   int getIndex(uint32_t piece) const;
 
   void addJumps(vmup &moves) const;
@@ -96,10 +78,15 @@ class BitBoard
   BitBoard(uint32_t black, uint32_t white, uint32_t kings);
   BitBoard(const BitBoard &board);
 
+  uint32_t getBlackPieces() { return m_blackPieces; };
+  uint32_t getWhitePieces() { return m_whitePieces; };
+  uint32_t getKings () { return m_kings; };
+  bool getIsBlacksTurn() { return m_isBlacksTurn; };
+
   std::string player() const;
   vmup actions() const;
   bup result(mup &move) const;
-  double utility(std::string player) const;
+  double utility() const;
   void printState() const;
 };
 

include/MinimaxSearch.h

@@ -6,23 +6,25 @@
 #include <memory>
 #include "Move.h"
 #include "BitBoard.h"
+#include "Heuristic.hpp"
 
 typedef std::unique_ptr<Move> mup;
 
 class MinimaxSearch
 {
 private:
-  static const int maxDepth = 9;
+  static const int maxDepth = 1;
+    Heuristic heuristic;
 
-  double minValue(std::unique_ptr<BitBoard> &board, int currentDepth) const;
-  double maxValue(std::unique_ptr<BitBoard> &board, int currentDepth) const;
-  double alphaBeta(std::unique_ptr<BitBoard> &board, double alpha, double beta, int depth) const;
+    double minValue(std::unique_ptr<BitBoard> &board, int currentDepth);
+    double maxValue(std::unique_ptr<BitBoard> &board, int currentDepth);
+    double alphaBeta(std::unique_ptr<BitBoard> &board, double alpha, double beta, int depth);
 
 
 public:
-  Move minimaxDecisionStack(const BitBoard &board) const;
-  mup minimaxDecision(std::unique_ptr<BitBoard> &board) const;
-
+    mup minimaxDecision(std::unique_ptr<BitBoard> &board);
+ MinimaxSearch(Heuristic& h): heuristic(h){};
+    MinimaxSearch() {};
 };
 
 #endif

src/BitBoard.cpp

@@ -7,6 +7,7 @@
 #include <memory>
 #include "Move.h"
 #include "BitBoard.h"
+#include "Heuristic.hpp"
 
 typedef std::unique_ptr<BitBoard> bup;
 typedef std::unique_ptr<Move> mup;
@@ -248,15 +249,18 @@ bup BitBoard::result(mup &move) const
   return result;
 }
 
-double BitBoard::utility(std::string player) const
+double BitBoard::utility() const
 {
-  if (m_isBlacksTurn) {
+//  std::cout << h.evalHeuristics(m_blackPieces, m_whitePieces, m_kingPieces);
+/*  if (m_isBlacksTurn) {
     std::bitset<32> bits (m_blackPieces);
     return 12 - bits.count();
   }
 
   std::bitset<32> bits (m_whitePieces);
   return bits.count() - 12;
+*/
+  return 0;//  return heuristic.evaluate(m_blackPieces, m_whitePieces, m_kingPieces);
 }
 
 void BitBoard::printState() const

src/MinimaxSearch.cpp

@@ -12,9 +12,9 @@ typedef std::unique_ptr<Move> mup;
 
 /* Private Functions */
 
-double MinimaxSearch::minValue(bup &board, int currentDepth) const
+double MinimaxSearch::minValue(bup &board, int currentDepth) 
 {
-  if (currentDepth == maxDepth) return board->utility(board->player());
+  if (currentDepth == maxDepth) return heuristic.evaluate(board);
   double v = std::numeric_limits<double>::max();
   for (mup &move : board->actions()) {
     bup result = board->result(move);
@@ -23,9 +23,9 @@ double MinimaxSearch::minValue(bup &board, int currentDepth) const
   return v;
 }
 
-double MinimaxSearch::maxValue(bup &board, int currentDepth) const
+double MinimaxSearch::maxValue(bup &board, int currentDepth) 
 {
-  if (currentDepth == maxDepth) return board->utility(board->player());
+  if (currentDepth == maxDepth) return heuristic.evaluate(board);
   double v = std::numeric_limits<double>::lowest();
   for (mup &move : board->actions()) {
     bup result = board->result(move);
@@ -34,10 +34,9 @@ double MinimaxSearch::maxValue(bup &board, int currentDepth) const
   return v;
 }
 
-double MinimaxSearch::alphaBeta(bup &board, double alpha, double beta, int depth) const
+double MinimaxSearch::alphaBeta(bup &board, double alpha, double beta, int depth) 
 {
-  if (depth == maxDepth) return board->utility(board->player());
-
+  if (depth == maxDepth) return heuristic.evaluate(board);
 
   // black is max player here
   double v;
@@ -63,7 +62,7 @@ double MinimaxSearch::alphaBeta(bup &board, double alpha, double beta, int depth
 }
 /* Public Functions */
 
-mup MinimaxSearch::minimaxDecision(bup &board) const
+mup MinimaxSearch::minimaxDecision(bup &board) 
 {
   mup bestMove;
   double bestMoveValue{0.0};

src/main.cpp

@@ -10,7 +10,7 @@ int main(int argc, const char * argv[]) {
     std::unique_ptr<BitBoard> board (new BitBoard);
     MinimaxSearch searchDriver;
 
-    for (int i = 0; i < 20; ++i) {
+    for (int i = 0; i < 100; ++i) {
       board->printState();
       std::unique_ptr<Move> bestMove = searchDriver.minimaxDecision(board);
       board = board->result(bestMove);