CS4701FinalPresentation (1)x

strangerwineAI and Robotics

Oct 19, 2013 (4 years and 6 months ago)




Final Presentation

Anand Bheemarajaiah

Chet Mancini

Felipe Osterling

Problem Definition

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

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.



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


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



As specified in our initial presentation, we
decided to continue with an AB
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
oriented directions from each

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


Search Heuristic Design

We use a composite heuristic by weighting and summing
the following weighted sub


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


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

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

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

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


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


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