GoogolHex

CS4701Final Presentation

Anand BheemarajaiahChet ManciniFelipe Osterling

Problem Definition

• Build an intelligent agent that can play the 2-player modified Chinese Checkers game.

• The board setup consists of individual tiles that are hexagonal and a set of pieces that must move from their start positions by moving individually or “jumping” one another to a set of end positions.

• The motivation for this project is to implement and evaluate various AI ideas into an intelligent agent that plays the game against other intelligent agents.

Summary - Tournament Performance

• Our agent has performed at about the average or slightly below.

Method - Board Representation

• Since the Greedy player provided implemented the same design concepts we specified in our initial presentation, we decided to only slightly modify the provided Board object.

• We added some helper methods, and we added an extra jump function that maintained a depth counter of the current depth of a player.

Method - Agent

• As specified in our initial presentation, we decided to continue with an AB-pruned Minimax adversarial search to allow us to find optimal moves within a reasonable visibility.

Limiting Minimax Search

• Clearly, a basic Minimax search would explode far too quickly with the size of the board and number of moves.

• We still identified an adversarial search as the most straightforward solution to find intelligent moves.

Limiting Minimax Search (cont)

• Limit the search depth to 6.

• Don't bother searching tree of the two backwards-oriented directions from each peg.

• Don't bother moving towards sides of board.

• After realizing a depth of 4 was far preferable, we decided to limit depth to 2, and continue search again of depth 2 on most optimistic paths. This gets a functional depth of 4 without the time complexity (and a small optimality tradeoff risk).

Method - Search Heuristic Design

• We use a composite heuristic by weighting and summing the following weighted sub-heuristics:

• Simple - Distances to the farthest free slot, using the Board.dist(...) implementation provided.

• Distance - The total Euclidean distance from the goal (i.e. the sum of the Euclidean distances of each player from the goal)

• Total Moves - Inverse of total number of moves taken (making a move subtracts)

• Marbles At Goal - Strongly weight actually getting marbles into goal slots.

Related Work

• Our board representation ideas came from Paula Ulfahake at Lund University

• (who also implemented her agent with a modified Minimax search)

System Architecture

• OOP Design

• GoogolHexPlayer extends standard player interface.

• Move Logic with Strategy Pattern.

• Provide standard "getMove" interface method for strategies.

• Provide standard "getValue" inteface method for heuristics.

Experimental Evaluation

• In our testing our agent consistently won against the greedy player by a considerable margin--always several moves ahead.

Shortcomings/Future Work

• We implemented a neural network, but were not able to use it effectively in our approach.

• We would like to further investigate different evaluations and classifications of training data in order to optimize our performance or experiment in more detail in learning algorithms.

Shortcomings/Future Work (cont)

• Our project would have been much easier to test and debug with a unit test framework we could use against the board and heuristic methods.

• This is a somewhat involved setup process and learning curve for JUnit and Eclipse, but it could have been quite beneficial.

Acknowledgements

• We would like to thank our TA, Jason Yosinski for his assessments and suggesions during the project.

Conclusion

• In this project we have developed an agent that fulfills our goals, attempted a variety of AI-related strategies, and ended up with a solid search for finding good moves in Chinese Checkers.