Programming Python (100 page)

PyToe’s GUI is
implemented as a frame of expandable packed labels, with
mouse-click bindings on the labels to catch user moves. The label’s text
is configured with the player’s mark after each move, computer or user.
The
GuiMaker
class we coded earlier
in the prior chapter (
Example 10-3
) is also reused here
again to add a simple menu bar at the top (but no toolbar is drawn at
the bottom, because PyToe leaves its format descriptor empty). By
default, the user’s mark is “X” and PyToe’s is “O.”
Figure 11-25
shows PyToe run from
PyGadgets with its status pop-up dialog, on the verge of beating me one
of two ways.

Figure 11-25. PyToe thinking its way to a win

Figure 11-26
shows
PyToe’s help pop-up dialog, which lists its command-line configuration
options. You can specify colors and font sizes for board labels, the
player who moves first, the mark of the user (“X” or “O”), the board
size (to override the 3 × 3 default), and the move selection strategy
for the computer (e.g., “Minimax” performs a move tree search to spot
wins and losses, and “Expert1” and “Expert2” use static scoring
heuristics functions).

Figure 11-26. PyToe help pop up with options info

The AI gaming techniques used in PyToe are CPU intensive, and some
computer move selection schemes take longer than others, but their speed
varies mostly with the speed of your computer. Move selection delays are
fractions of a second long on my machine for a 3 × 3 game board, for all
“-mode” move-selection strategy options.

Figure 11-27
shows an alternative
PyToe configuration (shown running its top-level script directly with no
arguments), just after it beat me. Despite the scenes captured for this
book, under some move selection options, I do still win once in a while.
In larger boards and more complex games, PyToe’s move selection
algorithms become even more useful.

Figure 11-27. An alternative layout

PyToe is a big
system that assumes some AI background knowledge and
doesn’t really demonstrate anything new in terms of GUIs. Moreover, it
was written for Python 2.X over a decade ago, and though ported to 3.X
for this edition, some of it might be better recoded from scratch today.
Partly because of that, but mostly because I have a page limit for this
book, I’m going to refer you to the book’s examples distribution package
for its source code instead of listing it here. Please see these two
files in the examples distribution for PyToe implementation
details:

If you do look, though, probably the best hint I can give you is
that the data structure used to represent board state is the crux of the
matter. That is, if you understand the way boards are modeled, the rest
of the code comes naturally.

For instance, the lists-based variant uses a list-of-lists to
represent the board’s state, along with a simple dictionary of entry
widgets for the GUI indexed by board coordinates. Clearing the board
after a game is simply a matter of clearing the underlying data
structures, as shown in this code excerpt from the examples named
earlier:

def clearBoard(self):
for row, col in self.label.keys():
self.board[row][col] = Empty
self.label[(row, col)].config(text=' ')

Similarly, picking a move, at least in random mode, is simply a
matter of picking a nonempty slot in the board array and storing the
machine’s mark there and in the GUI (
degree
is the board’s size):

def machineMove(self):
row, col = self.pickMove()
self.board[row][col] = self.machineMark
self.label[(row, col)].config(text=self.machineMark)
def pickMove(self):
empties = []
for row in self.degree:
for col in self.degree:
if self.board[row][col] == Empty:
empties.append((row, col))
return random.choice(empties)

Finally, checking for an end-of-game state boils down to
inspecting rows, columns, and diagonals in the two-dimensional
list-of-lists board in this scheme:

def checkDraw(self, board=None):
board = board or self.board
for row in board:
if Empty in row:
return 0
return 1 # none empty: draw or win
def checkWin(self, mark, board=None):
board = board or self.board
for row in board:
if row.count(mark) == self.degree:     # check across
return 1
for col in range(self.degree):
for row in board:                      # check down
if row[col] != mark:
break
else:
return 1
for row in range(self.degree):             # check diag1
col = row                              # row == col
if board[row][col] != mark: break
else:
return 1
for row in range(self.degree):             # check diag2
col = (self.degree-1) - row            # row+col = degree-1
if board[row][col] != mark: break
else:
return 1
def checkFinish(self):
if self.checkWin(self.userMark):
outcome = "You've won!"
elif self.checkWin(self.machineMark):
outcome = 'I win again :-)'
elif self.checkDraw():
outcome = 'Looks like a draw'

Other move-selection code mostly just performs other kinds of
analysis on the board data structure or generates new board states to
search a tree of moves and
countermoves
.

You’ll also find relatives of these files in the same directory
that implements alternative search and move-scoring schemes, different
board representations, and so on. For additional background on game
scoring and searches in general, consult an AI text. It’s fun stuff, but
it’s too specialized to cover well in this
book.

This part of the book explores Python’s role as a language for
programming Internet-based applications, and its library tools that
support this role. Along the way, system and GUI tools presented earlier
in the book are put to use as well. Because this is a popular Python
domain, chapters here cover all fronts:

Although they are outside this book’s scope,
Chapter 12
also provides brief overviews of more
advanced Python Internet tools best covered in follow-up resources, such
as Jython, Django, App Engine, Zope, PSP, pyjamas, and HTMLgen. Here,
you’ll learn the fundamentals needed to use such tools when you’re ready
to step up.

Along the way, we’ll also put general programming concepts such as
object-oriented programming (OOP) and code refactoring and reuse to work
here. As we’ll see, Python, GUIs, and networking are a powerful
combination
.