The board game of Go is so expressly Japanese – elegant, yet simple, yet layered with depths of genius for those who meditate upon it. The rules are simple, and well documented here.
Here is an example of a python program that will allow two human players to play against one another on one computer, providing an ascii display. In future posts we will be exploring how basic user-raw_input-dependent programs like this one can be improved through GUI programming and over-the-net communication – turning this one-computer ascii program into a graphical game you can play with your friend in Japan – or, if you’re already in Japan, with your friend in Jamaica (or, if you’re already in Jamaica, somewhere that is not Jamaica). I have explained the code in the comments.
In a recent post, I provided an example of AI that learns how to play tic-tac-toe, even until it becomes unbeatable. It may be worthwhile to consider how the approach shown there can be applied here.
## The number of spots per side of the board
## This code allows for an nxn board
boardsize = 5
## Value determining whether the player wants to quit or not
gameon = 1
## Lists of groups that have been removed from the board via capture,
## held in these varaibles in case, when all captures have been
## completed, the board resembles a previous game state and
## the move is invalid. In that case, the groups are restored
## from these varaibles.
restore_o = []
restore_x = []
## Generates blank game states
def initalize():
gs = []
for i in range(0,boardsize):
gs.append([])
for j in range(0,boardsize):
gs[i].append('-')
return gs
## Provides an ascii display of the Go board
def printboard(gs):
global boardsize
for row in gs:
rowprint = ''
for element in row:
rowprint += element
rowprint += ' '
print(rowprint)
## Returns a list of the board positions surrounding the
## passed group.
def gperm(group):
permimeter = []
global boardsize
hit = 0
loss = 0
## Adds permimeter spots below
## Works by looking from top to bottom, left to right,
## at each posisition on the board. When a posistion
## is hit that is in the given group, I set hit = 1.
## Then, at the next position that is not in that group,
## or if the end of the column is reached, I set loss = 1.
## That point is the first point below a point in that group,
## so it is part of the permieter of that group.
i = 0
j = 0
while i < boardsize:
j = 0
hit = 0
while j < boardsize:
if [i,j] in group:
hit = 1
elif (hit == 1) & ([i,j] not in group):
loss = 1
if (hit == 1) & (loss == 1):
permimeter.append([i,j])
hit = 0
loss = 0
j += 1
i += 1
## Adds permimeter spots to the right
i = 0
j = 0
while i < boardsize:
j = 0
hit = 0
while j < boardsize:
if [j,i] in group:
hit = 1
elif (hit == 1) & ([j,i] not in group):
loss = 1
if (hit == 1) & (loss == 1):
permimeter.append([j,i])
hit = 0
loss = 0
j += 1
i += 1
## Adds permimeter spots above
i = 0
j = boardsize-1
while i < boardsize:
j = boardsize-1
hit = 0
while j >= 0:
if [i,j] in group:
hit = 1
elif (hit == 1) & ([i,j] not in group):
loss = 1
if (hit == 1) & (loss == 1):
permimeter.append([i,j])
hit = 0
loss = 0
j -= 1
i += 1
## Adds permimeter spots to the left
i = 0
j = boardsize-1
while i < boardsize:
j = boardsize-1
hit = 0
while j >= 0:
if [j,i] in group:
hit = 1
elif (hit == 1) & ([j,i] not in group):
loss = 1
if (hit == 1) & (loss == 1):
permimeter.append([j,i])
hit = 0
loss = 0
j -= 1
i += 1
return permimeter
## Returns a string that describes the game state
def readable(gs):
readthis = ''
readthis += '<<'
for row in gs:
for element in row:
readthis += element
readthis += '>>'
return readthis
## Counts the territory captured by each player
def count():
global gsc
global non_groups
global o_points
global x_points
global boardsize
## Creates a list of groups (non_groups) of empty positions.
for i in range(0,boardsize):
for j in range(0,boardsize):
if gsc[j][i] == '-':
new = 1
for group in non_groups:
if [i,j] in gperm(group):
group.append([i,j])
new = 0
if new == 1:
non_groups.append([[i,j]])
concat('-')
o_points = 0
x_points = 0
## Gives a point to the each player for every pebble they have
## on the board.
for group in o_groups:
o_points += len(group)
for group in x_groups:
x_points += len(group)
## The permimeter of these empty positions is here considered,
## and if every position in the permimeter of a non_group is
## one player or the other, that player gains a number of points
## equal to the length of that group (the number of positions
## that their pieces enclose).
for group in non_groups:
no = 0
for element in gperm(group):
if gsc[element[1]][element[0]] != 'o':
no = 1
if no == 0:
o_points += len(group)
for group in non_groups:
no = 0
for element in gperm(group):
if gsc[element[1]][element[0]] != 'x':
no = 1
if no == 0:
x_points += len(group)
## Checks for capture, and removes the captured pieces from the board
def capture(xoro):
global o_groups
global x_groups
global gsf
global restore_o
global restore_x
global edited
if xoro == 'o':
groups = x_groups
otherplayer = 'o'
else:
groups = o_groups
otherplayer = 'x'
## Checks to see, for each group of a particular player,
## whether any of the board positions in the
## perimeter around that group are held by the other player.
## If any position is not held by the other player,
## the group is not captured, and is safe. Otherwise,
## the group is removed. But we haven't tested this yet
## to see if this would return the board to a previous
## state, so we save the removed groups with the restore lists.
for group in groups:
safe = 0
for element in gperm(group):
if gsf[element[1]][element[0]] != otherplayer:
safe = 1
if safe != 1:
edited = 1
if xoro == 'o':
restore_x.append(group)
else:
restore_o.append(group)
groups.remove(group)
# Sets gsf given the new captures
gsf = initalize()
for group in o_groups:
for point in group:
gsf[point[1]][point[0]] = 'o'
for group in x_groups:
for point in group:
gsf[point[1]][point[0]] = 'x'
## Checks to see if the new game state, created by the most recent
## move, returns the board to a previous state. If not, then
## gsc is set as this new state, and gsp is set as what gsc was, and
## the new game state is stored in gscache. The function returns 1
## if the move is valid, 0 otherwise.
def goodmove():
global gscache
global gsc
global gsp
global gsf
if readable(gsf) not in gscache:
gsp = []
gsc = []
for element in gsf:
gsp.append(element)
gsc.append(element)
gscache += readable(gsf)
return 1
else:
return 0
## Checks if any groups contain the same point;
## if so, joins them into one group
def concat(xoro):
global o_groups
global x_groups
global non_groups
if xoro == 'o':
groups = o_groups
elif xoro == 'x':
groups = x_groups
else:
groups = non_groups
i = 0
## currentgroups and previousgroups are used to compare the number
## of groups before this nest of whiles to the number after. If
## The number is the same, then nothing needed to be concatinated,
## and we can move on. If the number is different, two groups
## were concatinated, and we need to run through this nest again
## to see if any other groups need to be joined together.
currentgroups = len(groups)
previousgroups = currentgroups + 1
## Checks if the positions contained in any group are to be
## found in any other group. If so, all elements of the second are
## added to the first, and the first is deleted.
while previousgroups != currentgroups:
while i < len(groups)-1:
reset = 0
j = i + 1
while j < len(groups):
k = 0
while k < len(groups[i]):
if groups[i][k] in groups[j]:
for element in groups[j]:
if element not in groups[i]:
groups[i].append(element)
groups.remove(groups[j])
reset = 1
if reset == 1:
break
k += 1
j += 1
if reset == 1:
i = -1
i += 1
previousgroups = currentgroups
currentgroups = len(groups)
## Adds point xy to a group if xy is in the
## perimeter of an existing group, or creates
## new group if xy is not a part of any existing group.
def addpoint(xy,xoro):
global o_groups
global x_groups
if xoro == 'o':
groups = o_groups
else:
groups = x_groups
new = 1
for group in groups:
if xy in gperm(group):
group.append(xy)
new = 0
if new == 1:
groups.append([xy])
## Lets the player select a move.
def selectmove(xoro):
global boardsize
global gsf
hold = 1
while hold == 1:
minihold = 1
while minihold == 1:
pp = raw_input('Place or pass (l/a)? ')
if pp == 'a':
return 'pass'
elif pp == 'l':
minihold = 0
## This try...except ensures that the user
## raw_inputs only numbers
error = 0
try:
x = int(raw_input('x: '))
except ValueError:
error = 1
try:
y = int(raw_input('y: '))
except ValueError:
error = 1
if error == 1:
minihold = 1
print('invalid')
else:
print('invalid')
## Ensures that the raw_input is on the board
if (x > boardsize) | (x < 0) | (y > boardsize) | (y < 0):
print('invalid')
elif gsc[y][x] != '-':
print('invalid')
else:
hold = 0
## Places the piece on the 'future' board, the board
## used to test if a move is valid
if xoro == 'o':
gsf[y][x] = 'o'
else:
gsf[y][x] = 'x'
return [x,y]
## The 'turn,' in which a player makes a move,
## the captures caused by that piece are made,
## the validity of the move is checked, and
## the endgame status is checked.
def turn():
global xoro
global notxoro
global player1_pass
global player2_pass
global gameover
hold = 1
while hold == 1:
print()
print('place for '+xoro)
## By calling selectmove(), the player
## is given the option of whether to place
## a piece or to pass, and where to place
## that piece.
xy = selectmove(xoro)
if xy == 'pass':
if xoro == 'o':
player1_pass = 1
else:
player2_pass = 1
hold = 0
## If the player doesn't pass...
else:
player1_pass = 0
player2_pass = 0
## The new piece is added to its group,
## or a new group is created for it.
addpoint(xy,xoro)
## Groups that have been connected by
## the this placement are joined together
concat(xoro)
minihold = 1
## Edited is a value used to check
## whether any capture is made. capture()
## is called as many times as until no pieces
## are capture (until edited does not change
## to 1)
edited = 0
while minihold == 1:
restore_o = []
restore_x = []
capture(xoro)
capture(notxoro)
if edited == 0:
minihold = 0
edited = 0
else:
edited = 0
## Checks to see if the move, given all the
## captures it causes, would return the board
## to a previous game state.
if goodmove() == 1:
hold = 0
## If the move is invalid, the captured groups need
## to be returned to the board, so we use
## the groups stored in the restore lists to
## restore the o_ and x_groups lists.
else:
print('invalid move - that returns to board to a previous state')
for group in restore_o:
o_groups.append(group)
for group in restore_x:
x_groups.append(group)
if (player1_pass == 1) & (player2_pass == 1):
gameover = 1
## Called to start a game
def main():
## Either 'o' or 'x', determines who's turn it is
global xoro
## The opposite of xoro, determines who's turn it is not
global notxoro
## Game State Current, the current layout of the board
## This value is two-dimensional list, the higher dimension being
## lists representing the rows and the lower dimension being
## strings representing individual positions on the board.
## These strings are either '-', 'o', or 'x'
global gsc
## 0 or 1, determins whether the current game is ongoing or ended
global gameover
## Game State Future, same setup as gsc, used for testing the
## waters of a new move, to see if that move is valid, before
## gsc is edited to reflect that move
global gsf
## Two-dimensional lists, the higher dimension being groups, the
## lower dimension being lists of board positions in a particular
## group
global o_groups
global x_groups
## Groups of empty positions
global non_groups
## String containing all the game states encountered in a particular
## game, used to check validity of moves
global gscache
## 0 or 1, for whether the player has passed their turn or not
global player1_pass
global player2_pass
## Integer value reflecting the score of a player
global o_points
global x_points
## Creates a blank game state - a blank board
gsc = initalize()
gsf = initalize()
## Sets initial values
o_groups = []
x_groups = []
non_groups = []
gscache = ''
player1_pass = 0
player2_pass = 0
gameover = 0
o_points = 0
x_points = 0
## Gives players turns until the end of the game
## (that is, until both players pass, one after
## the other)
while gameover != 1:
## Set it as o-player's turn
xoro = 'o'
notxoro = 'x'
print()
printboard(gsc)
turn()
if gameover == 1:
break
## Sets it as x-player's turn
xoro = 'x'
notxoro = 'o'
print()
printboard(gsc)
turn()
## Counts the score of both players
count()
print()
print('final board:')
print()
printboard(gsc)
print()
print('o points: ',str(o_points))
print('x points: ',str(x_points))
## Determines the winner
if o_points > x_points:
print('o wins')
elif x_points > o_points:
print('x wins')
else:
print('tie')
## Finally something that is not a function!
## This while loop will start new games for as
## long as the user choses to.
while gameon == 1:
main()
hold = 1
while hold == 1:
yn = raw_input('play again (y/n)? ')
if yn == 'n':
gameon = 0
hold = 0
elif yn == 'y':
hold = 0
else:
print('invalid')