Min-Max Algorithm - StackOverFlowError ???

Question

Having trouble with my minmax algorithm for my game. Keep getting StackOverFlowError - possible due to too much recursion???
If it is too much recusion - ie the game tree is too vast what should I do?
This is just for a Dominoes game - so I didnt think it would be that complicated :S
Any help / suggestions / insight will be greatly appreciated!!!
NB. It is the tacticExtreme method that is the recursive one
// Strategy MinMax
    public void tacticMinMaxAlpha(Domino player[]) {
            Domino probDomino = new Domino(7,7);
            int score = 0;
            int highestScore = 0;
            // Create array of possible opponent dominoes
            possiblePlays();
            // Create ArrayList of possible moves from current situation
            ArrayList possMoves = new ArrayList(possibleMoves(player, moveLeft, moveRight));
            if(possMoves.size() == 0) {
                 // If there are no plays do nothing!
            } else {
                 // For each of my dominoes that are playable...
              for(int i = 0; i < possMoves.size(); i++){
                  Domino tempDomino[] = new Domino[7];
                  int newLeft = moveLeft;
                     int newRight = moveRight;
                 Domino domino = (Domino)possMoves.get(i);
                 if (domino.x == moveLeft && domino.x != moveRight) {
                     newLeft = domino.y;
                 } else if (domino.x == moveRight){
                     newRight = domino.y;
                 } else if (domino.y == moveLeft && domino.y != moveRight) {
                     newLeft = domino.x;
                 } else if (domino.y == moveRight) {
                     newRight = domino.x;
                 // Mark the domino used
                 for(int j = 0; j < 7; j++){
                      tempDomino[j] = new Domino(player[j].x, player[j].y);
                      //if(!player[j].available) tempDomino[j].available = false;
                        if(domino.x == tempDomino[j].x){
                             if(domino.y == player[j].y){
                                  tempDomino[j].available = false;
                 // Calculate the number of possible moves at most the opponent may have
                    ArrayList other = new ArrayList(possibleMoves(possible, newLeft, newRight));
                   if(other.size() > 0){
                        score = tacticExtreme(tempDomino, possible, newLeft, newRight, false);     
                 if (score > highestScore) {
                     highestScore = score;
                     probDomino = new Domino(domino.x, domino.y);
                 } else if(score == highestScore){
                      if((domino.x + domino.y) > (probDomino.x + probDomino.y)){
                           probDomino = new Domino(domino.x, domino.y);
         if((probDomino.x != 7)){
              for(int i = 0; i < 7; i++){
                   if(probDomino.x == player.x){
                    if(probDomino.y == player[i].y){
                         play = i + 1;
} else {
     play = 0;
} // end tacticProbability()
// Tactic tacticProbability
public int tacticExtreme(Domino player1[], Domino player2[], int left, int right, boolean flag) {
          int score = 0;
          boolean player1First = flag;
          // Check not greater than 3 recursion calls by this method
          if( DepthLimitReached() ){
               depth = 0;
          } else {
               if(player1First){
               Domino tempDomino[] = new Domino[player1.length];
               ArrayList possMoves = new ArrayList(possibleMoves(player1, moveLeft, moveRight));
               // For each playable domino
          for(int i = 0; i < possMoves.size(); i++){
          int newLeft = left;
          int newRight = right;
     Domino domino = (Domino)possMoves.get(i);
     if (domino.x == moveLeft && domino.x != moveRight) {
     newLeft = domino.y;
     } else if (domino.x == moveRight){
     newRight = domino.y;
     } else if (domino.y == moveLeft && domino.y != moveRight) {
     newLeft = domino.x;
     } else if (domino.y == moveRight) {
     newRight = domino.x;
          // Mark the current domino as used to pass to the next recursion call
     for(int j = 0; j < player1.length; j++){
          tempDomino[j] = new Domino(player1[j].x, player1[j].y);
                    if(domino.x == tempDomino[j].x){
                         if(domino.y == player1[j].y){
                              tempDomino[j].available = false;
                    // Check if that was the last Domino in hand. If it wasn't then continue on search tree.
                    if(outOfDominoes(tempDomino)){
                         score = 100; // Played all the Dominoes - WIN!!!
                    } else {
                         ArrayList x = new ArrayList(player2.length);
                         x = possibleMoves(player2, newLeft, newRight);
               ArrayList y = new ArrayList(tempDomino.length);
                         y = possibleMoves(tempDomino, newLeft, newRight);
               if(x.size() > 0) { // If player2 has a move it is their turn
                    score = tacticExtreme(tempDomino, player2, newLeft, newRight, !player1First);
               } else if (y.size() > 0){ // If player2 has no move. Have I got a move?
                    score = tacticExtreme(tempDomino, player2, newLeft, newRight, player1First);
               } else { // If no one can make a move then it is a draw.
                    score = 50;
          } else {
               Domino tempDomino[] = new Domino[player2.length];
               ArrayList possMoves = new ArrayList(possibleMoves(player2, moveLeft, moveRight));
               // For each playable domino
          for(int i = 0; i < possMoves.size(); i++){
          int newLeft = left;
          int newRight = right;
     Domino domino = (Domino)possMoves.get(i);
     if (domino.x == moveLeft && domino.x != moveRight) {
     newLeft = domino.y;
     } else if (domino.x == moveRight){
     newRight = domino.y;
     } else if (domino.y == moveLeft && domino.y != moveRight) {
     newLeft = domino.x;
     } else if (domino.y == moveRight) {
     newRight = domino.x;
          // Mark the domino used     
     for(int j = 0; j < player2.length; j++){
          tempDomino[j] = new Domino(player2[j].x, player2[j].y);
                    if(domino.x == tempDomino[j].x){
                         if(domino.y == player2[j].y){
                              tempDomino[j].available = false;
                    if(outOfDominoes(tempDomino)){
                         score = -100;
                    } else {
                         ArrayList other = new ArrayList(player1.length);
                         other = possibleMoves(player1, newLeft, newRight);
               ArrayList myPlayable = new ArrayList(tempDomino.length);
                         myPlayable = possibleMoves(tempDomino, newLeft, newRight);
               if(other.size() > 0) {
                    score = tacticExtreme(player1, tempDomino, newLeft, newRight, player1First);
               } else if (myPlayable.size() > 0){
                    score = tacticExtreme(player1, tempDomino, newLeft, newRight, !player1First);
               } else {
                    score = 50;
     return score;
} // end tacticExtreme()

Answer 1

You are so wrong!
The recursion depth of MinMax is limited to the number of moves into the future you want the computer to think.
If you have a complex game with 100 different possible moves, and you want the computer to think 4 moves into the future, then the recursion depth will be 4.
If you have a simple game with just 2 different possible moves, and you want the computer to think 4 moves into the future, then the recursion depth will still be 4.
In both cases you need a stack that can handle the depth of 4.
The stack might be small, yes, but the stack size needed is extremely small.
The time it takes to complete the algorithm will be dependent of the complexity of the game.
A complex game as mentioned above would run the recursive method 100^4 = 100000000 times, and the simple game as mentioned above would run the recursive method 2^4 = 16 times.
In addition, one single run trough the method would normally be faster in a more simple game.
In order to make an AI that is as smart as possible without being slow, you would normally increase the recursion depth of the simple game, and decrease the recursion depth of the complex game.
To summarize:
The stack size needed for the complex game is smaller than the stack size needed for the simple game.
The stack size needed (both for the complex and the simple game) is very small.
The time needed to complete the algorithm grows exponentially, so it is unfeasible to increase the recursion depth (potentially risking a stack overflow) without causing the calculation to be too slow (assuming the computer never should use more than 1 year to calculate its next move).