Minimax In The Darkness

A.I Final Project

Assaf

Yoel

Overview

In this project we will explore the Mini-max algorithm under a special condition :

Mini-max algorithm with one of the players is a partial viewer. In our case, the "MIN

player" randomly loses visibility of parts of the world , hence 'Minimax in the dark' .

In order to explore the algorithm uder these conditions, we created a simple two

player game and a GUI environment to demonstrate it.

The Minimax Algorithm – short overview

Minimax is used in zero-sum deterministic games to denote minimizing the

opponent's maximum payoff, assuming the opponent is a rational player and has full

visibility.

In order to explore the Minimax algorithm visibility factor influence, we decided to

take a “real world” problem – Cartman tries to chase down Kenny who tries to run

away.

Cartman, as our Min player will have a partial visibility, which means he will

randomly see only percentage of the grid in each turn.

Each player assumes the other plays optimally , therefore in the example above MAX

will choose A1 since A2 and A3 will lead MIN to choose moves A21 or A33 (that lead

to position value of 2) and A1 will yield a value of 3 . The tree's height equals to the

recursion depth in our algorithm.

Minimax attributes:

Optimal (if the other player plays optimally)

Complete – if the tree is finite.

Run time: O(bm) (b = legal moves, m = maximum depth of tree)

Minimax assumptions:

Full visibility (each player can see what his opponent did the last turn).

Each player assumes his opponent plays in an optimal way

Our game: Minimax In The Darkness

Game flow:

Two players (Cartman and Kenny) are randomly placed on a board . Kenny's mission

is to escape (reach the first row) without being caught by Cartman . Cartman's

mission is to catch Kenny before he reaches the first row.

In order to explore the visibility factor, Cartman's visibility is randomly limited to

some percentage of the board each turn (hence Minimax in the dark) .Kenny, on the

other hand enjoying full visibility and completely aware of Cartman position.

Kenny leaves 'footprints' wherever he steps that remain for up to 4 game turns, and

the footprints receive values between 1 to 4 (4 is the most recent footprint and 1 the

least). Using these footprints, Cartman could guess kenny's position whenever Kenny

is not visible to him.

The main difference in our version of Minimax is that one player (Cartman, which

has a partial visibility) will sometimes make non optimal moves. This will affect both players since the second player will assume the partial viewer is optimal.

Our project will examine Cartman's performance under various visibilities and

allowed calculation steps (recursion depth).

The Evaluation functions

We scored each state of board according to the players positions as follows:

