Stratego

Designing agents for the Stratego game
Sergiu Redeca and Adrian Groza
Department of Computer Science,
Technical University of Cluj-Napoca, Romania
sergiu.redeca@student.utcluj.ro, adrian.groza@cs.utcluj.ro
Abstract—We focus here on designing agents for games with
incomplete information, such that the Stratego game. We develop
two playing agents that use probabilities and forward reasoning
with multiple-ply. We also proposed various evaluation functions
for a given position and we analyse the importance of the starting
configuration.
Index Terms—games with imperfect information, evaluation
functions, Stratego game
I. STRATEGO GAME
Stratego is a game with imperfect information invented by
the dutch Jacques Johan Mogendorff in 1942 [1]. The classical
game takes place on a board of size 10x10. The goal is to
capture the enemy’s flag [2]. In the centre of the board there
are two lakes of size 2x2, where the pieces are not allowed.
There are two players: red and blue. Each player has 40 pieces,
initially placed in a rectangular area of size 4x10. The players
can choose the way they place their pieces.
There are two types of pieces: mobile and immobile. Immo-
bile pieces are the flag and the bombs. Capturing the enemy’s
flag means winning the game. By attacking the bomb of the
enemy, the agent loses its piece, excepting the case when the
attacker is a miner (e.g. a mobile piece).
Mobile pieces have different ranks which are numbers
between 1 and 10. Pieces of rank 1 are called spies and are
the only pieces that can defeat the enemy’s piece of rank 10,
but only when the spy is the one who is attacking. Pieces of
rank 2 are called scouts and are the only pieces that can be
moved on a distance greater than one square at a time. The
way those pieces are moved is similar with the way the rook
moves on a chess board: it can be moved on any square in
the 4 directions (up, left, right, down) with the condition they
do not jump over another piece or over a lake. The pieces of
rank 3 are called miners with the role to diffuse bombs.
For attacking a piece, the attacker must be moved in the
cell where there is the enemy’s piece. The conflict between
two pieces results in removing the piece with the lower rank
or removing both of them if their ranks are equal. Attacking
a piece also leads to revealing the rank of the two involved
pieces. The game ends when one of the players captures the
opponent’s flag. Also, the game ends if one of the players do
not have what to move.
The challenge is that Stratego has a higher game-tree
complexity compared to other games such as Go and Chess
(Table I). For more about the game, the reader is referred to [3]
and [1].
Game Board
size
State-
space
complexity
Game-tree
complex-
ity
Average
game
length
Branching
fac-
tor
Tic-tac-toe 9 3 5 9 4
Chess 64 47 123 70 35
Go 361 170 360 150 250
Stratego 92 115 535 381 22
TABLE I: Complexity analysis [4]. State-space complexity and
game-tree complexity are expressed as log to base 10.
II. RELATED WORK
The first Stratego software agent was created in 1990 by the
company Accolade, but it made a lot of mistakes. Currently,
the best artificial Stratego agents have the level of a beginner.
Using neural networks. Smith has used in [5] a simplified
version of the game (6x6 board, 12 pieces) to increase the
number of running games. Smith has considered a random
position with complete information and simulates the game
with Monte-Carlo for the next 10-50 moves. This first strategy
is weaker than a human player, but beats the random agent
(which makes random moves) in 94% of the games. Training
set for the Convolutional Neural Network used was generated
by letting the agent playing against itself. Smith has also
investigated the combination of alpha-beta pruning with neural
networks. That is, at a certain depth in the search tree, the
position is evaluated using a neural network. This second
approach has proved better in 60% of the games with an
opponent using the first strategy.
Using probabilities and Bayesian networks. Stankicwicz has
focused on opponent modelling [6] to determine the rank of
each piece, based on previous games with the same opponent.
The simulated behaviour of the opponent is also considered.
For instance, the opponent may aggressively advance a low-
ranked piece towards a piece with known rank in order to
mislead its opponent. A probability distribution is attached to
each piece to simulate the behaviour. Stankicwicz has also
argued on the importance of the initial starting position of
the players. Placing high-ranked pieces on the first line leads
to a quicker revealing of their ranks. Similarly, known pieces
should be captured with pieces with closed ranks, in order to
keep the location of valuable pieces secret. Probabilities are
used to assess the rank of a piece based on local information
only. For instance, an approaching piece usually has a higher
rank. Modelling the opponent has lead to correct rank predic-
tion of 40%, compared to only 17.7% in case of not using978-1-5386-8445-0/18/ $31.00 © 2018 IEEE

