[deleted]

[quote name='whitenose' timestamp='1349755934' post='4988213']
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
[/quote]
It's not obvious how to use minimax in games with more than 2 players anyway. I would look into Monte Carlo Tree Search if you want to write engines for a larger class of games.

It's not obvious how to use minimax in games with more than 2 players anyway.

It stops being minimax, but it is clear what the generalization is, right? You drop the zero-sum requirement, you give each player his own reward function (rather than having one be the negative of the other), and everybody does a MAX on his own function.

(Granted, this gets impractical for large numbers of players.)

How alpha-beta search generalizes is less clear to me. You can do a generic branch-and-bound, with upper and lower bounds for each player's reward (so you'd keep cutting chunks off a bounding cube), but there are other options; I don't know if the game structure lets you keep just one number instead of two per player, or if non--axis-aligned planes (I haven't thought this through) are useful. This has got to be standard, but I don't know.

I have thought multiple-player minimax a bit myself, and also how to extend minimax and alpha-beta to games with randomness (e.g., games with dice). You can think of games with randomness as having an extra player that doesn't have any preference for one result or another, so will pick a "move" at random.

I have never actually tried to implement any of it, but I think alpha-beta is going to be of very limited value in those more complicated scenarios.

MCTS on the other hand extends very naturally to multiplayer games and to games with randomness. You still need to evaluate the result of the game as one number (the utility) per player. The rest of the MCTS scheme works basically without modification from the 2-player deterministic version of the technique.

I have implementations of multiplayer minimax and there certainly are papers out there going into detail of the issues. The easiest algoriths are paranoid search which basically treats all opponents essentially as one (they are all out to get you) which is the most pessimistic view as apposed to maxn which is the most optmistic method (everyone just tried to max their own score).

Hello,

I'm so sorry for the late reply. I had a car accident, all it's ok...
Thanks for all your answers !

As i said first, i'm trying to do a simple 9Men's Morris game (for Android).
This game has 3 phases: PlacingTokens, PlayGame, EndGame as you well know.

I have switched to negaMax() but the problem persists, and i think I know where/when it happens (i will explain) but dont know how to fix it.
The problem is returning final "bestMove" to the main calling function .

Had some time today to implemeent negaMax() and i hope didn't made mistakes - and it seems that at "depth=1" when PlacingTokens phase is active -> all it's OK. (meaning that the "computer" plays good enough).
The calling code for this looks like this now for negaMax():





// as you can see "depth=1" (MAX = "computer" turn !)
case renderer.GAMESTATUS_PLACETOKEN:

//PARAMETERS: simulationBoard, depth, alpha, beta, sign (or color wich wil alternate between +1 or -1)
negaMax(simulationBoard, 1, Integer.MIN_VALUE+1, Integer.MAX_VALUE-1, 1);


My "negaMax()" function looks like this:



private int negaMax(board board, int depth, int alpha, int beta, int sign)
{
// if depth reached or we DO have a winner on "this" board
if(depth<=0 || board.checkWinner(sign))
{
// evaluateBoard() evaluates board from "sign"'s point of view and returns a positive or negative score.
return sign*board.evaluateBoard(sign);
}

int max = Integer.MIN_VALUE+1; // -VERY SMALL value.

// generate all available possible moves
ArrayList<board> boardsArray = board.generateNextPossibleBoards(sign);

// loop thru all generated boards
for(board nextBoard: boardsArray)
{
// recurse and store result to "x" .
int x = -negaMax(nextBoard, depth-1, -beta, -alpha, -sign); // sign alterantes between +1 & -1 (computer & human)

// got a "better/best" move ?
if (x>max)
{
// save the "best" move so far.
max = x;
chosenBoard = nextBoard;
chosenBoard.showBoard("FOUND BEST MOVE");
}

// alpha-beta pruning
if (x>alpha) alpha = x;
if (alpha>=beta) return alpha;
}

// clear boards when done.
boardsArray.clear();

// return best move so far.
return max;
}



allright, and now the checkWinner(sign) method (wich returns true or false if a team is Winning)



