class Gomoku:
def __init__(self):
self.player1 = Policy("X")
self.AI_Sec = AI("O")
self.board = Board()
self.computer = Policy(self.AI_Sec.shape)
# self is object itself (in this case gomoku)
# capitalize objects and classes
def play(self):
while True:
turn_x = input("Player 1 turn x: ")
turn_y = input("Player 1 turn y: ")
while not (self.player1.CheckLegal(self.board, int(turn_x),
int(turn_y))):
print("Please type again")
turn_x = input("Player 1 turn x: ")
turn_y = input("Player 1 turn y: ")
self.player1.MakeMove(self.board, int(turn_x), int(turn_y))
if self.player1.checkWin(self.board, int(turn_x), int(turn_y)):
print("Player 1 wins")
return
#turn_x = input("Player 2 turn x: ")
#turn_y = input("Player 2 turn y: ")
# while not (self.player2.CheckLegal(self.board, int(turn_x), int(turn_y))):
#turn_x = input("Player 2 turn x: ")
#turn_y = input("Player 2 turn y: ")
computerMove = self.AI_Sec.findBestMove(self.board)
x, y = computerMove[0], computerMove[1]
print(x)
print(y)
self.computer.MakeMove(self.board, x, y)
if self.computer.checkWin(self.board, x, y):
print("Computer wins")
return
class TicTacToe:
def __init__(self):
self.player1 = Policy("X")
self.AI_Sec = AI("O")
self.board = Board()
self.computer = Policy(self.AI_Sec.computerShape)
def play(self):
while True:
boardStatus = self.board.DrawBoard()
print(boardStatus)
turn_x = input("Player 1 turn x: ")
turn_y = input("Player 1 turn y: ")
while not (self.player1.CheckLegal(self.board, int(turn_x),
int(turn_y))):
print("Please type again")
turn_x = input("Player 1 turn x: ")
turn_y = input("Player 1 turn y: ")
self.player1.MakeMove(self.board, int(turn_x), int(turn_y))
if self.player1.checkWin(self.board, int(turn_x), int(turn_y)):
print("Player 1 wins")
return
computerMove = self.AI_Sec.findBestMove(self.board)
x, y = computerMove[0], computerMove[1]
print("The x-cord: " + str(x))
print("The y-cord: " + str(y))
self.computer.MakeMove(self.board, x, y)
if self.computer.checkWin(self.board, x, y):
print("Computer wins")
return
if self.board.isFull():
print("Tie!")
return
class AI:
def __init__(self, Computer):
self.shape = Computer
self.computer = Policy(self.shape)
self.player = Policy("X")
def Opponent(self):
if self.shape == "X":
return "O"
return "X"
# Check if there is any spaces left on board
def moveLeft(self, board):
for i in range(9):
for j in range(9):
if board.config[i][j] == 0:
return True
return False
# Check if the maxPlayer or minPlayer win or not
def Evaluate(self, board, maxPlayer, x, y):
if maxPlayer:
if self.computer.checkWin(board, x, y):
return 10
else:
if self.player.checkWin(board, x, y):
return -10
return 0
#
def MiniMax(self, board, depth, maxPlayer, alpha, beta, x, y, Score):
score = self.Evaluate(board, not (maxPlayer), x, y)
# print("board")
# print(board.config)
# print(depth)
if depth == 4:
return Score
if score == 10:
#print("The maxPlayer has won")
#print(score - depth)
return score - depth
elif score == -10:
#print("The minPlayer has won")
# print(score)
#print(score + depth)
return score + depth
if self.moveLeft(board) == False:
#print("The board is full")
return 0
if maxPlayer:
best = -10000000
for i in range(9):
for j in range(9):
if board.config[i][j] == 0:
board.config[i][j] = self.shape
score = self.MiniMax(board,
depth + 1,
not (maxPlayer),
alpha,
beta,
i,
j,
Score=score)
best = max(best, score)
alpha = max(alpha, best)
board.config[i][j] = 0
if beta <= alpha:
break
return best
else:
best = 10000000
for i in range(9):
for j in range(9):
if board.config[i][j] == 0:
board.config[i][j] = "X"
score = self.MiniMax(board,
depth + 1,
not (maxPlayer),
alpha,
beta,
i,
j,
Score=score)
best = min(best, score)
beta = min(beta, best)
board.config[i][j] = 0
if beta <= alpha:
break
return best
def findBestMove(self, board):
bestVal = -1000
bestCol = -1
bestRow = -1
Score = int()
# print("board")
# print(board.config)
# print(self.Opponent())
for x in range(9):
for y in range(9):
if board.config[x][y] == 0:
board.config[x][y] = self.shape
# print("before")
# print(board.config)
# print(x)
# print(y)
currentVal = self.MiniMax(board, 0, False, -math.inf,
math.inf, x, y, Score)
board.config[x][y] = 0
# print("after")
# print(board.config)
# print(x)
# print(y)
# print("Current Val")
# print(currentVal)
print(currentVal)
if currentVal > bestVal:
bestVal = currentVal
bestRow = x
bestCol = y
# print("Final")
# print(board.config)
# print(x)
# print(y)
print("the best value: " + str(bestVal))
print("computer choose the row: " + str(bestRow))
print("computer choose the column: " + str(bestCol))
# print(board.config)
return [bestRow, bestCol]
def computerMove(self, board, x, y):
# move = self.findBestMove(board)
# x, y = move[0], move[1]
# print("x,y")
# print(x)
# print(y)
# print(board.config)
self.computer.MakeMove(board, x, y)
# Check if the computer win
def isWin(self, board, x, y):
return self.computer.checkWin(board, x, y)
class AI:
def __init__(self, Computer):
self.shape = Computer
self.computer = Policy(self.shape)
def Opponent(self):
if self.shape == "X":
return "O"
return "X"
# Check if there is any spaces left on board
def moveLeft(self, board):
for i in range(15):
for j in range(15):
if board.config[i][j] == 0:
return True
return False
# Check if the maxPlayer or minPlayer win or not
def Evaluate(self, board, maxPlayer, x, y):
if maxPlayer:
if self.computer.checkWin(board, x, y):
return 10
else:
if self.computer.checkWin(board, x, y):
return -10
return 0
def MiniMax(self, board, depth, maxPlayer, x, y):
score = self.Evaluate(board, maxPlayer, x, y)
# print(score)
if score == 10:
# print("The maxPlayer has won") # checking cast if the computer won
return score - depth
elif score == -10:
# checking the cast if the player won
#print("The minPlayer has won")
return score + depth
if self.moveLeft(board): #
#print("The board is full")
return 0
if maxPlayer:
best = -1000000
for x in range(15):
for y in range(15):
# if board.config[x][y] == 0:
if self.computer.CheckLegal(board, x, y):
board.config[x][y] = self.shape
score = self.MiniMax(
board, depth + 1, not(maxPlayer), x, y)
if score > best:
best = score
board.config[x][y] = 0
return best
else:
best = 10000000
for i in range(15):
for j in range(15):
# if board.config[i][j] == 0:
if self.computer.CheckLegal(board, x, y):
board.config[i][j] = self.Opponent()
score = self.MiniMax(
board, depth + 1, not(maxPlayer), i, j)
if score < best:
best = score
board.config[i][j] = 0
return best
# Finding the best move
def findBestMove(self, board):
bestVal = -10000
bestCol = -1
bestRow = -1
for x in range(15):
for y in range(15):
currentVal = self.MiniMax(board, 0, True, x, y)
if currentVal > bestVal:
bestVal = currentVal
bestRow = x
bestCol = y
#print("the best value: " + str(bestVal))
#print("computer choose the row: " + str(bestRow))
#print("computer choose the column: " + str(bestCol))
return [bestRow, bestCol]
# Computer makes a move
def computerMove(self, board):
move = self.findBestMove(board)
x, y = move[0], move[1]
# Check if the computer win
def isWin(self, board, x, y):
return self.computer.checkWin(board, x, y)
class AI:
def __init__(self, computerShape):
self.computerShape = computerShape
self.computer = Policy(self.computerShape)
self.humanShape = "X"
self.human = Policy(self.humanShape)
self.point = {"Computer": 10, "Human": -10, "Tie": 0}
def moveLeft(self, board):
return not (board.isFull())
def validMoves(self, board):
moves = []
for i in range(board.row):
for j in range(board.column):
if board.config[i][j] == 0:
pass
pass
def Win(self, shape):
winner = Policy(shape)
return winner.checkWin(board, x, y)
def Evaluate(self, board, isMaximizing, x, y):
if isMaximizing:
if self.computer.checkWin(board, x, y):
return "Computer"
else:
if self.human.checkWin(board, x, y):
return "Human"
return "Tie"
def miniMax(self, board, depth, isMaximizing, x, y):
score = self.point[self.Evaluate(board, not (isMaximizing), x, y)]
if score == 10:
return score - depth
elif score == -10:
return score + depth
if self.moveLeft(board) == False:
return 0
if isMaximizing:
bestScore = -math.inf
for x in range(board.row):
for y in range(board.column):
if board.config[x][y] == 0:
board.config[x][y] = self.computerShape
score = self.miniMax(board, depth + 1,
not (isMaximizing), x, y)
bestScore = max(score, bestScore)
board.config[x][y] = 0
return bestScore
else:
bestScore = math.inf
for i in range(board.row):
for j in range(board.column):
if board.config[i][j] == 0:
board.config[i][j] = self.humanShape
score = self.miniMax(board, depth + 1,
not (isMaximizing), i, j)
bestScore = min(score, bestScore)
board.config[i][j] = 0
return bestScore
def findBestMove(self, board):
bestScore = -math.inf
row = int()
column = int()
for i in range(board.row):
for j in range(board.column):
pos = board.config[i][j]
if pos == 0:
board.config[i][j] = self.computerShape
currentScore = self.miniMax(board, 0, False, i, j)
#print("Computer evals this move: " + str(currentScore))
board.config[i][j] = 0
if currentScore > bestScore:
row = i
column = j
bestScore = currentScore
return [row, column]
def Win(self, shape):
winner = Policy(shape)
return winner.checkWin(board, x, y)