F B B 10 2 B
B B 1
7
3
B 10
5
7
B 10 3
5 B B 9 7
B F B 7
F B B 10 2 B
B B 1
7
3
B 10 3
5 B B 9 7
B F B 7
Fig. 1: Asymmetric information on the same game: blue agent on the left, red agent in the centre, controller agent on the right.
the model of the opponent. This higher prediction has lead to
55% wins against the opponent without the model of the other
player.
Duperier et al. has observed that with complete information
the game is easy to solve [7]. Hence, the agent’s strategy
focuses on revealing information. The starting positions are
taken from collection of 40.000 games. At each round, a
random variable for ranks is updated. Maarten et al. have
proved in [3] that quiescence search is effective for the
Stratego game. That is because there are many positions with
no moves leading to signiﬁcant changes. Boer in [8] and
Tunru in [9] have tested the feasibility of genetic algorithms.
The ﬁtness function considers number of moves, number of
remaining pieces, the outcome of the game (win/lost). Arts
has applied alpha-beta pruning in [4]. The evaluation function
considers the ranks of the pieces, information gains and
strategic positions. In [10], Ismail has created a set of rules for
controlling the pieces and develops a multi-agent architecture
using expert systems.
III. DESIGNING AGENTS FOR THE STRATEGO GAME
A. Probabilistic agent
The probabilistic agent evaluates the outcome of all next
legal moves, and picks the best one. The best move is given by
an evaluation function. If a piece of the enemy has an unknown
rank, the agent chooses a rank for that piece in a probabilistic
way, by considering all the information known about that piece
and about the enemy’s army. Because the number of each piece
type of the enemy is known, the probabilistic agent stores a
table with scores with the remaining pieces. The number of the
pieces of a particular rank will be associated with that rank in
the table. A similar approach is used in [7] where each piece
has its own probability distribution.
The opponents have different views on the same game. Let
the tuple r,ir with r representing the rank, while ir the num-
ber of the pieces of that rank on the board. On the game de-
picted in Fig. 1), the blue player has the following information:
{ F,1 , B,5 , 1,1 , 2,1 , 3,1 , 10,1 }. Differently, the red
player knows: { F,1 , B,4 , 3,1 , 7,2 , 9,1 }. When the
rank of an opponent’s piece is disclosed, the number associated
with the rank of that piece is decreased. When evaluating a
move which requires to attack a piece of an unknown rank,
the player chooses the rank of the attacked piece according
to the number of the available pieces of each rank the enemy
still has on the board. The probability of the agent to choose
the rank r for the attacked piece of colour c ∈ {blue,red} is
pc
r =
ir
∑s∈Rc is
, ∀r ∈ Rc
(1)
where ir is the number of pieces of rank r, the denominator is
the number of remaining pieces of the enemy, Rc is the set of
all ranks of the pieces the enemy has on the board, In Fig. 1 we
have Rred = {F,B,3,7,9} and Rblue = {F,B,1,2,3,10}, while
iF and i3 have value 1 for both players.
If it is known that the attacked piece of the enemy was
moved, the immobile pieces are not considered anymore:
pc
rm
=
irm
∑s∈Rc
m
is
, ∀rm ∈ Rc
m (2)
where Rc
m is the set of the ranks of the movable pieces
the enemy has left on the board, which leads to: Rplayer
m =
Rplayer{F,B}. In Fig. 1, we have Rblue
m = {1,2,3,10} and
Rred
m = {3,7,9}.
B. Multi-ply agent
Similarly to the probabilistic agent, for each legal move
the agent chooses a rank for the attacked piece if there is an
attacked piece of unknown rank. Differently from the proba-
bilistic agent is that instead of evaluating the resulting position
immediately for each move, the multi-ply agent simulates the
next moves of the opponent. For this, the player generates a
possible game position for the enemy, that is consistent with
the information currently known about the opponent. Then
it uses the information that it knows the opponent certainly
knows about it for keeping the consistency in the newly
simulated position. After obtaining the move of the enemy, it
simulates it on its own board, getting this way a response from
the enemy for the initial move. Similarly with the probabilistic
agent, the multi-ply agent evaluates next the resulted position
and chooses the best move. For simulating the opponent’s

