Minimax algorithm: how to skip a turn? - minimax

Question

I am using minimax algorithms with tic-tac-toe, reversi, etc.
How to properly add to the algorithm the possibility for one player to skip a turn (when there are no valid moves)?
01 function minimax(node, depth, maximizingPlayer)
02 if depth = 0 or node is a terminal node
03 return the heuristic value of node
04 if maximizingPlayer
05 bestValue := −∞
06 for each child of node
07 v := minimax(child, depth − 1, FALSE)
08 bestValue := max(bestValue, v)
09 return bestValue
10 else (* minimizing player *)
11 bestValue := +∞
12 for each child of node
13 v := minimax(child, depth − 1, TRUE)
14 bestValue := min(bestValue, v)
15 return bestValue
Thanks.

Answer 1

I implemented Minimax for a game that involved passing. So, pass was an action a user could do. In my case there were a few "re-actions" you could do as a player in the "passed" state, but that's irrelevant here.
You can add the player->pass = true as the new state and add it to the tree, just be sure to also check before any actions are added to the tree if that player has already passed, and skip it.
You then need to handle how many times they will be allowed to pass. Since now, if all players pass, the game can go on indefinitely. This depends on the game. In my case, when a player passed they could no longer do anything (beyond what I mentioned at first), and then when all players passed, the round ended and all pass states were reset.
An example from my game:
std::list<GameState*> GameState::generateChildren(GameState& parent) {
std::list<GameState*> children;
PlayerBoard* currentBoard = parent.getCurrentPlayer();
if (!currentBoard->pass) {
GameState* childState = new GameState(parent);
PlayerBoard *childBoard = childState->getCurrentPlayer();
childBoard->pass = true;
childBoard->nextPlayer();
children.push_back(childState);
//And then all your regular actions...
}
return children;
}

Answer 2

You can write a function GenerateValidMoves(node, player) that returns the list of all valid moves for the player in a given position. Then the start of minimax routine can be rewritten as follows:
function minimax(node, depth, maximizingPlayer)
if depth == 0:
return heuristicValueOfNode
if generateValidMoves(node, currentPlayer) is empty:
if generateValidMoves(node, opponentPlayer) is empty:
return heuristicValueOfNode //here the game is finished since neither player can move
return minimax(node, depth, not maximizingPlayer) //call minimax for the opponent
if maximizingPlayer
bestValue := −∞
for each child of node
v := minimax(child, depth − 1, FALSE)
bestValue := max(bestValue, v)
return bestValue
else (* minimizing player *)
bestValue := +∞
for each child of node
v := minimax(child, depth − 1, TRUE)
bestValue := min(bestValue, v)
return bestValue