Hello,
Im new to this so please escuse my mistakes.
I'm trying to implement a 9Men's Morris game and i'm using minimax with alpha-beta pruning finding BestMove for "computer".
The problem is that if depth >= 3 then getBestMove() returns invalid move (board) , meaning that
it's returning a move (board) from other team sometimes - and I don't know where i go wrong.
Is my algorithm implementation done right ?! What i'm missing ?
Please Help !!
Here is my Java code , and getBestMove() function :
private int getBestMove(board board, int depth, int alpha, int beta, boolean bIsMax)
{
// is depth reached ? or do we have a winner ? (checkWinner() returns 0 if nobody is winning so far!)
if (depth == 0 || board.checkWinner()!=0)
{
// if depth reached, or we DO have a winner.
return board.evaluateBoard();
}
// is "computer" turn
if (bIsMax)
{
// generate all possible boards for "computer" (MAX).
ArrayList<board> boardsArray = board.generateNextPossibleBoards(bIsMax);
// loop thru all possible previously generated boards
for(board nextBoard: boardsArray)
{
// recurse
int score = Math.max(alpha, getBestMove(nextBoard, depth - 1, alpha, beta, !bIsMax));
nextBoard.showBoard("next-max[" + boardsArray.size() + "]"); // display to user current board.(debbuging purpose)
// found a better board ?
if ( score > alpha )
{
alpha = score;
chosenBoard = nextBoard; // save best board so far to "chosenBoard"
}
if(beta<=score) break; // prune
}
// clear boards array when done.
boardsArray.clear();
// return alpha.
return alpha;
}
else
{
// generate all possible boards for "player" (MIN).
ArrayList<board> boardsArray = board.generateNextPossibleBoards(bIsMax);
// loop thru all these possible boards.
for(board nextBoard: boardsArray)
{
// recurse
beta = Math.min(beta, getBestMove(nextBoard, depth - 1, alpha, beta, !bIsMax));
nextBoard.showBoard("next-min[" + boardsArray.size() + "]");
if(beta <= alpha) break; // prune.
}
// clear boards array when done.
boardsArray.clear();
// return beta.
return beta;
}
}
and the calling of this method is:
short depth = 2;
// get best move for "computer" on this phase
getBestMove(simulationBoard, depth , Integer.MIN_VALUE+1, Integer.MAX_VALUE-1, true);
and this is the evaluation function :
// evaluate current board.
public int evaluateBoard()
{
int score = 0;
score = score + (checkWinner()); // checkWinner() returns -1000000 if player wins, +1000000 if computer wins.
score = score + (checkMills()*1000); // checkMills() returns -10000*mills_count if player has some mills formed, or +10000*mills_count otherwise.
score = score + (checkBlockers()*500); // checkBlockers() returns -1000*block_count if player has bloked some tokens, or +1000*block_count otherwise
score = score + (checkFormers()*50); // etc.
score = score + (checkTokenDifference()*10);
return score;
}
and the generateNextPossibleBoards() function wich chooses "default" switch case here :
public ArrayList<board> generateNextPossibleBoards(boolean bIsMax)
{
// copy current board
board currentBoard = new board(this);
// instantiate a empty array.
ArrayList<board> boardsArray = new ArrayList<board>();
// current team is unknown.
short team = -1;
short game_status = -1;
// update current team (can be "computer" or "human" player).
if(bIsMax)
{
team = renderer.TEAM_OPPONENT;
game_status = (short) renderer.gOpponent.gGameStatus;
}
else
{
team = renderer.TEAM_PLAYER;
game_status = (short) renderer.gPlayer.gGameStatus;
}
// according to current player's (computer/human) game-status:
switch(game_status)
{
...
default:
// generate a move (a board) and save this new board to boardsArray.
// if no moves left, return all boards so far!
for(short i=0;i<24;i++)
{
// go thru all tokens in this board.
if(currentBoard.gNode.gOccupiedByTeam==team)
{
// check if any empty neighbours for this token
for(short n=0;n<4;n++)
{
// get neighborur node id
short id = currentBoard.gNode.gNeighbourId[n];
// check if neighbour is empty spot (empty node)
if(id!=-1 && currentBoard.gNode[id].gOccupiedByTeam==renderer.TEAM_NOTEAM)
{
// make move for this token to the empty neighbour found above.
currentBoard.makeMoveToken( i , id );
boardsArray.add(new board(currentBoard));
// undo previous move
currentBoard.undoMoveToken( id , i );
}
}
}
}
break;
}//end switch.
// return all possible boards so far.
return boardsArray;
}
thak you.
P.S: sorry for the bad view of some of the code.
just could not succeded making it "java" (using [source lang="java"]) because it was "eating" my code and the functions were displayed
partially .
I don't really know Java, but I don't see any obvious bugs in the code you posted.
It's easier to get things right by adopting the negamax convention (in every node positive score means good for the player to move, so you flip the sign of the result of the recursive call and treat every node as a max node).
I don't really know Java, but I don't see any obvious bugs in the code you posted.
It's easier to get things right by adopting the negamax convention (in every node positive score means good for the player to move, so you flip the sign of the result of the recursive call and treat every node as a max node).
Thank you for replying mr. alvaro.
The algorithm should be the same, and it looks ok to me so far also ... but i still dont get it
Why it returns some invalid moves when depth is greater or equal than 3 (i.e depth >= 3) ??
With depth>2 the algorithm should "see" ahead further moves and return them.
I only get moves from "player"'s team (not the "computer" team as it should).
But with depth = 1 or 2 all is just Fine ! (it returns best board/move from all of possible boards'/moves)
But this has a disadvantage: it cannot anticipate further moves of the "player" . Only the "power" of the evaluateBoard() function is used then (a local board evaluation).
You have a bug, but it is not obvious to me what it is, from the code posted here and my understanding of Java. It is perfectly possible that your bug is in some other part of the code. I'm afraid you are going to have to debug it yourself. Find a position where the problem occurs and try to step through the code with a debugger. Unfortunately, recursive code is notoriously confusing to debug unless you have experience.
when adding features to a minimax search I've found it useful to compare the output of the newly enhanced search with the output of the basic search (in this case the pure minimax). For most new features the results should be the same (not always, in rare cases of transposition tables, obviously things like razoring will change the output).
If that checks out then you need to step through (depth three shouldn't be too hard for this) maybe with a contrived starting position.Remember that your fist branch should return at least some value (not an invalid board), so your step iteration will only be 2 + branching factor to at least see the first leaf branch return something.
I think I see the problem in the code. The chosenBoard looks like a global variable, and it will be overwritten at a lower level from a future cutoff from the current 'best board'. Avoid global variables in recursive code, rather return the best board and let the parent decide what to do with it.
Wow, I just noticed something crazy in your code. What are you calling showBoard in the middle of the search?
EDIT: If you expect that code to only be executed at the root, but it turns out it's getting executed in internal nodes as well, the output will be very confusing. Perhaps that's what you are experiencing...
I recommend separating the search of the root of the tree into its own function. There is a little bit of code duplication, but there are enough differences to justify it (returning a move, reporting progress, iterative deepening, time control, looking up the opening book, clearing the hash tables or at least making them obsolete...).
I think I see the problem in the code. The chosenBoard looks like a global variable, and it will be overwritten at a lower level from a future cutoff from the current 'best board'. Avoid global variables in recursive code, rather return the best board and let the parent decide what to do with it.
That is correct mr Druzil, and i think you are right !
I must return chosenBoard recursively (as a reference parameter) to the previously function call and decide what to do with it.
So far the chosenBoard is overwritten and the last value is always the value of "last best board" found at lower levels.
Wow, I just noticed something crazy in your code. What are you calling showBoard in the middle of the search?
EDIT: If you expect that code to only be executed at the root, but it turns out it's getting executed in internal nodes as well, the output will be very confusing. Perhaps that's what you are experiencing...
I recommend separating the search of the root of the tree into its own function. There is a little bit of code duplication, but there are enough differences to justify it (returning a move, reporting progress, iterative deepening, time control, looking up the opening book, clearing the hash tables or at least making them obsolete...).
showBoard() function only displays the current board to the debug window, it's just a debbugging function - i dont care about performance now .
I was trying to see what happens when getBestMove() calls itself recursively - so i've made this function (wich doesn't modify the content of the board)
I will keep this in mind - separating the search of the root (level 0) into its own function.
But also must say that i'm thinking using negamax algorithm if i will not figure where i go wrong....
But also must say that i'm thinking using negamax algorithm if i will not figure where i go wrong....
certainly negamax is a simpler and cleaner algorithm. One thing to keep in mind is if you intend to reuse your algorithm for >2 player games or games with multisteps per play you won't be able to use negamax as there is an assumption built into the call that the next level down is your single opponent. if this is not the case then I would suggest moving to negamax will save you potential headaches later on
.