move, the agent considers if the other agent is a probabilistic
or a multi-ply one.
This approach is formalised in Algorithm 1. For eval-
uating a move, some auxiliary functions are used: First,
generate_valid_move outputs a valid move (in case
of a conflict, a valid move also specifies the ranks of the
involved pieces). Its input contains only the initial and the final
coordinates of the piece. It is necessary to use a valid move,
because we want to keep the information about the players
consistent with the current board. Without a valid move, the
agent to move would have no information about the opponent
which would lead to disadvantageous moves. Second, move
takes a game position t and the move that is made x and
returns the resulted position. Third, the reverse function
gives the agent the current game position as it thinks the
opponent sees it. For keeping the information consistent, the
agent keeps the information that is known by both players,
and hide the information that is known only by the agent, and
determine (using a probabilistic algorithm for example) the
information known only by its opponent.
Function GetMultiplyMove(cnt, pos, feval)
/* cnt - counter for recursion */
/* pos - game position */
/* feval - evaluation function */
if cnt = 0 then
moves := legal moves for position pos
evaluated moves := map(m →
{x := generate_valid_move(m)
return x, feval(move(pos,x))
},moves)
return argmax(evaluated moves)
else
moves := the moves available in the current pos
evaluated moves := map(m →
{
x := generate_valid_move(m)
pos := move(pos, x)
enemys board := reverse(pos )
enemys move :=
GetMultiplyMove(cnt −
1, enemys board, feval)
new position :=
move_in_actual_context
(pos , enemys move)
return x,feval(new position)
}
moves)
return argmax(evaluated moves)
end if
end
Algorithm 1: Picking the next move for the multi-ply agent.
Based on Algorithm 1, the multi-ply agent moves as follows.
Let the number of plies set to value 2 (e.g. cnt = 2) and
the starting position in the left part of Fig. 2. Here, the red
agent evaluates all legal moves and selects the best one. Let
the first analysed move to be (3,0)→(4,0). The move
(3,0)→(4,0) must be transformed in a valid move. For this
it is needed that at a conflict between pieces (such as in this
case) the rank of the involved pieces must be known. As the
rank of the blue piece is not known, it is estimated based on
the formulae 1 and 2). In the second board of Fig. 2 the rank
of the enemy’s piece is 6. Because the red piece has a higher
rank than the attacked blue piece, the red piece wins (right part
of Fig. 2). If the attacked piece would have had a bigger rank,
the execution of the move would also have been continued
even if this apparently leads to a disadvantageous move.
The red agent has a representation on how its opponent sees
the table. Only the information the red player knows that the
blue player knows about it are kept. In Fig. 5, that information
is represented by the pieces with ranks 5, 8, and 10. The ranks
of the pieces of the blue player are estimated probabilistically.
If we consider only the first level of the algorithm, we would
get a tree like the one from Fig. 4. All the possible moves
from level 0 are taken into consideration, even if they do not
lead to a fight between pieces. For continuing the algorithm
to the level 2, the steps applied until now are applied on the
leaves of the tree (such as the one in Fig. 5), making similar
computations for the rest of the nodes from level 1 of the tree.
In Fig. 6 (left), the move received after simulating the
move of the enemy (the red player) from the level 2 is now
executed in the context of the position from level 1 which
led to that ply. This way, the move from the board from
Fig 5 is executed on the board which initiated that ply for
the simulation (recall Fig. 5) which is seen from the point
of view of the blue player. After executing the move, the
evaluation of the position reached takes place (Fig 6) (center).
The evaluation is associated with the move (4,1)→(3,1)
that the blue agent started to test in Fig. 5. All the moves that
seem legal from perspective of the blue player from Fig. 5
will be similarly evaluated.
In Fig. 6, for the scenario where the move (4,1)→(3,1)
is considered the best move the blue player can make on the
board from position from Fig. 5, the move (4,1)→(3,1)
will be executed in the context of the board in Fig. 5 as a
response for the move of the red player from Fig. 2. Note that
by making the move from Fig. 5, the blue player attacks with
a piece of rank 3 another piece whose rank was computed as
being B. The information about this attacking piece is used
(the blue player’s piece of rank 3), but the information about
the attacked piece (the red piece of rank 6) is preserved. This
way the conflict between a piece of rank 3 and one of rank
6 is simulated, which will lead to the piece with the higher
rank being the winner (that is the red player’s piece).
Fig. 4 presents the computation method for the multi-
ply agent with 3 levels (0, 1, and 2). Each node (a circle)
represents a position of the game seen by the player of the
node colour . The transitions between nodes are numbered
so as the transitions that happen first have a lower number.
The levels of the tree are horizontal groups of nodes of the
same predominant colour, the level numbering starting from

