By: Casey Savage, Hayley Stueber, and James Olson 2048 Game Solver By: Casey Savage, Hayley Stueber, and James Olson

About 2048 Goal of the Game: create the 2048 tile How to Play the Game: slide tiles left, right, up, or down to combine like numbers: For example, two adjacent 2’s can be combined to create a 4, two adjacent 4’s can make an 8, and so on. Tiles slide in the specified direction until they are stopped by a tile or the edge A new tile with the value of 2 or 4 will appear in an empty spot on the board. The player loses if there are no empty spaces left on the board.

Previous Work Matt Overlan: Vasilis Vryniotis: created a code using a minimax algorithm High probability of winning, but very slow, heavily due to its animation Vasilis Vryniotis: created a problem-solver for 2048 in Java using an alpha-beta pruning algorithm Very slow and ineffective problem-solver that would not display its process. Gayas Chowdhury and Vignesh Dhamodaran Created a game solver code using Expectimax algorithm

Problem Statement Create a game solver that attempts to solve the game 2048 by achieving a 2048 tile while maximizing the efficiency and success rate To do this we examined: Minimax Algorithm Alpha Beta Pruning Algorithm Expectimax Algorithm

2048 Game tree Diagram Top Node Depth 1 Depth 2 Depth 3 …Depth (n)

Minimax Algorithm Has the “player” select the most effective move Anticipates the “opponent,” or the computer, placing the next piece in the position most inconvenient for the player, but, in this case, we simply used the game’s method for placing the next tile.

Minimax Psuedocode function minimax(node, depth, maximizingPlayer) if depth = 0 or node is a terminal node: return the heuristic value of node if maximizingPlayer: bestValue := -∞ For each child of node val := minimax(child, depth – 1, FALSE)) bestValue := max(bestValue, val) return bestValue else bestValue := ∞ for each child of node val := minimax(child, depth – 1, TRUE)) bestValue := min(bestValue, val) (* Initial call for maximizing player *): minimax(origin, depth, TRUE)

Results and Analysis of Minimax Big O Algorithm Complexity of: O(n^d) n = number of moves in a game d = depth of the search 40% of trials fail with highest tile as 512. 50% success rate.

Alpha-Beta Pruning Algorithm An expansion of the Minimax Algorithm Main Goal: decrease the number of nodes to evaluate by comparing alpha and beta values and “pruning” sub trees

Alpha-Beta Pruning Pseudocode Function alphabeta(node, depth, alpha, beta maximizingPlayer): if(max(state, α, β, depth)): If (depth ==0): return value(state) For s in Successors(state): α = MAX(α, MIN(state, α, β, depth) If α >=  β: return α else: β= MIN(β, MAX(state, α, β, depth-1) If β >= α : return β α: The best value for MAX seen so far β: The best value for MIN seen so far state: game position

Alpha-Beta Algorithm Results Using a depth of 7: Success rate: 60-70% Fails at 1024 tile about 90% of the time Average Time to Solve a Game: 72 seconds Big O Algorithm Complexity of: O(n^(d/2)) n = number of moves in a game d = depth of the search

Expectimax Algorithm Expectimax is also a variation of minimax game tree algorithm Expectimax has chance nodes in addition to min and max, which takes the expected value of random event that is about to occur The random event being the next randomly placed 2 or 4 tile on the 2048 game board The next move sliding board Right, Left, Up, or Down is chosen by the highest expected value of all the possibilities. Expected value is calculated by weighted average of values of the children

Expectimax Algorithm The expectimax algorithm evaluates each node by calculating all of possible tile placements, weighted by the probability of the occurrence of each tile The percent of a 2 tile being placed is 90% and 4 tile is 10% The algorithm then chooses the case with the best probability of occurrence Depending on the set depth(d) it will calculate the probability to d amount of future moves

Expectimax Algorithm Pseudocode function expectimax(node, depth, player) else if random event at node if node is a terminal node or depth = 0 // Return weighted average of all child nodes' values let α := 0 return the heuristic value of node if the adversary is to play at node α := α + (Probability[child] * expectimax(child, depth-1)) // Return value of minimum-valued child node return α let α := +∞ foreach child of node α := min(α, expectimax(child, depth-1)) else if we are to play at node // Return value of maximum-valued child node let α := -∞ α := max(α, expectimax(child, depth-1))

Results and Analysis of Expectimax Expectimax Algorithm with a depth of 7 had a success rate of 80% wins The lowest tile to fail on was 1024 Reached a 4096 tile 30% of the time Big O Algorithm Complexity of: O(n^d) d = depth of the expectimax search n = number of moves in a game

Results And Conclusion Expectimax proved to have the highest success rate, but had an incredibly slow runtime. Alpha-Beta pruning was less successful than expectimax, but had an incredibly quick runtime. The minimax algorithm was least effective in success rate, but quicker than expectimax.

Future Work Improve the Speed: Improving the speed of the algorithm will allow you to use larger depth and thus get better accuracy. Tune Heuristics: One can experiment with the way that the scores are calculated, the weights and the board characteristics that are taken into account.

Questions What limits a minimax algorithm? The depth of the search What are the differences between the Minimax, Alpha Beta Pruning, and Expectimax algorithms? The Alpha Beta Pruning algorithm expands on the Minimax algorithm by eliminating branches to evaluate to hopefully decrease runtime. The Expectimax algorithm add chance nodes to the Minimax algorithm to increase the chances of getting a winning score by calculating probabilities. What is the time complexity of the Expectimax algorithm? O(n^d) As the tree depth increases, how does it affect your algorithm? It increases the likelihood of a winning outcome, but also increases the time it takes to complete.