Báo cáo Đồ Án Trí tuệ Nhân tạo tiếng Anh Game Caro

Developing Gomoku chess based on Minimax
algorithm
1st Pham Dang Khoa
Department of Computer Science
Vietnam National University – Ho
Chi Minh City
University of information Technology


2nd Nguyen Hoang Quan
Department of Computer Science
Vietnam National University – Ho
Chi Minh City
University of information Technology


Abstract— We proposed to develop a new
version of Gomoku chess game based on the idea
of Minimax algorithm as well as Alpha-Beta
Pruning. Minimax is one of backtracking
algorithms that is widely applied in making
decision to search the optimal move for player, in
case that its enemy makes the optimal step too.
Alpha-beta pruning is the optimization algorithm
reduces computation time by seeking to decrease
the number of nodes by cutting off branches which
are not necessary to search because there has
already been a better move in next steps. In this
project, we will implement it by C# with Visual
Studio tool, .NET framework, Windows Forms
library. In this version, we are planning to build a

truly-sized game board and integrate some
functions depending on player's demand: give the
right to choose difficulty, undo your moves, etc.
Keywords—Minimax,
Alpha-Beta
Pruning,
optimization, backtracking algorithm (key words)
I. INTRODUCTION
Long time ago, searching was always a fundamental
manipulation for several tasks. The main purpose of
searching is to find to optimal way to collect the
necessary information for an important decision.
Generally, searching can be implied that it is the
method to find one or more objects which are
satisfactory at any requirements in a large set of
objects.
We can see many problems of searching in real life.
For example, some games such as Gomoku chess –
also called Caro, among many probable moves, we
must find the best one that can lead to winning position.
Minimax is the specialized search algorithm to return
a series of optimal moves for a player in a zero-sum
game [1]. A zero-sum game is a game where the total
value of the outcome of winner is fixed. Whichever side
wins (+1) finally makes the other components lose (-1),
which corresponds to a pure competitive situation,
eventually leading to a total (+ 1- 1) = 0. Our game,
Gomoku chess, is also a zero-sum game because
there is never a situation that both of two players have
a draw result. Consequently, Minimax is a technique

whose purpose is to minimize the possible loss in a
worst case, and to maximize the minimum gain when
dealing with gains. The Minimax algorithm helps find
the best move, by going backwards from the end of the
game. At each step, it will estimate that Player A is

XXX-X-XXXX-XXXX-X/XX/$XX.00 ©20XX IEEE

3rd Le Viet Trung
Department of Computer Science
Vietnam National University – Ho
Chi Minh City
University of information Technology