7
8 6 10 3
5 B B 9 5
B F B 7
7
6?
8 6 10 3
5 B B 9 5
B F B 7
7
8
6 10 3
5 B B 9 5
B F B 7
Fig. 2: (Left) The red player evaluates one legal move i.e., (3,0)→(4,0). The legal move with the best evaluation score
will be selected. (Centre) In case of conflict between pieces, the rank of the blue piece is probabilistically estimated. (Right)
Simulating the move (3,0)→(4,0):higher rank 8 wins over the lower rank 6.
7 B B 10 6 3
B F 5
7
9
8 3 1
10
5
7 B B 10 6 3
B F 5
7
9
8 3 1
10
5
7 B B 10 6 3
B F 5
7
9
8 3 1
B? 10
5
Fig. 3: (Left): Red agent’s probabilistic representation on how the blue player sees the board. (Centre): The blue agent evaluates
all legal moves and it will choose the best one. Assume the move (4,1)→(3,1) is selected. (Right): Because the rank of
the attacked piece is not known, it is probabilistically estimated. In this case, the mos probable rank for the opponent is B.
0 and from top to bottom. In the figure we can notice that the
level 2 is reached. The agent starts to determine all moves it
can make; after this it takes the first move (transition a1) and
executes it, reaching the node n1 then it will obtain a possible
move the enemy will make, then it will execute that move in
its own context a7 and will analyse the resulting position n7,
the evaluation score being associated with the initial move a1.
The moves analysed initially shouldn’t be taken in order. The
order between a1, a9, a21 can be changed and the same
would apply for example for a3, a4, a5 .
We describe the correlation of the Fig. 9 with the board
positions presented for multi-ply agent. Any node will be
named according to any arc number that enters in that node.
The initial position from Fig. 2 would be the root node of
the tree. The moves from Fig. 2 correspond to the arc a9,
which leads to Fig. 5 that corresponds to the node n9. Fig. 5
depicts also the inverted position of the previous board, and
it corresponds to the node n10. The arc a10 represents the
function of reversing positions reverse from Algorithm 1.
The move from Fig 5 (left) and 5 (centre) corresponds to the
arc a12. The node n12 represents the position from Fig. 5.
The node n13 corresponds to the board in Fig. 5, arc a13
being the result of applying the function reverse on the
node n12.
Fig. 5 depicts the moves (3,8)→(4,8) and
(1,0)→(2,0). The second move corresponds to the
arc a14. The first portion of arc a15 represents the sending
of the move correlated with the arc a14 and its evaluation
(which is the evaluation of the position from n14) back to
the node n13. The second portion represents the selection of
the move a14 as being the best from the evaluated moves
and sending it to the parent node; the selection is made by
node n13. The preserving-context move from Fig. 6 (left)
has the arc a16 as a correspondent. The board from Fig. 6
(centre) corresponds to the node n16. The arc a17 represents
sending the evaluation of the move a12 (which is the same
with the evaluation of position n16) back to the node n10.
The arc a18 represents the sending of the best move (a12 in
this case) to the parent node. The context-keeping move from
Fig. 6 (right) corresponds to arc a19, while the resulting
position (Fig. 7) to the node n19 whose value is sent through
the arc a20 as being the evaluation of the initially-tested
move a9. In the parent node, all tested moves (including a1,
a9, a21) will be sorted using their evaluations (a8, a20,

7
8 6 10 3
5 B B 9 5
B F B 7
7
8
6 10 3
5 B B 9 5
B F B 7
7 B B 10 6 3
B F 5
7
9
8 3 1
10
5
7
5
8 6 10
5 B B 9 5
B F B 7
F 1 B 10 3 6
B 7 B
7
5
3 9 5
10
5
level 0
Fig. 4: The tree for the plies of the level 1 of the algorithm.
a22) and the agent will choose the best move to make.
IV. IMPROVING THE AGENTS
We focus on two issues for effective Stratego agents: 1)
How to configure the starting position?, respectively 2) How
to evaluate a given position?
A. Selecting the starting position
First, random starting positions are generated randomly.
One advantage is that the resulted starting positions will be
very unpredictable, which will lead to an advantage, at least
in the beginning. One disadvantage is that starting positions
will be usually bad in the long run, because even if they are
very unpredictable, the most important pieces (such as the flag,
the marshal, the mines) will be randomly placed. Moreover,
the setup might not be suited for the agent’s style of play.
Second, predefined starting positions are the positions that
the best Stratego players use in international tournaments.
These have some common characteristics which increase their
chances of winning. The agents implemented in the game can
randomly choose one of those positions. Using predefined po-
sitions has some advantages: i) the pieces are well-organised,
ii) the setups were tested by experienced users. There are also
disadvantages: i) the setup might not be suited for the agent’s
style of play, ii) when there are few setups to choose from, the
agent’s board setup might be predictable, iii) it is necessary
to gather large amount of data.
B. Evaluation functions
Firstly, we define a function that considers only the material
advantage. A similar approach is used in [11]. This evaluation
function considers the number of moves available for each
player (see Algorithm 2). A positive output considers that the
red player has advantage. For negative output, the blue player
has advantage. Zero value means an equal position. We have
a polynomial complexity O(n·m), where n is the number of
rows, while m the number of columns.
fm(pos) =
n=9
∑
i=0
m=9
∑
j=0
g(i, j, pos) (3)
g(x,y, pos) =



