title: Java Minimax Alpha-Beta Pruning Recursion Return
body: <p>I am trying to implement minimax with alpha-beta pruning for a checkers game in Java. My minimax algorithm works perfectly. My code runs with the alpha-beta code in place. Unfortunately, when I play 1000 games vs the standard minimax algorithm, the alpha-beta algorithm always comes out behind by 50 games or so. </p>
  
  <p>Since alpha-beta pruning should not be reducing the quality of the moves, just the time it takes to achieve them, something has to be wrong. However, I have taken out pen and paper and drawn hypothetical leaf node values and used my algorithm to predict whether it will calculate the correct best move, and there doesn't appear to be any logic errors. I used the tree from this video: <a href="http://www.youtube.com/watch?feature=player_detailpage&amp;v=xBXHtz4Gbdo">Alpha-Beta Pruning</a> to trace my algorithm. It logically should make all of the same choices, and therefore be a functioning implementation. </p>
  
  <p>I have also put print statements into the code (they have been removed to reduce the clutter), and values are being returned correctly it appears and pruning does happen. Despite my best efforts I have been unable to find where the logic error lies. This is my third different attempt at implementing this and all of them have had the same issue.</p>
  
  <p>I can't post the full code here, it's much too long, so I have included the methods that are relevant to the error. I'm not certain, but I suspect the problem may likely be in the non-recursive move() method, though I can't find a logical error in it so I'd just be thrashing around in it more, probably making things worse rather than better without having a rhyme or reason.</p>
  
  <p><strong>Is there a trick to recovering multiple integer values from recursive calls in a for loop?</strong> It works fine with both my minimax and negamax implementations, but alpha-beta pruning seems to produce some strange results.</p>
  
  <pre><code>@Override
  public GameState move(GameState state) 
  {
      int alpha = -INFINITY;
      int beta = INFINITY;
      int bestScore = -Integer.MAX_VALUE;
      GameTreeNode gameTreeRoot = new GameTreeNode(state);
      GameState bestMove = null;
      for(GameTreeNode child: gameTreeRoot.getChildren())
      {
          if(bestMove == null)
          {
              bestMove = child.getState();
          }
          alpha = Math.max(alpha, miniMax(child, plyDepth - 1, alpha, beta));
          if(alpha &gt; bestScore)
          {
              bestMove = child.getState();
              bestScore = alpha;
          }
      }
      return bestMove;
  }
  
  private int miniMax(GameTreeNode currentNode, int depth, int alpha, int beta) 
  {
      if(depth &lt;= 0 || terminalNode(currentNode.getState())) 
      {
          return getHeuristic(currentNode.getState());
      }
      if(currentNode.getState().getCurrentPlayer().equals(selfColor))
      {
          for(GameTreeNode child: currentNode.getChildren())
          {
              alpha = Math.max(alpha, miniMax(child, depth - 1, alpha, beta));
  
              if(alpha &gt;= beta)
              {
                  return beta;
              }
          }
          return alpha;
      }
      else
      {
          for(GameTreeNode child: currentNode.getChildren())
          {
              beta = Math.min(beta, miniMax(child, depth - 1, alpha, beta));
  
              if(alpha &gt;= beta)
              {
                  return alpha;
              }
          }
          return beta;
      }
  }
  //Checks to see if the node is terminal
  private boolean terminalNode(GameState state)
  {
  if(state.getStatus().equals(win) || state.getStatus().equals(lose) || state.getStatus().equals(draw))
      {
          return true;
      }
      else
      {
          return false;
      }
  }
  </code></pre>