#TicTacToe
#Written by Brandon Martin
#Digital Sol
import random
class BadInputError(Exception):
pass
class LogicError(Exception):
pass
#===========GAMEBOARDS===========#
blankBoard = {
'UL' : ' ', 'UM' : ' ', 'UR' : ' ',
'CL' : ' ', 'CM' : ' ', 'CR' : ' ',
'BL' : ' ', 'BM' : ' ', 'BR' : ' ',
}
debugBoard = {
'UL' : ' ', 'UM' : ' ', 'UR' : ' ',
'CL' : ' ', 'CM' : ' ', 'CR' : ' ',
'BL' : ' ', 'BM' : ' ', 'BR' : ' ',
}
invertedSpaces = {
'LU' : 'UL', 'MU' : 'UM', 'RU' : 'UR',
'LC' : 'CL', 'MC' : 'CM', 'RC' : 'CR',
'LB' : 'BL', 'MB' : 'BM', 'RB' : 'BR',
}
#===========DEFINITIONS===========#
'''Spaces'''
spaces = ('UL','UM','UR','CL','CM','CR','BL','BM','BR')
'''Wins'''
oWin = ('O','O','O')
xWin = ('X','X','X')
'''Doubles'''
oDoubles = [(' ','O','O'),('O',' ','O'),('O','O',' ')]
xDoubles = [(' ','X','X'),('X',' ','X'),('X','X',' ')]
'''Input'''
possibleInput = [key for key in blankBoard]
for key in invertedSpaces:
possibleInput.append(key)
'''Space Types'''
corners = ('UL','UR','BL','BR')
sides = ('CL','CR', 'UM', 'BM')
'''Space Inversions'''
horizontalFlip = {
'UL' : 'UR','UR' : 'UL',
'CL' : 'CR','CR' : 'CL',
'BL' : 'BR','BR' : 'BL',
}
verticalFlip = {
'UL' : 'BL', 'UM' : 'BM', 'UR' : 'BR',
'BL' : 'UL', 'BM' : 'UM', 'BR' : 'UR',
}
#===========OBJECTS===========#
class ticBoard():
def __init__(self, mode='blank', copyBoard=None):
if mode == 'blank':
self.board = {space:blankBoard[space] for space in blankBoard}
elif mode == 'debug':
self.board = {space:debugBoard[space] for space in debugBoard}
elif mode == 'copy' and copyBoard != None:
self.board = {space:copyBoard.board[space] for space in copyBoard.board}
def draw(self):
'''Draw board'''
print()
print(' L M R ')
print('U: {} | {} | {} '.format(self.board['UL'], self.board['UM'], self.board['UR']))
print(' -----------')
print('C: {} | {} | {} '.format(self.board['CL'], self.board['CM'], self.board['CR']))
print(' -----------')
print('B: {} | {} | {} '.format(self.board['BL'], self.board['BM'], self.board['BR']))
print()
def place(self, symbol, space):
'''Places a symbol at the designated space.'''
try:
self.board[space] = symbol
except:
raise BadInputError("{} is not a valid space for {}.".format(space, symbol))
def clear(self):
'''Clears board of all symbols.'''
self.board = {space:' ' for space in self.board}
def fieldReport(self):
'''Returns dictionary of triads.'''
report = {}
report[('UL','UM','UR')] = (self.board['UL'],self.board['UM'],self.board['UR'])
report[('CL','CM','CR')] = (self.board['CL'],self.board['CM'],self.board['CR'])
report[('BL','BM','BR')] = (self.board['BL'],self.board['BM'],self.board['BR'])
report[('UL','CL','BL')] = (self.board['UL'],self.board['CL'],self.board['BL'])
report[('UM','CM','BM')] = (self.board['UM'],self.board['CM'],self.board['BM'])
report[('UR','CR','BR')] = (self.board['UR'],self.board['CR'],self.board['BR'])
report[('UL','CM','BR')] = (self.board['UL'],self.board['CM'],self.board['BR'])
report[('UR','CM','BL')] = (self.board['UR'],self.board['CM'],self.board['BL'])
return report
def returnDoubles(self, report):
'''Filters out report to only include triads close to winning. ie "[X,X, ]" or '[O, ,O]"'''
doubles = {}
for triad in report:
if report[triad] in oDoubles or report[triad] in xDoubles:
doubles[triad] = report[triad]
return doubles
def checkWin(self):
'''Returns True if there are three symbols in a row. False if otherwise.'''
report = self.fieldReport()
for triad in report:
if report[triad] == oWin or report[triad] == xWin:
return True
return False
def checkEntry(self, entry, selected):
'''Returns the entry and whether or not it is valid.'''
entry = entry.upper()
if entry in invertedSpaces:
entry = invertedSpaces[entry]
if entry not in possibleInput:
return {'valid':False,'entry':entry, 'message':'\n{} is not a valid entry!'}
if entry not in selected:
return {'valid':True,'entry':entry}
else:
return {'valid':False,'entry':entry, 'message':'\n{} has already been selected!'}
def buildString(self, string):
if len(string) != 9:
print('String is not correct length. Reformatting will occur.')
string = string[:9]
while len(string) < 9:
string += '0'
for i in range(9):
if string[i] == '0':
self.board[spaces[i]] = ' '
elif string[i] == '1':
self.board[spaces[i]] = 'O'
elif string[i] == '2':
self.board[spaces[i]] = 'X'
def blankSpaces(self):
'''Returns list of free spaces remianing.'''
return [space for space in self.board if self.board[space] == ' ']
class player():
def __init__(self, identity):
self.id = identity
self.score = 0
self.match = 0
self.symbol = ''
def setName(self, name):
'''Define player's name.'''
if 0 < len(str(name)) < 20:
self.name = name.title()
return False
else:
return True
def setSymbol(self, symbol):
if symbol.upper() in ['X','O']:
self.symbol = symbol.upper()
return False
else:
return True
def win(self):
self.score += 1
def matchWin(self):
self.match += 1
def resetMatch(self):
self.match = 0
def getSymbol(self):
return self.symbol
def getName(self):
return self.name
def getIdentity(self):
return self.id
def getScore(self):
return self.score
def getMatches(self):
return self.match
class computer(player):
def __init__(self, difficulty='E'):
self.id = 'comp'
self.difficulty = difficulty[0]
self.setName('Computer')
self.setSymbol('X')
self.score = 0
self.match = 0
self.strategy = ''
self.tactic = ''
self.lastMove = ''
self.reiterate = False
def mapCoordinates(self, triad):
'''Converts a entry from a triad tuple to a dictionary of
symbol : coordinate values.'''
mapped = {}
coor = 0
for coordinate in triad[0]:
mapped[coordinate] = triad[1][coor]
coor+=1
return mapped
def analyzeMap(self, mappedCoordinates):
'''Returns empty value from a mapped coordinates dictionary.'''
for key in mappedCoordinates:
if mappedCoordinates[key] == ' ':
return key
def defineStrategy(self, strategy):
'''Play offensively (first turn) or defensively.'''
if strategy in ['offensive','defensive']:
self.strategy = strategy
def decideTactic(self, board):
'''Decide tactic based on the first move or by making first move.'''
if self.strategy == 'offensive':
firstMove = random.choice(['center','corner'])
#firstMove = 'corner'
self.tactic = firstMove
elif self.strategy == 'defensive':
for space in board.board:
if board.board[space] == 'O':
if space in corners:
self.tactic = 'corner'
elif space == 'CM':
self.tactic = 'center'
else:
self.tactic = 'side'
def clearStrategy(self):
self.strategy = ''
self.tactic = ''
def counter(self, doubles):
'''Either place winning piece or stop opponent from winning.'''
if doubles != {}:
triad = doubles.popitem()
entry = self.analyzeMap(self.mapCoordinates(triad))
debug(d,'Countering')
return {'counter':True, 'entry':entry}
return {'counter':False, 'entry':''}
def trapSimulation(self, board, report, pool):
'''Simulate different moves to trap opponent.'''
for coordinate in pool:
simulatedBoard = ticBoard('copy',board)
simulatedBoard.place(self.getSymbol(),coordinate)
simulatedDoubles = board.returnDoubles(simulatedBoard.fieldReport())
soDoubles = {key:simulatedDoubles[key] for key in simulatedDoubles if 'O' in simulatedDoubles[key]}
sxDoubles = {key:simulatedDoubles[key] for key in simulatedDoubles if 'X' in simulatedDoubles[key]}
if len(soDoubles) == 0 and len(sxDoubles) > 1:
debug(d,'Trapping')
return {'trap':True, 'entry':coordinate}
return {'trap':False, 'entry':coordinate}
def offensiveStrategy(self, board):
'''Provide offensive move based on a certain tactic.'''
if self.tactic == 'center':
if len(board.blankSpaces()) == 9:
debug(d,'Begin Center')
return {'offensive':True, 'entry':'CM'}
elif len(board.blankSpaces()) == 7:
for corner in corners:
if board.board[corner] == 'O' and board.board[verticalFlip[horizontalFlip[corner]]] == ' ':
debug(d,'Countering Corner')
return {'offensive':True, 'entry': verticalFlip[horizontalFlip[corner]]}
return {'offensive':False, 'entry':''}
else:
return {'offensive':False, 'entry':''}
elif self.tactic == 'corner':
if len(board.blankSpaces()) == 9:
debug(d,'Begin Corner')
return {'offensive':True, 'entry':random.choice(corners)}
else:
if board.board['CM'] != 'O':
if self.lastMove != '':
if board.board[horizontalFlip[self.lastMove]] == ' ' and board.board[self.lastMove[0] + 'M'] != 'O':
debug(d,'Horizontal Flip')
return {'offensive':True, 'entry':horizontalFlip[self.lastMove]}
elif board.board[horizontalFlip[self.lastMove]] == 'O':
debug(d,'Invert')
return {'offensive':True, 'entry':verticalFlip[horizontalFlip[self.lastMove]]}
else:
debug(d,'Vertical Flip')
return {'offensive':True, 'entry':verticalFlip[self.lastMove]}
if board.board['CM'] == 'O':
for space in board.board:
if board.board[space] == 'X' and space in corners:
debug(d,'Form XOX')
return {'offensive':True, 'entry':horizontalFlip[verticalFlip[space]]}
else:
return {'offensive':False, 'entry':''}
def defensiveStrategy(self, board):
'''Provide defensive move based on a certain tactic.'''
if self.tactic == 'center': #Keep Selecting Corners
for corner in corners:
if board.board[corner] == ' ':
debug(d,'Get Corners')
return {'defense':True, 'entry':corner}
elif self.tactic == 'corner':
if board.board['CM'] == ' ': #Get Center
debug(d,'Secure Center')
return {'defense':True, 'entry':'CM'}
else:
if len(board.blankSpaces()) == 6:
cornersFound = 0
for corner in corners:
if board.board[corner] == 'O':
cornersFound += 1
if cornersFound == 2:
for side in sides:
if board.board[side] == ' ':
debug(d,'Two Corners')
return {'defense':True, 'entry':side}
else:
self.strategy = 'offensive'
self.tactic = 'center'
self.reiterate = True
debug(d,'Retrategizing')
return {'defense':False, 'entry':''}
elif self.tactic == 'side':
if board.board['CM'] == ' ': #Get Center
return {'defense':True, 'entry':'CM'}
else:
if len(board.blankSpaces()) == 6:
report = board.fieldReport()
for triad in report:
if triad == ('O','X','O'):
debug(d,'OXO Kill')
return {'defense':True, 'entry':random.choice(corner)}
return {'defense':False, 'entry':''}
def think(self, board):
'''Return best possible move for a given situation.'''
### Query Board for Information ###
while True:
report = board.fieldReport()
totalDoubles = board.returnDoubles(report)
oDoubles = {key:totalDoubles[key] for key in totalDoubles if 'O' in totalDoubles[key]}
xDoubles = {key:totalDoubles[key] for key in totalDoubles if 'X' in totalDoubles[key]}
pool = board.blankSpaces()
if pool == []:
return
### Check for Winning Counters ###
counterMove = self.counter(xDoubles)
if counterMove['counter']:
self.lastMove = counterMove['entry']
return counterMove['entry']
### Check for Losing Counters ###
counterMove = self.counter(oDoubles)
if counterMove['counter']:
self.lastMove = counterMove['entry']
return counterMove['entry']
### Check for Trapping Moves ###
trapMove = self.trapSimulation(board, report, pool)
if trapMove['trap']:
self.lastMove = trapMove['entry']
return trapMove['entry']
### Strategize ###
if self.strategy == '':
if len(board.blankSpaces()) == 9:
self.strategy = 'offensive'
else:
self.strategy = 'defensive'
if self.tactic == '':
self.decideTactic(board)
if self.strategy == 'offensive':
offenseMove = self.offensiveStrategy(board)
if offenseMove['offensive']:
self.lastMove = offenseMove['entry']
return offenseMove['entry']
else:
defenseMove = self.defensiveStrategy(board)
if defenseMove['defense']:
self.lastMove = defenseMove['entry']
return defenseMove['entry']
### Random Guess ###
if self.reiterate:
self.reiterate = False
else:
debug(d,'Random Entry')
entry = random.choice(pool)
self.lastMove = entry
return entry
class debugger():
def __init__(self):
self.active = True
#===========HELPER FUNCTIONS===========#
def nextTurn(turnList, currentTurn):
currentIndex = turnList.index(currentTurn)
if (currentIndex + 1) == len(turnList):
return turnList[0]
else:
return turnList[currentIndex+1]
def debug(debugObject,statement):
if debugObject.active:
print(statement)
#===========GAME FUNCTIONS=============#
d = debugger()
def TicTacToe(debugging=True):
if not debugging:
d.active = False
###MENUS###
def mainMenu():
difficulty = 'Easy'
players = {}
debugStatus = ''
while True:
if d.active:
debugStatus = 'Enabled'
else:
debugStatus = 'Disabled'
print('\t\tTic-Tac-Toe')
print('\n\t1. One Player')
print('\t2. Two Players')
if players != {}:
print('\t\tA. Rematch')
print('\n\t3. Computer Difficulty:',difficulty)
print('\t4. Debugging',debugStatus)
selection = str(input('\nSelect Game Mode: '))
while selection not in ['1', '2', '3', '4', 'A', 'a', 'escape']:
print('\nSelection Invalid')
selection = str(input('\nSelect Game Mode: '))
if selection == '1':
print()
players = singlePlayer(difficulty)
print()
players = gameplay(players)
elif selection == '2':
print()
players = multiPlayer()
print()
players = gameplay(players)
elif selection == '3':
print()
if difficulty == 'Easy':
difficulty = 'Medium'
elif difficulty == 'Medium':
difficulty = 'Hard'
elif difficulty == 'Hard':
difficulty = 'Impossible'
else:
difficulty = 'Easy'
elif selection == '4':
print()
if d.active:
d.active = False
else:
d.active = True
elif selection in ['A','a']:
if players != {}:
print()
players = gameplay(players)
else:
print('Not an Option')
elif selection == 'escape':
break
else:
raise BadInputError('Data Provided Has No Function')
def singlePlayer(difficulty):
'''Returns dictionary of players for singleplayer gameplay.'''
players = {}
newPlayer = player('play1')
print('Player 1',end=' ')
if not d.active:
nameEntry = str(input('please enter your name: '))
while newPlayer.setName(nameEntry):
print('Invalid Entry!')
print('Player 1',end=' ')
nameEntry = str(input('please enter your name: '))
else:
newPlayer.setName("Debug")
newPlayer.setSymbol('O')
players['play1'] = newPlayer
players['comp'] = computer(difficulty)
return players
def multiPlayer():
'''Returns dictionary of players for multiplayer gameplay.'''
symbols = ['X','O']
players = {}
for identity in ['play1','play2']:
if identity == 'play1':
title = 'Player 1'
else:
title = 'Player 2'
newPlayer = player(identity)
print(title,end=' ')
nameEntry = str(input('please enter your name: '))
while newPlayer.setName(nameEntry):
print('Invalid Entry!')
print(title,end=' ')
nameEntry = str(input('please enter your name: '))
if identity == 'play1':
symbolEntry = str(input('O or X: '))
while newPlayer.setSymbol(symbolEntry):
print('Invalid Entry!')
symbolEntry = str(input('O or X: '))
symbols.remove(symbolEntry.upper())
else:
newPlayer.setSymbol(symbols[0])
players[identity] = newPlayer
return players
def gameplay(players):
'''Provides turn system for a Tic Tac Toe Game.'''
if 'comp' not in players:
print('Beginning Game, {} vs {}'.format(players['play1'].getName(),players['play2'].getName()))
else:
print('Beginning Game, {} vs the Computer'.format(players['play1'].getName()))
print("Win Two Matches In a Row to Be Victorious")
board = ticBoard(mode='blank')
turnList = list(players.keys())
firstTurn = random.choice(turnList)
#firstTurn = 'comp'
turn = firstTurn
selected = []
while True:
board.draw()
if turn != 'comp':
print(players[turn].getName(),'please select a space.')
selection = str(input('Space: ')).upper()
if not d.active or selection not in ["RESET", "END"]:
errorCheck = board.checkEntry(selection,selected)
while not errorCheck['valid']:
errorMessage = errorCheck['message'].format(selection)
print(errorMessage)
print(players[turn].getName(),'please select a space.')
selection = str(input('Space: ')).upper()
errorCheck = board.checkEntry(selection,selected)
if selection == 'END':
break
else:
print('Computer Turn')
selection = players['comp'].think(board)
errorCheck = board.checkEntry(selection,selected)
print('Computer Chooses {}'.format(selection))
if selection != 'RESET' or not d.active:
board.place(players[turn].getSymbol(), errorCheck['entry'])
selected.append(selection)
if board.checkWin() and selection != 'RESET':
board.draw()
selected = []
winner = turn
loser = nextTurn(turnList, turn)
if players[winner].getMatches() == 1:
print(players[turn].getName(),end=' ')
str(input('wins!'))
players[turn].win()
players[loser].resetMatch()
players[winner].resetMatch()
break #END GAME
elif players[winner].getMatches() == 0:
print(players[turn].getName(),end=' ')
players[winner].matchWin()
players[loser].resetMatch()
str(input('won a match! Beginning next round.'))
if 'comp' in players:
players['comp'].clearStrategy()
board.clear()
turn = loser
firstTurn = loser
else:
if len(board.blankSpaces()) == 0 or selection == 'RESET':
board.draw()
str(input('Draw! Beginning next round.'))
if 'comp' in players:
players['comp'].clearStrategy()
players[turn].resetMatch()
players[nextTurn(turnList, turn)].resetMatch()
board.clear()
firstTurn = nextTurn(turnList, firstTurn)
turn = firstTurn
selected = []
else:
turn = nextTurn(turnList, turn)
try:
print()
print('\t\tCurrent Score\n')
print('\t'+players[winner].getName()+'\t\t\t'+str(players[winner].getScore()))
print('\t'+players[loser].getName()+'\t\t\t'+str(players[loser].getScore()))
print('\n==========================================\n')
except:
print('\tNo Scores to Show.\n')
return players
mainMenu() #Load Main Menu First
activeDebug = False
TicTacToe(activeDebug) #Begin Program