1, if there is a red piece atpos[x,y]
−1, if there is a blue piece atpos[x,y]
0, if there is no piece atpos[x,y]
(4)
Function EvaluateMaterialAdvantage(board)
sum ← 0, n = lines(board), m ← columns(board)
for i ← 1 to n do
for j ← 1 to m do
if at board[i][j] == RED then
sum ← sum+1
end if
if at board[i][j] == BLUE then
sum ← sum−1
end if
end for
end for
return sum
end
Algorithm 2: The evaluation of the material advantage.
In contrast to the evaluation of the material advantage,
the baseline evaluation considers the information which is
known about the pieces which are on the board. If a piece
gives information about its rank, the evaluated position is
detrimentally affected, the owner of that piece having a
disadvantage. The distance of the pieces from the enemy’s
side of the board (where the enemy flag is placed) is also
taken into consideration (see Algorithm 3). The complexity of
the evaluation function is also O(m·n).
fb(pos, pieceW,rankW,moveW,distW) =
=
n=9
∑
i=0
m=9
∑
j=0
g(i, j, pos)·(pieceW −rankW ·rank(pos[i, j])
−moveW −distW ·((4.5−i)g(i, j, pos)+1.5)2
) (5)
V. RUNNING EXPERIMENTS
A. Comparing agents with different configurations
The agents are compared in Table II, where total represents
the number of played games. Here, VR represents red victories

