local function prequire(name) local success, result = pcall(require, name); return success and result end local bench = script and require(script.Parent.bench_support) or prequire("bench_support") or require("../bench_support") function test() -- https://github.com/stefandd/Tic4 local negaMax = {maxdepth = 4, minsearchpos = 0, numsearchpos = 0} negaMax.__index = negaMax function negaMax:evaluate(board, depth) --[[ What can be confusing is how the heuristic value of the current node is calculated. In this implementation, this value is always calculated from the point of view of player A, whose color value is one. In other words, higher heuristic values always represent situations more favorable for player A. This is the same behavior as the normal minimax algorithm. The heuristic value is not necessarily the same as a node's return value due to value negation by negamax and the color parameter. The negamax node's return value is a heuristic score from the point of view of the node's current player. Negamax scores match minimax scores for nodes where player A is about to play, and where player A is the maximizing player in the minimax equivalent. Negamax always searches for the maximum value for all its nodes. Hence for player B nodes, the minimax score is a negation of its negamax score. Player B is the minimizing player in the minimax equivalent. Variations in negamax implementations may omit the color parameter. In this case, the heuristic evaluation function must return values from the point of view of the node's current player. --]] print ("This function needs to be implemented!") end function negaMax:move_candidates(board, side_to_move) print ("This function needs to be implemented!") end function negaMax:make_move(board, side_to_move, move) print ("This function needs to be implemented!") end function negaMax:negaMax(board, side_to_move, depth, alpha, beta) -- side_to_move: e.g. 1 is blue, -1 is read -- -- init vars for root call -- if not depth then -- root call depth = 0 alpha = -math.huge beta = math.huge self.numsearchpos = 0 -- reset call counter end -- -- test if the node is terminal (i.e. full board or win) -- local best_move = -1 local score, is_term_node = self:evaluate(board, depth) -- we abort the recursion if this is a terminal node, or if one of the search abort conditions are met -- if is_term_node or depth == self.maxdepth then return side_to_move*score, best_move, is_term_node end -- -- if not terminal node, eval child nodes -- local moves = self:move_candidates(board, side_to_move) score = -math.huge for _, analyzed_move in pairs(moves) do -- iterate over all boards self.numsearchpos = self.numsearchpos + 1 local b = self:make_move(board, side_to_move, analyzed_move) local move_score, _, _ = -self:negaMax(b, -side_to_move, depth+1, -beta, -alpha) if move_score > score then score = move_score best_move = analyzed_move end -- disable alpha-beta pruning -- alpha = math.max(alpha, score) if alpha >= beta then break end -- end if depth == 0 then -- -- exit for root call (depth == 0) -- -- debug stuff --print(string.format("---- Negamax: node info, depth: %d, side: %d, score: %d, best move: %d", depth, side_to_move, score, best_move)) --print_board(board) --print(string.format("----")) print("Analyzed positions: " .. self.numsearchpos) end return score, best_move, game_over end local empty_board = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0} -- 16 empty positions ----------- helper methods function copy_board(board) local copy = {} for i = 1, #board do copy[i] = board[i] end return copy end function print_board(board) gboard = {} for i = 1, #board do if board[i] == 0 then gboard[i] = '.' elseif board[i] == 1 then gboard[i] = 'x' else gboard[i] = 'o' end end print(string.format("\n%s %s %s %s\n%s %s %s %s\n%s %s %s %s\n%s %s %s %s\n", unpack(gboard))) end function is_board_full(board) for i = 1, #board do if board[i] == 0 then return false end end return true end ----------- implement negaMax methods negaMax.index_quadruplets = { {1,2,3,4}, {5,6,7,8}, {9,10,11,12}, -- rows {13,14,15,16}, {1,5,9,13}, {2,6,10,14}, -- cols {3,7,11,15}, {4,8,12,16}, {1,6,11,16}, {4,7,10,13}, -- diags {1,2,5,6}, {2,3,6,7}, {3,4,7,8}, -- squares {5,6,9,10}, {6,7,10,11}, {7,8,11,12}, {9,10,13,14}, {10,11,14,15}, {11,12,15,16} } function negaMax:evaluate(board, depth) -- return format is score, is_terminal_position --[[ What can be confusing is how the heuristic value of the current node is calculated. In this implementation, this value is always calculated from the point of view of player A, whose color value is one. In other words, higher heuristic values always represent situations more favorable for player A. This is the same behavior as the normal minimax algorithm. The heuristic value is not necessarily the same as a node's return value due to value negation by negamax and the color parameter. The negamax node's return value is a heuristic score from the point of view of the node's current player. Negamax scores match minimax scores for nodes where player A is about to play, and where player A is the maximizing player in the minimax equivalent. Negamax always searches for the maximum value for all its nodes. Hence for player B nodes, the minimax score is a negation of its negamax score. Player B is the minimizing player in the minimax equivalent. Variations in negamax implementations may omit the color parameter. In this case, the heuristic evaluation function must return values from the point of view of the node's current player. --]] local player_plus_score, player_minus_score = 0, 0 local game_won = false for _, curr_qdr in pairs(negaMax.index_quadruplets) do -- iterate over all index quadruplets -- count the empty positions and positions occupied by the side whos move it is local player_plus_fields, player_minus_fields, empties = 0, 0, 0 for _, index in next, curr_qdr do -- iterate over all indices if board[index] == 0 then empties = empties + 1 elseif board[index] == 1 then player_plus_fields = player_plus_fields + 1 elseif board[index] == -1 then player_minus_fields = player_minus_fields + 1 end end -- evaluate the quadruplets score by looking at empty vs occupied positions if empties == 3 then if player_plus_fields == 1 then player_plus_score = player_plus_score + 3 elseif player_minus_fields == 1 then player_minus_score = player_minus_score + 3 end elseif empties == 2 then if player_plus_fields == 2 then player_plus_score = player_plus_score + 13 elseif player_minus_fields == 2 then player_minus_score = player_minus_score + 13 end elseif empties == 1 then if player_plus_fields == 3 then player_plus_score = player_plus_score + 31 elseif player_minus_fields == 3 then player_minus_score = player_minus_score + 31 end elseif empties == 0 then -- check for winning situations if player_plus_fields == 4 then player_plus_score = 999-depth player_minus_score = 0 game_won = true break elseif player_minus_fields == 4 then -- this should not happen if there is a proper terminal node detection! player_plus_score = 0 player_minus_score = 999-depth game_won = true break end end end -- return format is score, is_terminal_position if not game_won and is_board_full(board) then return 0, true -- DRAW else return (player_plus_score - player_minus_score), game_won -- >0 is good for player 1 [+], <0 means good for the other player (player 2 [-])) end end function negaMax:move_candidates(board, side_to_move) local moves = {} for i = 1, #board do if board[i] == 0 then -- empty? moves[#moves + 1] = i -- save move that was made end end return moves end function negaMax:make_move(board, side_to_move, move) local copy = copy_board(board) copy[move] = side_to_move return copy end local human_player = 1 local AI_player = -human_player local game_board = copy_board(empty_board) local curr_move = -1 local curr_player = human_player -- human player goes first local score = 0 local stop_loop = false local game_over = false negaMax.maxdepth = 5 local t0 = os.clock() score, curr_move = negaMax:negaMax(game_board, curr_player) local t1 = os.clock() return t1-t0 end bench.runCode(test, "tictactoe")