public boolean checkWinner(int sign)
{
board board = this;

// ---------------------------------------------------------------------------------
// 0. get current team
// ---------------------------------------------------------------------------------
int team = renderer.TEAM_NOTEAM;
int opponent = renderer.TEAM_NOTEAM;

if(sign==1)
{
// if "computer" turn
team = renderer.TEAM_OPPONENT;
opponent = renderer.TEAM_PLAYER;
}
else
{
// if "human" turn
team = renderer.TEAM_PLAYER;
opponent = renderer.TEAM_OPPONENT;
}


// ---------------------------------------------------------------------------------
// 1. check if only 2 tokens (from opponent team!) are left on current board.
// ---------------------------------------------------------------------------------
int counter = 0;

for(short i=0;i<24;i++)
{
if(board.gNode.gOccupiedByTeam!=renderer.TEAM_NOTEAM && board.gNode.gOccupiedByTeam==opponent) counter++; // count opponent tokens
}

switch(team)
{
case renderer.TEAM_OPPONENT:
if(counter<=2 && renderer.gPlayer.gTokensToPlaceOnTable==0)
{
return true; // opponent has won.
}
break;
case renderer.TEAM_PLAYER:
if(counter<=2 && renderer.gOpponent.gTokensToPlaceOnTable==0)
{
return true; // player has won.
}
break;
}


// ---------------------------------------------------------------------------------
// 2. all opponent tokens are blocked! (no more possible moves, all tokens are blocked)
// ---------------------------------------------------------------------------------
for(short i=0;i<24;i++)
{
// go thru all tokens in this board, if opponent is not blocked -> return false.
if(board.gNode.gOccupiedByTeam==opponent)
{
// check if any empty neighbours for this token
for(short n=0;n<4;n++)
{
// get neighborur id
int id = board.gNode.gNeighbourId[n];

// check if neighbour is empty space.
if(id!=-1 && board.gNode[id].gOccupiedByTeam==renderer.TEAM_NOTEAM)
{
// still having empty spaces to move. (NOT BLOCKED!)
return false;
}
}
}
}

// opponent is BLOCKED! so this team is winning -> return true!
return true;
}




and this is the evaluateBoard(sign) function wich evaluates current board from --> "sign" ("computer" or "human") point of view :



// evaluate current board.
public int evaluateBoard(int sign)
{
int score = 0;
int formers = checkFormers(sign); // if 2 tokens on same row/column has been found, then a former has been found.
int blockers = checkBlockers(sign); // if 1 token blocks a token form other team, then we have a blocker.
int mills = checkMills(sign); // if a mill has been formed (3 tokens in a row/column), then we have a mill.
int tkcount = checkTokenCount(sign);// count token (team - opponent) difference on this board.

score = score + formers*250; // multiplier is 10 here for the "formers"
score = score + blockers*500; // multiplier is 500 here for the "blockers"
score = score + mills*1000; // etc.
score = score + tkcount*10;

if(sign==1) // is it "computer" turn?
{
return -score; // return score for "computer"
}
else
{
return +score; // return score for "human"
}

}




OK, now generating boards in 1st phase (PlacingTokens) is done like so:



public ArrayList<board> generateNextPossibleBoards(int sign)
{
// copy current board
board currentBoard = new board(this);

// instantiate a empty array.
ArrayList<board> boardsArray = new ArrayList<board>();

// current team is unknown.
int team = -1;
int opponent = -1;
int game_status = -1;

// update current team (can be "computer" or "human" player).
if(sign==1)
{
team = renderer.TEAM_OPPONENT;
opponent = renderer.TEAM_PLAYER;
game_status = renderer.gOpponent.gGameStatus;
}
else
{
team = renderer.TEAM_PLAYER;
opponent = renderer.TEAM_OPPONENT;
game_status = renderer.gPlayer.gGameStatus;
}

// according to current player's (computer/human) game-status:
switch(game_status)
{
case renderer.GAMESTATUS_PLACETOKEN:
// simulate a single place token (on this board) and save this new board to boardsArray.
for(short i=0;i<24;i++)
{
// go thru all empty spaces on this board , and if not occupied by any token
if(currentBoard.gNode.gOccupiedByTeam==renderer.TEAM_NOTEAM)
{
// place (a opponent) token to the empty neighbour found
currentBoard.makePlaceToken( i , opponent ); // place a opponent token !!!

boardsArray.add(new board(currentBoard));

// undo previous move
currentBoard.undoPlaceToken( i , renderer.TEAM_NOTEAM);
}
}

break;
...
... return boardsArray; // return all generated boards.


OK , all it's good so far, the "computer" finds best moves and plays good against "human" .
--------------------------------------------------------------------------------------------------------------------------------------------------


The problem is when swithcing to phase2 -> i.e the "PlayGame" phase !
The code doesn't change EXCEPT generating "moves" when in "PlayGame" phase.
Now, generating "moves" is done like so:


public ArrayList<board> generateNextPossibleBoards(int sign)
{
// copy current board
board currentBoard = new board(this);

// instantiate a empty array.
ArrayList<board> boardsArray = new ArrayList<board>();

// current team is unknown.
int team = -1;
int opponent = -1;
int game_status = -1;

// update current team (can be "computer" or "human" player).
if(sign==1)
{
team = renderer.TEAM_OPPONENT;
opponent = renderer.TEAM_PLAYER;
game_status = renderer.gOpponent.gGameStatus;
}
else
{
team = renderer.TEAM_PLAYER;
opponent = renderer.TEAM_OPPONENT;
game_status = renderer.gPlayer.gGameStatus;
}

// according to current player's (computer/human) game-status:
switch(game_status)
{
....
....
case renderer.GAMESTATUS_PLAYNORMAL:

// 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 id
int id = currentBoard.gNode.gNeighbourId[n];

// check if neighbour is empty spot.
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 PLAYNORMAL.

....
} // end function generateNextPossibleBoards()



I have done a picture for you to see what happens when depth>1 and why the chosenBoard is not correctly chosen.

http://imageshack.us...0/mistaker.jpg/

step1) As you can see, token from node=3 (depth=3) generates a new "move" to node=4 (depth=2).
step2) After that negaMax() recurses itself again and the token from node=4 generates again a new move to node=7(depth=1).
step3) Similar, from node=7 a token is generated again and set to node=8 (when negaMax() recurses again).