7 B B 10 6 3
B F 5
7
9
8 1
3 10
5
7
8
3 10 7
5 B B F 9
6 3 B 5
7
8 10?
3 10 7
5 B B F 9
6 3 B 5
Fig. 5: (Left): Because the miner captures the bomb, the blue player’s piece wins. (Centre): The board is reversed again, and
the algorithm reaches the second level of the computational tree. The consistency with the previous board is preserved. Note
that the placement of the red pieces is not necessarily the same as in the previous position where the red player had to move.
This is the last generated ply, and the first where the agent starts computing evaluations of the resulting positions. (Right) The
agent evaluates all the positions resulted after making all legal moves, and picks the best one (e.g., (1,0)→(2,0)).
7 B B 10 6 3
B F 5
7
9
8 1
3 10
5
7 B B 10 6 3
B F 5
7
9
8 1
3 10
5
7
8 3?
6 10 3
5 B B 9 5
B F B 7
Fig. 6: (Left) The move received after simulating the move of the enemy (the red player) from the level 2. (Centre) Evaluating
the move (4,1)→(3,1). (Right) The information about this attacking piece is used (the blue player’s piece of rank 3).
7
8
6 10 3
5 B B 9 5
B F B 7
Fig. 7: Position after a conflict between a piece of rank
3 and an attacked piece of rank 6. The piece with the
highest rank wins (the red piece). The evaluation of the move
(3,0)→(4,0) from Fig. 2 will be equal with the evaluation
of the position we reached in this position. The rest of the
moves from the init board 2 will be similarly evaluated.
as a percentage of the total, VRC are red victories with
capture, as a percentage of VR. Similarly, VA are blue victories
as a percentage of the total number of games, while VAC are
blue victories with capture, as a percentage of VR. The number
of moves of the games finished with a win-by-capture is also
taken into consideration in some experiments (VRCM for red
and VACM for blue). The execution time is denoted with te.
Two evaluation functions were used: basic evaluation function
fb and material evaluation function fm. The players use the
same configuration for the starting position.
In Experiment 1 (Table II), the probabilistic agent wins
almost all games against the random agent, but there is no
win by capturing the enemy flag. This is because the blue
agent makes defensive moves, letting the enemy to make
bad moves and lose all their pieces. This technique wouldn’t
be efficient against a smarter player. It is important to also
win games by capture. In Experiment 2, only the evaluation
function of the blue player was changed. Even if the number
of victories is lower, the agent won some matches by capture.
In Experiment 3, the probabilistic agent is replaced by a 2-ply
agent, which at the end of their evaluation uses the approach of

7
8
3
10
7
5
B
B
F
9
6
3
B
5
7
B
B
10
6
3
B
F
5
7
9
8
3
1
B?
10
5
7
6?
8
6
10
3
5
B
B
9
7
B
F
7
B
level 0
level 1
level 2
Fig. 8: The evaluation of the moves of the multi-ply agent.
Each ply is at a different level. The move of the upper levels
will be used later at the lower levels.
Fig. 9: Computation tree for the multi-ply agent.
the probabilistic agent. Note that the percentage of victories
is slightly lower, but the percentage of the games won by
capture shows a significant improvement. In Experiment 4,
the more plies are used, the more games are won by capture.
In Experiment 5, the probabilistic agent and the multi-ply
agent are directly compared. The multi-ply agent has a small
advantage in won games, and the number of wins-by-capture
is much higher.
The probabilistic agent seems better than the multi-ply agent
in Experiments 2 and 3 considering just the parameter VA.
Function BasicEvaluation(board, pieceW, rankW,
moveW, distW)
sum ← 0.0, n ← lines(board), m ← columns(board)
for i ← 1 to n do
for j ← 1 to m do
if at board[i][j] == RED then
p ← piece from board[i][ j]
sum ← sum+ pieceW
if p has its rank disclosed then
sum ← sum−rankW·rank(p)
else if p was moved then
sum ← sum−moveW
end if
if i < 6 then
sum ← sum−distW ·(6−i)2
end if
end if
if at board[i][j] == BLUE then
p ← piece from board[i][ j]
sum ← sum− pieceW
if p has its rank disclosed then
sum ← sum+rankW·rank(p)
else if p was moved then
sum ← sum+moveW
end if
if i > 3 then
sum ← sum+distW ·(i−3)2
end if
end if
end for
end for
return sum
end
Algorithm 3: Baseline evaluation for positions of 10x10
board games. The last 4 parameters are used as weights.
But the probabilistic agent has a lower performance than
its opponent in test 5. From this, we can conclude that the
performance of agents cannot be ordered by their indirect
comparison, and that the percentage of won games is not the
only parameter which influences the strength of a player.
Experiments in Table III were made using starting positions
that were randomly chosen from a set used by players in
tournaments. Games were considered draws if there were
more than 10,000 moves. The results confirm the previous
experiments.
B. Parameter tuning
Here, the value of the weights from the baseline evaluation
function (Algorithm 3) was tuned to find the best values.
The default weights were: piece pW = 1.0, rank rW = 0.05,
move mW = 0.03, dist dW = 0.02. The results are shown in
Tables V, IV, VI and VII where the random agent (the red
player) is tested against the probabilistic agent with fb (the
blue player). The simulations for each table require 10 minutes
for completion.