trying to maximize A's winning chances when it is his
turn, and in the next move, Player B tries to minimize
the chances of Player A winning. (meaning maximizing
B's chances of winning).
II.

MINIMAX ALGORITHM

A. Ideas
Two players in that game are MIN and MAX. MAX is
supposed to be a player who tries to obtain the winning
chances. In contrary, MIN is the opponent who tries to
minimize MAX’s score at each move. We suppose that
MAX also uses the same information as MIN.
First, we represent it by a game tree. Each node in

the tree represents a specific status. The root node
denotes the beginning state of the game. While the leaf
nodes represent an end state (win or lose) of the game
in each case. If the state x is represented by the node n
then the children of n represent all the resulting states
of the possible moves from state x. Because the two
players alternate their moves with each other, the levels
(classes) on the game tree also alternate as MAX and
MIN. Therefore, this game tree is also called the MINMAX tree. In the game tree, the nodes which are
respective to the state where the MAX player chooses
the move will belong to the MAX class, the nodes
corresponding to the state from which the MIN player
selects the move will belong to the MIN class. The
minimax strategy is represented by the rule as follows:
If this node is leaf node, then we assign it a value to
denote the winning or losing state of the players. After
that, we take their values to determine nodes’ values in
the upper levels in the game tree followed by the rule:


The nodes belonging to MAX class will be
assigned the max value of their children.



The nodes belonging to MIN class will be
assigned the min value of their children.

These values assigned to each state based on the
above rule will indicate the value of the best state which

each player expects to achieve. And players will use
them to choose their own proper moves. When MAX
player is in turn, it will choose the move corresponding
to the state with the highest value in the sub-states, and
in contrast, when MIN player is in turn, it will choose the
move corresponding to the state of the price. smallest
value in the sub-states.
Figure 1: Illustration of Minimax applied in Tic
Tac Toe game – a short version of Gomoku chess


B. Minimax Illustration
From the ideas mentioned above, we can
implement the Minimax algorithm as follows: First of
all, the Minimax function takes a position named
pos and returns the value of that position. If the pos
position corresponds to the leaf node in the game
tree, the value which was assigned to the leaf node
is returned. In contrast, we will give pos a temporary
value of -∞ or ∞ depending on the situation that
whether the pos is the MAX or MIN node and
consider the sub-positions of pos. After a child of
pos has value V, we reset value = max (value, V) if
n is node MAX and value = min (value, V) if n is
node MIN. When all the children of n are
considered, the temporary value of pos becomes its
value. We introduce you a pseudo-code for this
algorithm:

begin

{Initialize temporary value for best variable}
if pos is MAX node then
best:= -INFINITY
else best := INFINITY;
{genPos function generates all possible
moves from the current position named pos}
genPos(pos);
{Check all children of pos, each time that we
determine one child node’s value, we must
reassign the temporary value for it.}
while (we can still take a move) do
begin
pos := (The new value computed by the
previous move);
value = Minimax(pos);
if pos is MAX node then
if (value > best) then best := value;
if pos is MIN node then
if (value < best) then best := value;
end;
Minimax := best;
end;
end;
In the program, the chess board was
represented by global variables. Therefore, instead of
passing parameter which is a new chess called pos
into Minimax parameter, we transform the global
variable by making a “trial” move. After computing
based on the chess board saved by global variables,
the algorithm will use some procedures to remove this

move.
C. Minimax evaluation
Minimax algorithm traverses the entire game tree by
using Depth-First Search. Therefore, this algorithmic
complexity algorithm is directly proportional to the size
of the search space bd, where b is the branching factor
of the tree or is the legal move at each point, d is the
maximum depth of the tree. The number of traversed
nodes is b(bd-1)/(b-1).
However, the evaluation
function is the most important method and only works
with leaf nodes, so it is unnecessary to traverse to
nodes which are not leaf nodes [8]. Hence the time
complexity is O (bd). The essence of this algorithm
seems to be Depth-first Search, so its memory space
requirements are linear only with d and b. So the spatial
complexity is O (bd). If the branching factor of tree is b
= 40, and the maximum depth is d = 4, then the number
of nodes need evaluating is 40 4 = 2560000, it is an
enormous figure. To solve this problem, we consider
using another more effective algorithm such as AlphaBeta Pruning.
III. ALPHA-BETA PRUNING

function Minimax(pos): integer;
value, best : integer;
begin
if pos is leaf node then return eval(pos)
else

In this part, we will present an algorithm decreasing

the number of nodes that are evaluated. It stops
evaluating one move when that move is proven to
be worse than a previously examined move.
Therefore, it is unnecessary to evaluate those
moves anymore. The aim of this algorithm is to


save time execution but does not influence much on
the search results, especially final decision.
A. Idea
The idea of an Alpha-beta search is simple:
Instead of searching the entire space until the
specific depth, Alpha-beta search proceeds in a
depth-first fashion. There are two values, called
alpha and beta, that are generated during a search:
The alpha value is an initial or temporary value
associated with MAX nodes and never decreases, it
can only go up. In contrast, beta value is associated
with MIN nodes and never increases, it can only go
down. Initially, both players start the game with their
own worst case. The searching process win end
when beta value of MIN player becomes less than
or equal to alpha value of its MAX parent nodes, the
MIN will not need to consider descendants of this
node since it is not important. The same rule is also
applied for MAX player.
B. Alpha-Beta Illustration
Here are some core steps that demonstrate
how the algorithm works:
 If the current level is root, it sets the values of







alpha and beta to - and +, respectively.
If it has reached search limit (leaf nodes), then
computes the static value of current state
corresponding current player and record result.
For MIN player: it applies Alpha-Beta
procedure with current alpha and beta values
for one child node, then store its result. Next, it
compares this stored value to beta, if that
result is smaller then it sets beta to this new
value. These works are repeated until all
descendants have been considered or alpha is
greater or equal to beta.
For MAX player: it applies Alpha-Beta
procedure with current alpha and beta values
for one child node, then store its result. Next, it
compares this stored value to alpha, if that
result is larger then it sets alpha to this new
value. These works are also repeated until all
descendants have been considered or alpha is
greater or equal to beta.

Figure 2: Alpha-Beta Algorithm
illustration
We also introduce pseudo-code for this algorithm

as it is convenient to compare with Minimax

function AlphaBeta(alpha, beta, depth): integer;

begin
if (depth = 0) or (pos is leaf node) then
AlphaBeta := Eval { Calculate position’s value }
else
begin
best := -INFINITY;
Gen; { Generate all possible moves from the
position called pos }
while (Still can get a move) and (best < beta) do
begin
if best > Alpha then Alpha := best;
Make the move;
value := -AlphaBeta(-beta, -Alpha, depth-1);
Cancel making the move;
if value > best then best := value;
end;
AlphaBeta := best;
end;
end;
C. Alpha-Beta evaluation
Generally, alpha-beta algorithm helps us save
a lot of time compared to Minimax while making
sure that search results have high accuracy.
However, this amount of savings is not stable since
it depends on the number of nodes cut. In the worst
case the algorithm could not cut a branch and must

consider the exact number of nodes by the Minimax
algorithm. We need to accelerate the removal by
accelerating the shrinking of the Alpha-beta search
interval. This interval is gradually narrowed when
there is a new value that is better than the old
value. When facing the best fit value, this interval is
narrowed the most. Therefore, we need to make the
leaf nodes arranged in order from high to low. The
better this order is, the more rapid the algorithm
executes.

D. Comparsion between Minimax and
Alpha-Beta

As you can see, the increase in the number of
nodes when increasing the depth of Minimax is always
the branching factor b, in this case is 40. In contrary,
The number of Alpha-beta increases is much less: only
1.7 times when increasing from d odd to even. 23.2


times when d is from even to odd, the average
increase is only about 6 times when d increases.
The formula for calculating the number of
nodes displays that the number of nodes to consider
when using Alpha-beta is much less than that of
Minimax but it is still an exponential function and still
leads to combinatorial explosion. Alpha-beta algorithm
does not completely avoid combinatorial explosion,
only lowers the explosion rate. Due to this problem,

both players cannot search all possibilities. Therefore,
the only method is to search only to a limited depth and
choose the move which leads to the best state for us.
In the light of the enemy's ability to fight back, we
cannot use normal search algorithms. A separate
search algorithm for the game tree must be used. They
are the Minimax algorithm and its improvement called
Alpha-beta algorithm. While both algorithms cannot
avoid combinatorial explosion, the Alpha-beta
algorithm just slows down it and; therefore; it is used
more often in chess games.
IV. DEMO APPLICATION
After presenting and concluding all the theories
researched, we will introduce some works that we have
made in our project.
In our User Interfaces, there are game board with
the size of 20x20, UIT logo and three main function
buttons: New Game, Undo and Exit. When you press
the button “New Game”, it will ask whether you or
Computer play first and the difficulty you want to
choose. The “Undo” button helps you reverse your
previous move, even you can reverse more than one
moves. Finally, the “Exit” button will quit the game if you
don’t want to play anymore.
Here are some pictures of (UI) in our application:

V. CONCLUSION AND FUTURE WORK
In summary, we have created a Caro game for
one player competing with the AI. The algorithms
that our group implements are Minmax and AlphaBeta Pruning, we have evaluated the efficiency of

each of them as well as given a general comparison
between both of them.
In spite of our efforts, it is certain that our
program does not avoid some limitations, hopefully
some potential problem will be further researched
and developed with improved algorithms. Our group
considers installing Expectimax algorithm in the
future and compare different evaluation functions to
assess the states.
REFERENCES
[1] Jessica Billings (2008), The Minimax Algorithm, CS
330.
[2] Alpha-Beta pruning - Wikipedia
[3] CPSC 352 -- Artificial Intelligence Notes:
Minimax and Alpha Beta Pruning.
[4] Đỗ Trung Tuấn (1997), Trí tuệ nhân tạo, NXB
Giáo dục.
[5] Heylighen (1993), Zero sum games – Principia
Cybernetica Web