Space gManeuverin

),(tan

3

1

Space gManeuverin

),(tan

7

1)(

FirstRowKennyceDisKennyCartmanceDisboardEVAL

The evaluation's function idea is very simple. Kenny, the max player, wants to

increase the distance between himself and Cartman (otherwise he loses) and this is

more urgent than reaching the goal (hence the weights 0.7 and 0.3). So Kenny will

prefer positive values. Cartman, who wants the exact opposite, will prefer negative

values.

The maneuvering space is the actual squares both players can step. So both equation

fractions values are between 0-1 and the whole EVAL function can get values

between -1 to 1.

We implemented 2 versions of the distance between Cartman and Kenny (thus we

have two evaluation functions, one for each distance). The first uses a relaxation –

the distance is simply the Manhattan distance and doesn't take into account any

blocks in the path.

The second is the exact (shortest) distance considering the blocks on the road,

implemented by searching for possible paths using BFS and returning the shortest

considering blocks. In big recursion depth numbers with real distance the run time

becomes very long therefore the Manhattan evaluation will be used in such cases.

The Algorithm

Kenny Moves: (max player)

Kenny chooses the move which minimizing the maximum payoff of Cartman using

the Minimax algorithm while considering Cartman as a rational opponent. The

ground is really dirty so without knowing he is leaving traces of his four last moves.

Cartman Moves: (min player)

In each turn, percentage of the board is invisible for cartman.

Two scenarios:

Kenny is located on the visible part of the board Cartman chooses the move which minimizing the maximum payoff of Kenny using

the Minimax algorithm.

Kenny is located on the invisible part of the board Cartman

will scan for the freshest trace of Kenny, if none of them is visible he will consider the

last place he saw Kenny as the freshest trace. Now, Cartman will calculate all the

places Kenny might progress from this trace and the possibility of that.

For each Kenny's possible position, Cartman will have calculate the move which

minimizing the maximum payoff of Kenny using the Minimax algorithm, and multiply

the move payoff by the possibility of Kenny being in that position.

In the end of the process, Cartman will choose the move with the highest

expectancy.

Exponential growing algorithm

Because the algorithm has an exponential growth which leads to heavy run-time, we

decided to let the algorithm work until some depth in the recursion (1-5). That's

mean the players will not always know the exact outcome of their move, and only

the outcome of the board which we got from highest recursion depth.

Cartman Move function (pseudo code):

Vector Cartman_moves = list of all possible moves of Cartman

If (Kenny visible)

Update Kenny's last seen position

For each cMove in Carman_moves

Calculate Minimax(cMove) ;

Choose minimal cMove ;

else

latest_trace= findKennyTraceFunc()

Vector KennyPoss_moves= list of all the possible positions

Kenny might be and their probabilities.

For each cMove in Carman_moves

totalcMoveVal=0;

For each kMove KennyPoss_moves

moveVal=Calculate Minimax(cMove,kMove);

totalcMoveVal+=moveVal*kMove_possibily;

Choose minimal cMove which have minimal totalcMoveVal

Minimax function (pseudo code):

minimax(BOARD,TURN,RECURSION_DEPTH){

if kenny reached first row

return 1

if Cartman reaches Kenny

return -1

if RECURSION_DEPTH==0

retrun the board score using the EVAL function

if TURN=KENNY

Vector Kenny_moves= list of all the possible moves

Kenny might take.

For each kMove in Kenny_moves

newBoard= make new Board with kMove

moveVal=minmax(newBoard,CARTMAN,RECURSION-1)

return minimal moveVal.

if TURN=Cartman

Vector Cartman_moves= list of all the possible moves

Cartman might take.

For each cMove in Cartman_moves

newBoard= make new Board with cMove

moveVal=minmax(newBoard,Kenny,RECURSION-1)

return maximal moveVal.

}

Shots From The Game

Screen visibility

selection tab

Recursion Depth

selection tab

Picture from the game: Cartman

(center) will try to prevent

Kenny (upper left) from

reaching the first row. The

squares with "Satan" are

'blocks' – squares that are

impossible to step on

Results

We wanted to examine our algorithm behavior under two parameters:

Cartman's visibility

Recursion's depth

In order to do so, we let Cartman and Kenny play against each other 100 games with

different visibilities and depths and repeat this process for both evaluation functions.

Note that Cartman mission is much easier, the only thing he needs to do is get to

Kenny. Kenny however needs to get to the top of the screen without being caught.

So we were not expected to both players to get equals as the visibility rises.

Partial visibility was critical

We could not test both players behavior under full visibility because they have reach

very fast to aquarium point, which both stayed in their positions. only when the

visibility factor took place the game could be tested.

Game Statistics

First evaluation function (relexation)

Visibility (%)

Recursion Depth

Cartman Wins Kenny Wins

0.125 1 33 67

0.25 1 42 58 0.5 1 62 38

0.75 1 70 30

0.125 2 35 65

0.25 2 45 55 0.5 2 60 40

0.75 2 73 27

0.125 3 38 62

0.25 3 54 46 0.5 3 70 30

0.75 3 65 35

0.125 4 43 57 0.25 4 45 55

0.5 4 43 57

0.75 4 46 54

Second evaluation function (exact calculation)

Visibility (%) Recursion Depth

Cartman Wins Kenny Wins

0.125 1 25 75

0.25 1 31 69

0.5 1 41 59

0.75 1 52 48

0.125 2 22 78

0.25 2 32 68 0.5 2 38 62

0.75 2 60 40

0.125 3 24 76

0.25 3 31 69

0.5 3 51 49

0.75 3 65 35

0.125 4 18 82 0.25 4 27 73

0.5 4 40 60

0.75 4 58 42

Graphs

Evaluation function 1 (relaxation)

cartman's performance as a function of visibility

0

10

20

30

40

50

60

70

80

0.125 0.225 0.325 0.425 0.525 0.625 0.725 0.825

visibility

cart

man

perf

orm

an

ce

depth 1

depth 2

depth 3

depth 4

Cartman's performance as a function of recursion depth

0

10

20

30

40

50

60

70

80

1 2 3 4

recursion depth

Cart

man

's p

erf

orm

an

ce

visibility 12.5%

visibility 25%

visibility 50%

visibility 75%

Evaluation function 2 (accurate distance)

cartman's performance as a function of visibility

0

10

20

30

40

50

60

70

0.125 0.225 0.325 0.425 0.525 0.625 0.725 0.825

visibility

cart

man

perf

orm

an

ce

depth 1

depth 2

depth 3

depth 4

Cartman's performance as a function of recursion depth

0

10

20

30

40

50

60

70

1 2 3 4

recursion depth

Cart

man

's p

erf

orm

an

ce

visibility 12.5%

visibility 25%

visibility 50%

visibility 75%

Discussion

There is a slight differences between the results we have got using the relaxation

evolution function over the accurate evaluation function. The results on both

function indicates an improvement of Cartman's performance as results of an

increase of the visibility and of the recursion depth, with more tendentious results

using the accurate evaluation function.

Function 1 (relaxation)

Visibility factor The results show's a different size of growth in Cartman's performance in all

recursion depth beside recursion depth 4 which is almost unaffected. Furthermore,

we can se that the growth in the improvement tends to grow lower or even become

smaller (as in case of depth 3).

We didn't expected these result but it can be settled if we take into consideration

the fact that we used inaccurate evolution function that might of caused this

behavior.

Recursion Depth factors The results shows the performance tends to converge to some value between 42 to

48. This evaluation function does not considering unreachable places or blocked

squares. So the players move only affected by the players' positions and not by the

board terrain. As a result of this, as much as the recursion depth is getting deeper

the general direction of each player is getting clearer and the players take the same

tactic in each play.

Function 2 (accurate evaluation)

Visibility factor The results show's almost the same linear growth in all recursion depths. It is clear

that Cartman visibility changes the game statistics to Cartman's benefit. We are

expecting Cartman improvement will continue to raise nearly to 95% performance.

notice that in 100% visibility the game can't take place, as we mentioned before.

Recursion Depth factor The

results shows that the recursion depth in this case is not a influence factor of

Cartman's performance. We think that using the accurate function there isn't much

need in going much deeper in the recursion because there is slight recursion hidden

in the evaluation function that uses BFS to calculate the distances. So the results we

get from the low depth recursions are sufficiently accurate.

Conclusions

The visibility factor has decisive influence of the Mini-max algorithm, even

when little percentage of it is taken.

Recursion Depth factor can influence the balance between the players when

the evaluation function is not accurate enough and more calculations are

needed.