Now token from node=8 is selected as the "chosen" best move --> and return it to main function, right ? (because we have Win or good score)
But...when moving from starting node=3 to node=8 there's a problem (because node=8 token is "far" away from token=3)
This is what i must solve, how do i return best move when depth > 1 ?



Im sorry for the long post.
I hope you accept my appologies !

LE:
@alvaro : OK, ill try that and get back to you. THANKS!

Please re-read this thing I wrote:

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...).

NegaMax should return a score and a score only. Then write another function that looks at each move available at the current position on the board and calls NegaMax for each one of them. This function is really very similar to NegaMax but, among other differences, it returns a move.

I have implementations of multiplayer minimax and there certainly are papers out there going into detail of the issues. The easiest algoriths are paranoid search which basically treats all opponents essentially as one (they are all out to get you) which is the most pessimistic view as apposed to maxn which is the most optmistic method (everyone just tried to max their own score).

This is interesting. "Paranoid search" hadn't occurred to me.

The "paranoid" concept is cool for a couple reasons.

The first is that it turns an N-player game into N separate two-player games. And if your game is zero-sum across all the players, then each of these two-player games will also be zero-sum, and so easy to solve (in mixed strategies, when turns are simultaneous).

The second is that, with this solution concept, we can understand "how we got there." With Nash equilibrium, it's unclear how you actually arrive at an equilibrium, or which equilibrium you arrive it. You've got things like Condorcet dynamics and "fictitious play," but these are kind of unsatisfying; there's no great reason to expect players to use these mental processes.

One question to ask about "paranoid" solutions is how "consistent" they are. Are the solutions you get even Nash equilibria? I expect not. Whereas I think(?) that maxn solutions are Nash equilibria. (But if not -- do we care? Why do we want Nash equilibria in the first place?)

It seems to work now , final functions here:

negamax (returing a best score):
[source lang="java"]public int negamax(board board, int depth, int alpha, int beta, int sign)
{
if (depth == 0 || board.checkWinner(sign))
{
return board.evaluateBoard(sign);
}

int max = Integer.MIN_VALUE+1;

ArrayList<board> boardsArray = board.generateNextPossibleBoards(sign);


for(board nextBoard: boardsArray)
{
int score = -negamax(nextBoard, depth-1, -beta, -alpha, -sign);

if (score>max) max = score;
if (score > alpha) alpha = score;
if (score >= beta) return score;
}

return max;
}
[/source]

and function returing a move (helped by negamax() function) :

[source lang="java"] public board returnBestMove(board board, int depth, int sign)
{
board bestMove = null;
int best = Integer.MIN_VALUE+1;

ArrayList<board> boardsArray = board.generateNextPossibleBoards(sign);

for(board nextBoard: boardsArray)
{
if (bestMove == null) bestMove = nextBoard;

int score = -negamax(nextBoard, depth, Integer.MIN_VALUE+1, Integer.MAX_VALUE-1, sign);

if (score > best)
{
bestMove = nextBoard;
best = score;
}
}

return bestMove;
}
[/source]


bestMove = it's a board also, when function returnBestMove() finishes I just compare bestMove board with initial Board and
identify wich token has been moved (from wich pos, to wich destination pos).


If i've made some mistakes - your suggestions will be highly appreciated !
Thanks .

int score = -negamax(nextBoard, depth, Integer.MIN_VALUE+1, Integer.MAX_VALUE-1, sign);[/quote]

Following the general alpha-beta algorithm, that should actually be
int score = -negamax(nextBoard, depth, Integer.MIN_VALUE+1, -best, sign);

Other than that, the only thing I would have done differently is not having a variable `max' at all: You can simply remove all mentions of it and return alpha at the end instead.

EDIT: Wait, why are you passing a sign around?