X x x x x x x x x x x x x x x x x o o o o o o o o x o

x x x
x x x
x x x
x
x
x
x x
x
x x
o
o
o
o o
o o o
x o x o
x o x o x o
x o x
o
x
x x x
x x x
. . .
. . .
. . .
T
T
T
I C
C
A
O E
GAME TREE
x o x
x
x
o o
. . .
These are game
structures.
These are move
structures.
KEYS
Now we use this tree to play a game of tic-tac-toe. Player X starts out with nine pos-
sible moves. She chooses to place her X in the upper-left corner. As a result, we focus only
on the leftmost branch of the tree, leaving player O with eight possibilities. Say player O
then marks the spot directly next to the X. This in turn means we again choose the left-
most branch. We keep pruning the tree like this until the game is over, which happens
when one player wins or all ields are marked.
Generating the tic-tac-toe tree is reasonably straightforward. Suppose we have a data
representation for the two players, X and O, and we represent the tree itself with
ttt
nodes:
(struct ttt (board moves))

170 Chapter 10
Each such node contains the current state of the board and the list of possible moves. Each
move is a two-element list that combines an action with the resulting game tree, where an
action is just another structure:
(struct action (player position))
It records the player that takes the action and her chosen token placement.
The tree-generating function consumes the two players and produces a complete
game tree starting from an empty board:
(define (generate-ttt-tree player1 player2)
(define (generate-tree board player opponent)
(ttt board (generate-moves board player opponent)))
(define (generate-moves board0 player opponent)
(define free-fields (board-find-free-fields board0))
(for/list ((f free-fields))
(define actnow (action player f))
(define board1 (board-take-field board0 player f))
(list actnow (generate-tree board1 opponent player))))
;; -- start here --
(generate-tree the-empty-board player1 player2))
As you can see, the function introduces two auxiliary functions:
generate-tree
and
generate-moves
. The irst one generates a tree node from the current state of the board
and two players, assuming the irst player takes an action. The second function gener-
ates the list of possible moves from the current board and the two players, still assuming
that the irst player is the active one.
From the deinition, you can see that
generate-tree
is straightforward. It cre-
ates the node from the current board and generates the possible moves with the second
function. In contrast, the
generate-moves
function must iterate over all free ields,
which it inds with
board-find-free-fields
, a function not shown here. For each of
the free ields, the loop creates an action for the current player and the free ield. Then
it computes with
board-take-field
the efect of the action on the current board. The
result of an iteration is a two-element list that pairs the action with the resulting tree,
which is determined via a recursive call to
generate-tree
. When the loop has inished,
generate-moves
returns an entire list of such two-element lists.