TABLE II: Comparing the agents using different parameters. The agents use the same setup at the beginning of their games.
#E red(R) blue(A) VR(%) VRC(%) VA(%) VAC(%) total te(m)
1 random probabilistic, fm 1.4 75.1 98.5 0 10,000 4
2 random probabilistic, fb 10.2 10.4 89.7 34.27 10,000 4
3 random 2-ply, fb 14.5 16.5 85.5 55.7 1,000 8
4 random 3-ply, fb 16 6.25 84 76.1 100 21
5 probabilistic, fb 3-ply, fb 41.1 42.1 58.8 87.5 450 79
TABLE III: Comparing agents against the random one. Best identified agent is 2-ply with fb (#E 5 in Table III). Here, one
third of wins are made by capture, while the average number of moves needed for capturing the enemy’s flag is the smallest.
#E red(R) blue(A) VR(%) VRC(%) VRCM VA(%) VAC(%) VACM total te(m)
1 random random 49.51 12.48 1390 50.49 12.97 1406.12 10,000 <2
2 probabilistic, fm random 91.49 0.002 780 4.79 79.33 2410.58 10,000 7
3 2-ply, fm random 91.3 1.96 1470 5 84 1959.05 1,000 18
4 probabilistic, fb random 86.85 21.75 631 10.65 52.95 1673.00 10,000 7
5 2-ply, fb random 91.3 37.34 546 8.6 27.9 1766.40 1,000 8
TABLE IV: Tuning the weight for the existing pieces (pW).
#E 5-9 lead to the best results for the blue player. The best
value for pW is between 1 and 1.8.
#E pW VR(%) VRC(%) VRCM VA(%) VAC(%) VACM
1 0.2 66.7 24.5 2467 30.8 25.6 516
2 0.4 26.5 41.8 2099 71.2 13.3 632
3 0.6 11.2 49.1 2313 86.9 7.0 691
4 0.8 10.4 40.3 1990 86.9 27.6 514
5 1.0 7.4 51.3 2425 90.6 27.1 510
6 1.2 6.6 51.5 2252 91.4 27.7 534
7 1.4 6.8 52.9 2318 90.9 32.1 584
8 1.6 7.1 52.1 1893 91.5 29.7 534
9 1.8 8.1 45.6 2699 89.3 30.2 584
10 2.0 7.2 45.8 1933 91.3 25.0 541
TABLE V: Tuning the weight for pieces of unknown rank
(rW). The probabilistic agent has more victories for smaller
values of rW. One should pick rW ∈ (0.015; 0.075).
#E rW VR(%) VRC(%) VRCM VA(%) VAC(%) VACM
1 0.01 7.8 46.1 1852 91.1 28.5 567
2 0.03 8.5 50.5 2536 89.9 29.4 499
3 0.04 7.7 46.7 2323 90.4 25.7 541
4 0.06 7.7 42.8 2856 90.8 29.7 586
5 0.07 8.3 46.9 2406 89.4 28.9 583
6 0.09 10.4 48.0 2188 87.6 26.4 590
7 0.10 14.8 43.2 1942 83.2 28.1 639
8 0.12 18.3 30.6 2101 80.2 28.9 690
9 0.14 23.8 32.3 2241 74.2 32.7 600
10 0.15 28.9 32.1 1884 70.2 33.7 677
TABLE VI: Tuning the weight for moved pieces (mW). Note
that there is no values for mW which brings a substantial
advantage for the blue player.
#E mW VR(%) VRC(%) VRCM VA(%) VAC(%) VACM
1 0.006 7.0 41.4 2478 90.9 28.1 528
2 0.012 8.2 40.2 2292 89.8 28.9 545
3 0.018 6.5 50.7 1964 90.9 32.2 545
4 0.024 6.9 36.2 2902 91.5 28.7 519
5 0.030 8.0 48.7 2405 90.0 28.6 501
6 0.036 7.2 51.3 3171 90.8 29.4 509
7 0.042 7.8 52.5 2626 90.6 26.4 519
8 0.048 7.7 40.2 2242 90.3 28.3 524
9 0.054 6.5 50.7 2126 91.3 32.8 581
10 0.060 8.1 48.1 2440 90.7 32.5 554
TABLE VII: Tuning the weight for the distance of the pieces
from the enemy’s base (dW). The best values (for the blue
player) are in #E 1-5, where the most victories by capture
(VAC) occur. One should pick dW ∈ (0.005; 0.025).
#E dW VR(%) VRC(%) VRCM VA(%) VAC(%) VACM
1 0.005 5.8 41.3 1939 93.0 29.1 457
2 0.010 7.7 49.3 1923 90.0 29.4 549
3 0.015 7.5 46.6 1989 90.9 31.1 489
4 0.020 6.7 44.7 1946 90.8 29.7 502
5 0.025 6.7 37.3 2741 90.6 29.6 520
6 0.030 10.0 48.0 2577 88.5 5.5 535
7 0.035 9.3 45.1 2696 88.6 4.9 580
8 0.040 9.8 42.8 2463 88.2 5.6 494
9 0.045 9.0 56.6 1673 88.7 5.3 623
10 0.050 9.8 43.8 2324 87.9 6.0 644
VI. CONCLUSION
We developed here two agents for the game Stratego:
probabilistic and multi-ply. We also proposed two evaluation
functions for a given position and we analysed the importance
of the configuration of the evaluation functions. The running
experiments help an agent to adjust its strategy (probabilistic,
multi-ply) and evaluation function according to the strategy of
the opponent.
REFERENCES
[1] “Wikipedia: Stratego, https://en.wikipedia.org/wiki/stratego.”
[2] O. A. Syed and A. G. Syed, “Strategic board game,” Jan. 3 2006, US
Patent 6,981,700.
[3] M. P. S. M. H. Winands, “Quiescence search for Stratego,” 2009.
[4] S. Arts, “Competitive Play in Stratego,” March 2010.
[5] S. Smith, “Learning to play stratego with convolutional neural net-
works.”
[6] J. A. Stankiewicz and M. P. Schadd, “Opponent modeling in stratego,”
Natural Computing, 2009.
[7] L. Y. Duperier, R. Sauvestre, and Y. L. Calonnec, “Beating the Stratego
(technical article),” 2016.
[8] R. de Boer, “Reachable level of stratego using genetic algorithms,” B.S.
thesis, 2012.
[9] V. Tunru, “Feasibility of applying a genetic algorithm to playing
stratego,” B.S. thesis, 2012.
[10] M. Ismail, “Multi-agent stratego,” Ph.D. dissertation, B. Sc thesis,
Rotterdam University, The Netherlands.[2], 2004.
[11] J. Mohnen, “Using domain-dependent knowledge in stratego,” Ph.D.
dissertation, B. Sc thesis, Maastricht University, The Netherlands.[2],
2009.

Stratego

More Related Content

What's hot

Similar to Stratego

Recently uploaded

Stratego