def interactiveGame(currentGame, depth):
# Fill me in
#sys.exit('Interactive mode is currently not implemented')
while currentGame.pieceCount != 42:
if currentGame.currentTurn == 1:
move = input('enter some number in the range of 1-7::')
if move > 7 or move < 1:
print 'Invalid move'
continue
if not currentGame.playPiece(move - 1):
print 'No space left in this column..'
continue
try:
currentGame.gameFile = open('human.txt', 'w')
except:
sys.exit('file not found')
postmoveupdate(currentGame, move - 1)
elif currentGame.pieceCount != 42:
search = Minimax(currentGame, depth)
move = search.decision()
result = currentGame.playPiece(move)
try:
currentGame.gameFile = open("computer.txt", 'w')
except:
sys.exit('file not found')
postmoveupdate(currentGame, move)
currentGame.gameFile.close()
if currentGame.player1Score == currentGame.player2Score:
print 'It is a draw'
elif currentGame.player2Score < currentGame.player1Score:
print 'Human wins'
else:
print 'AI rampage'
def interactiveGame(currentGame, depth):
while currentGame.pieceCount != 42:
if currentGame.currentTurn == 1:
nextMove = input(
"Enter the column between [1-7] where you want to insert your next coin : "
)
if not currentGame.playPiece(nextMove - 1):
print "This column is full!"
continue
if nextMove < 1 or nextMove > 7:
print "Enter a column between [1-7]!"
currentGame.gameFile = open("Human.txt", 'w')
gameState(currentGame, nextMove - 1)
elif currentGame.pieceCount != 42:
minimaxTree = Minimax(currentGame, depth)
move = minimaxTree.Decision()
result = currentGame.playPiece(move)
currentGame.gameFile = open("Computer.txt", 'w')
gameState(currentGame, move)
currentGame.gameFile.close()
if currentGame.player1Score > currentGame.player2Score:
print "User won"
elif currentGame.player2Score > currentGame.player1Score:
print "Computer won"
else:
print "Game Drawn"
def aiPlay(currentGame, init_next, depth):
print('---------------COMPUTER TURN---------------')
#Minimax object
miniobj = Minimax(currentGame, init_next, depth)
#Result of next move(column) using minimax algorithm
dec_col = miniobj.final_decision()
#Play with result column
currentGame.playPiece(dec_col)
print('move %d: Player %d, column %d' %
(currentGame.pieceCount, currentGame.currentTurn, dec_col + 1))
# Print GameBoard
print 'Game state after move:'
currentGame.printGameBoard()
# Print Score
currentGame.countScore()
print('Score: Player 1 = %d, Player 2 = %d' %
(currentGame.player1Score, currentGame.player2Score))
try:
# open computer.txt with write mode
currentGame.gameFile = open("computer.txt", 'w')
except:
sys.exit('Error opening output file, computer.txt')
# write currentGameBoard to computer.txt
currentGame.printGameBoardToFile()
# human.txt computer.txt close
currentGame.gameFile.close()
def oneMoveGame(currentGame, depth):
if currentGame.pieceCount == 42: # Is the board full already?
print 'BOARD FULL\n\nGame Over!\n'
sys.exit(0)
tree = Minimax(currentGame, depth)
move = tree.Decision()
result = currentGame.playPiece(move)
gameState(currentGame, move)
currentGame.gameFile.close()
def oneMoveGame(currentGame,depth):
if currentGame.pieceCount == 42: # Is the board full already?
print 'BOARD FULL\n\nGame Over!\n'
sys.exit(0)
#currentGame.aiPlay() # Make a move (only random is implemented)
searchTree = Minimax(currentGame,depth)
move = searchTree.makeDecision()
result = currentGame.playPiece(move)
afterMoveOperations(currentGame,move)
currentGame.gameFile.close()
def oneMoveGame(currentGame, depth):
if currentGame.pieceCount == 42: # Is the board full already?
print 'BOARD FULL\n\nGame Over!\n'
sys.exit(0)
#currentGame.aiPlay() # Make a move (only random is implemented)
possible_moves = Minimax(currentGame, depth)
move = possible_moves.makeDecision()
currentGame.playPiece(move)
nextMove(currentGame, move)
currentGame.gameFile.close()
def computerClick():
global step
if Minimax.checkWin(playerSymbol, gameBoard):
tkinter.messagebox.showinfo("Tic-Tac-Toe", "You win!")
return
if step == 9:
tkinter.messagebox.showinfo("Tic-Tac-Toe", "Draw")
return
move = Minimax.findMove(gameBoard)
gameBoard[move] = computerSymbol
dict_b[move]["text"] = "O"
step += 1
def netplay(window,images,board,player,coupE,date,damier,scoreboard,score_noir,score_blanc):
if (date == 0) and (player == 2):
coupE = attentePremierCoup()
return netplay(window,images,board,player,coupE,1,damier,scoreboard,score_noir,score_blanc) #OnlinePlay(player,dam,coupE,1)
elif (date == 0) and (player == 1):
coupE = jouer(65)
print ('moi: 65')
Poser(6,5,1,damier)
boardupdate(window,board,images,damier,player)
return netplay(window,images,board,player,coupE,1,damier,scoreboard,score_noir,score_blanc)
if (coupE != -1):
xe = int(coupE//10)
ye = int(coupE%10)
print ('lui: ',coupE)
Poser(xe,ye,3-player,damier)
else:
print("the enemy pass")
boardupdate(window,board,images,damier,player)
noplay =np (damier,player)
if noplay[0] == 4:
return fin(-1)
coup = Minimax (damier,player)
print ('moi: ',coup)
x = int(coup//10)
y = int(coup%10)
Poser(x,y,player,damier)
noplay = np(damier,player)
if noplay[0] == 4:
return fin(coup)
boardupdate(window,board,images,damier,player)
scoreboard.itemconfigure(score_noir,text ="Joueur 1 : %d" %(noplay[1]))
scoreboard.itemconfigure(score_blanc,text ="Joueur 2 : %d" %(noplay[2]))
return netplay(window,images,board,player,jouer(coup),1,damier,scoreboard,score_noir,score_blanc)
def multiBot(self):
""" Permainan Mode 3: Bot Minimax vs Bot Minimax Local Search"""
terminalState = False
while not (terminalState):
# Masukkan mau pion ID berapa yang mau dijalankan
self.printInfo()
if (self.currentPlayer.noPlayer == 1):
print("PLAYER " + str(self.currentPlayer.noPlayer) +
" MINIMAX TURN!")
self.currentPlayer.printAllPion()
# Minimax Process
currentState = GameState.GameState(self.board,
self.currentPlayer,
self.oppositePlayer)
beforeProcess = time.time()
minimaxState, _eval = Minimax.minimax(
currentState, 3,
time.time() + self.tlimit, -math.inf, math.inf,
self.currentPlayer.noPlayer)
self.assignState(minimaxState)
deltaTime = time.time() - beforeProcess
print(f"Execution time = {deltaTime} seconds")
else:
print("PLAYER " + str(self.currentPlayer.noPlayer) +
" MINIMAX LOCAL SEARCH TURN!")
self.currentPlayer.printAllPion()
# Minimax with Local Search
currentState = GameState.GameState(self.board,
self.currentPlayer,
self.oppositePlayer)
beforeProcess = time.time()
minimaxState, _eval = Minimax.minimaxLocalSearch(
currentState, 3,
time.time() + self.tlimit, -math.inf, math.inf,
self.currentPlayer.noPlayer)
self.assignState(minimaxState)
deltaTime = time.time() - beforeProcess
print(f"Execution time = {deltaTime} seconds")
if (self.board.checkTerminalState(self.currentPlayer.noPlayer)):
terminalState = True
else:
self.nextTurn()
self.printInfo()
print("Player " + str(self.currentPlayer.noPlayer) + " win the game!")
def minimaxDecision(self):
nextBoards = self.board.nextBoardsExcludingCar(self.otherCar)
minValues = []
for nextBoard in nextBoards:
s = Minimax.minimax(nextBoard, self.carCh, 3, False)
minValues.append(s)
i = minValues.index(max(minValues))
return nextBoards[i]
def playerVsMinMax(self):
""" Permainan Mode 1: Player vs BOT Minimax """
terminalState = False
while not (terminalState):
self.printInfo()
# Giliran Player BOT Minimax
if (self.currentPlayer.noPlayer != self.hplayer):
print("PLAYER " + str(self.currentPlayer.noPlayer) +
" MINIMAX TURN!")
input("Begin minimax? ")
self.currentPlayer.printAllPion()
# Minimax process for the BOT
currentState = GameState.GameState(self.board,
self.currentPlayer,
self.oppositePlayer)
beforeProcess = time.time()
minimaxState, _eval = Minimax.minimax(
currentState, 2,
time.time() + self.tlimit, -math.inf, math.inf,
self.currentPlayer.noPlayer)
self.assignState(minimaxState)
deltaTime = time.time() - beforeProcess
print(f"Execution time = {deltaTime} seconds")
print("PLAYER " + str(self.currentPlayer.noPlayer) + " FANO")
print("PLAYER " + str(self.hplayer) + " Hello")
input("Boleh next sekarang!")
# Giliran Player Manusia
else:
print("PLAYER " + str(self.currentPlayer.noPlayer) + " TURN!")
self.currentPlayer.printAllPion()
chosenID = int(
input("Pilih Pion ID mana yang ingin dimainkan : "))
if (chosenID == 999):
self.saveGame()
possible_moves = self.currentPlayer.listAllPossibleMove(
chosenID, self.board)
for i in range(len(possible_moves)):
print(str(i + 1) + ". ", end="")
possible_moves[i].printPosisi()
chosenMove = int(
input(
"Pilih move yang diinginkan dengan memasukkan nomor : "
))
self.currentPlayer.movePion(chosenID,
possible_moves[chosenMove - 1],
self.board)
# Cek apakah sekarang merupakan kondisi terminal
if (self.board.checkTerminalState(self.currentPlayer.noPlayer)):
terminalState = True
else:
self.nextTurn()
self.printInfo()
print("Player " + str(self.currentPlayer.noPlayer) + " win the game!")
def play(self, game):
if self.color is None:
raise RuntimeError("A player cannot play without an assigned color.")
if self.color != game.currentColor:
raise RuntimeError("This player ({}) can't"
"play this turn ({}).".format(self.color,
game.currentColor))
value, move, strokes = Minimax.minimax(game, self, debug=False)
return game.play(move)
def minimaxDecisionABPruning(self):
nextBoards = self.board.nextBoardsExcludingCar(self.otherCar)
minValues = []
alpha = -float("inf")
beta = float("inf")
for nextBoard in nextBoards:
s = Minimax.minimax_pruning(nextBoard, self.carCh, 3, False, alpha, beta)
minValues.append(s)
i = minValues.index(max(minValues))
return nextBoards[i]
def play(self, game):
if self.color is None:
raise RuntimeError(
"A player cannot play without an assigned color.")
if self.color != game.currentColor:
raise RuntimeError("This player ({}) can't"
"play this turn ({}).".format(
self.color, game.currentColor))
value, move, strokes = Minimax.minimax(game, self, debug=False)
return game.play(move)
def Play(player, dam, player1, player2, gamemode):
affiche(player, dam)
if (win(dam, player, player1, player2, gamemode) == 0):
print('')
else:
return
if gamemode == 1:
if (player == 1):
coup = int(input(player1))
else:
coup = int(input(player2))
if gamemode == 4:
coup = Minimax(dam, player)
if gamemode == 5:
if player == 1:
coup = Minimax(dam, player)
else:
plyy = []
for i in range(10):
for j in range(10):
if estValide(i, j, player, dam) and dam[i][j] == 0:
plyy.append(10 * i + j)
if plyy != []:
coup = plyy[random.randint(0, len(plyy) - 1)]
if gamemode == 2:
if player == 1:
coup = int(input(player1))
else:
coup = Minimax(dam, player)
x = int(coup // 10) #Oui, la magie existe!
y = int(coup % 10)
if coup == -1:
print('aha')
else:
if coup not in range(0, 100, 1):
print("Impossible")
return Play(player, dam, player1, player2, gamemode)
if not estValide(x, y, player, dam):
print("Impossible")
return Play(player, dam, player1, player2, gamemode)
Poser(x, y, player, dam)
return Play(3 - player, dam, player1, player2, gamemode)
def play(self):
self.display()
s = in2048()
m = mm.miniMax(s)
while not self.gameover:
#op = raw_input('operator: ')
#print ("AI")
op = m.find_best_move(s, 3)
#commands = ['w','d','s','a']
#op = commands.index(op)
self.operation(op)
self.display()
def btnClick(x):
global step
if Minimax.checkWin(computerSymbol, gameBoard):
tkinter.messagebox.showinfo("Tic-Tac-Toe", "Computer wins!")
return
if dict_b[x]["text"] == " ":
dict_b[x]["text"] = playerSymbol
gameBoard[x] = 'X'
step += 1
computerClick()
else:
tkinter.messagebox.showinfo("Tic-Tac-Toe", "Button already Clicked!")
def interactiveGame(currentGame, depth):
# Fill me in
# sys.exit('Interactive mode is currently not implemented')
while not currentGame.pieceCount == 42:
if currentGame.currentTurn == 1:
userMove = input(
"Enter the column number [1-7] where you would like to play : "
)
if not 0 < userMove < 8:
print "Invalid column number!"
continue
if not currentGame.playPiece(userMove - 1):
print "This column is full!"
continue
try:
currentGame.gameFile = open("human.txt", 'w')
except:
sys.exit('Error opening output file.')
nextMove(currentGame, userMove - 1)
elif not currentGame.pieceCount == 42:
possible_moves = Minimax(currentGame, depth)
move = possible_moves.makeDecision()
currentGame.playPiece(move)
try:
currentGame.gameFile = open("comupter.txt", 'w')
except:
sys.exit('Error opening output file.')
nextMove(currentGame, move)
currentGame.gameFile.close()
if currentGame.player1Score > currentGame.player2Score:
print "Player 1 wins"
elif currentGame.player2Score > currentGame.player1Score:
print "Computer wins"
else:
print "It's a draw"
print "Thank you for playing MaxConnect4Game"
def minimaxDecision(self):
start = time.time()
nextBoards = self.board.next(self.label)
minValues = []
for nextBoard in nextBoards:
s = Minimax.minimax(nextBoard, self.label, 4, False)
minValues.append(s)
i = minValues.index(max(minValues))
end = time.time()
print(
"Time it took to make this decision with minimax without alpha-beta pruning: "
+ str(end - start))
return nextBoards[i]
def interactiveGame(currentGame,depth):
# Fill me in
# sys.exit('Interactive mode is currently not implemented')
while not currentGame.pieceCount == 42:
if currentGame.currentTurn == 1:
userMove = input("Enter the column number [1-7] where you would like to play : ")
if not 0 < userMove < 8:
print "Invalid column number!"
continue
if not currentGame.playPiece(userMove-1):
print "This column is full!"
continue
try:
currentGame.gameFile = open("human.txt", 'w')
except:
sys.exit('Error opening output file.')
afterMoveOperations(currentGame,userMove-1)
elif not currentGame.pieceCount == 42:
searchTree = Minimax(currentGame,depth)
move = searchTree.makeDecision()
result = currentGame.playPiece(move)
try:
currentGame.gameFile = open("comupter.txt", 'w')
except:
sys.exit('Error opening output file.')
afterMoveOperations(currentGame,move)
currentGame.gameFile.close()
if currentGame.player1Score > currentGame.player2Score:
print "Player 1 wins"
elif currentGame.player2Score > currentGame.player1Score:
print "Computer wins"
else:
print "It's a draw"
print "Thank you for playing MaxConnect4Game"
def minimaxDecisionABPruning(self):
start = time.time()
nextBoards = self.board.next(self.label)
minValues = []
alpha = -float("inf")
beta = float("inf")
for nextBoard in nextBoards:
s = Minimax.minimax_pruning(nextBoard, self.label, 4, False, alpha,
beta)
minValues.append(s)
i = minValues.index(max(minValues))
end = time.time()
print(
"Time it took to make this decision with minimax with alpha-beta pruning: "
+ str(end - start))
return nextBoards[i]
def choose_move(self, game):
try:
if self.type == Player.PlayerTypes.MINIMAX:
return Minimax.alpha_beta(game, Player.DEPTH, self, True,
self.get_disk())
elif self.type == Player.PlayerTypes.HUMAN:
return self.human_move(game)
elif self.type == Player.PlayerTypes.NBOARD:
pass # todo add choose move for Nboard player
elif self.type == Player.PlayerTypes.RANDOM:
return self.random_move(game)
elif self.type == Player.PlayerTypes.FOUR_BY_FOUR:
return self.four_by_four_move(game)
elif self.type == Player.PlayerTypes.TABLE:
raise ValueError("not supposed to do a move")
except Exception as e:
print("do again")
print(str(e))
return self.choose_move(game)
def minimaxMove(self):
""" Menjalankan bot Minimax pada giliran bot tersebut """
print("PLAYER " + str(self.currentPlayer.noPlayer) + " MINIMAX TURN!")
# Minimax Process
beforeProcess = time.time()
currentState = GameState.GameState(self.board, self.currentPlayer,
self.oppositePlayer)
minimaxState, _eval = Minimax.minimax(currentState, 3,
time.time() + self.tlimit,
-math.inf, math.inf,
self.currentPlayer.noPlayer)
deltaTime = time.time() - beforeProcess
self.totalTime += deltaTime
print(f"Execution time = {deltaTime} seconds")
self.assignState(minimaxState)
terminalState = False
if (self.board.checkTerminalState(self.currentPlayer.noPlayer)):
terminalState = True
return terminalState
def Play(window,board,images,damier,X,Y,scoreboard,score_noir,score_blanc):
w , h = window.winfo_screenwidth(), window.winfo_screenheight()
global player
noplay = np(damier,player)
x = Y//70
y = X//70
if estValide(x,y,player,damier):
Poser(x,y,player,damier)
player = 2
noplay = np(damier,player)
boardupdate(window,board,images,damier,1)
while (noplay[0] == 0) and (player == 2):
coup = Minimax(damier,player)
print("ai played: " , coup)
x = int(coup//10)
y = int(coup%10)
Poser(x,y,player,damier)
boardupdate(window,board,images,damier,1)
player = 1
noplay = np(damier,player)
if noplay[0] == 4:
break
elif noplay[0] == 1:
print( "skipped turn player")
player = 2
noplay = np(damier,player)
scoreboard.itemconfigure(score_noir,text ="Joueur : %d" %(noplay[1]))
scoreboard.itemconfigure(score_blanc,text ="IA : %d" %(noplay[2]))
player = 1
if noplay[0] == 4:
print("game ended")
if noplay[1] == noplay[2]:
Button(window, text = 'Egalite' , command = lambda:window.destroy()).place(x=w/2-50, y = h/2-25, width=100, height=30)
elif noplay[1] > noplay[2]:
Button(window, text = 'Victoire Joueur' , command = lambda:window.destroy()).place(x=w/2-50, y = h/2-25, width=100, height=30)
else:
Button(window, text = 'Victoire IA' , command = lambda:window.destroy()).place(x=w/2-50, y = h/2-25, width=100, height=30)
def move(self, state):
m = Minimax.Minimax(state)
best_move, value = m.bestMove(self.difficulty, state, self.color)
return best_move
def get_grid_tile(px_x, px_y):
return Vector2(px_x // 125, px_y // 125)
curr_player = GL.BLACK
is_running = True
pending_move = PendingMove(board, curr_player)
# debugging
show_mouse_moves = False
while is_running:
if curr_player == GL.RED:
start_s = time.time()
move = ALG.minimax(board, DEPTH, float('-inf'), float('inf'), True)[0]
end_s = time.time()
print('move found in ' + str(round(end_s-start_s,4)) + ' seconds')
GL.execute_move(board, move)
pending_move.switch_player()
curr_player *= -1
gm = GL.game_over(board, curr_player)
if gm:
print([None, 'Red', 'Black'][gm] + ' Won!')
is_running = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
is_running = False
break
if self.board[i]==self.board[i+2]==self.board[i+4] and self.board[i]!=".":
return True
return False
num_players= int(input('Enter the number of AI players: '))
x = Game_Board()
x.display_board
state=Minimax.State(x.board, 'X')
if num_players==1:
while True:
if x.is_empty():
player = 1
if player==1:
place = int(input("What spot would you like to mark: "))
elif player==2:
result=Minimax.minimax(state, 2, 'O')
place=result
print place
if x.mark_board(place, player)==False:
print "Invalid move, Choose again"
else:
print "Player %d has marked %d: " % (player, place)
if player==1:
state=Minimax.State(x.board, 'X')
else:
state=Minimax.State(x.board,'O')
if x.check_win():
if player==1:
x.display_board()
print "Player 1 wins!"
import Minimax
import GameState as game
best_moves = set([(0, 0), (2, 0), (0, 1)])
rootNode = game.GameState()
minimax_move = Minimax.minimax_decision(rootNode)
print("Best move choices: {}".format(list(best_moves)))
print("Your code chose: {}".format(minimax_move))
if minimax_move in best_moves:
print(
"That's one of the best move choices. Looks like your minimax-decision function worked!"
)
else:
print("Uh oh...looks like there may be a problem.")
features.append(TDLearning.getScoreFeature())
# whiteWin, blackWin = TDLearning.getWinFeatures()
# features.append(whiteWin)
# features.append(blackWin)
# features.append(TDLearning.getProtectedFeature(abgame, 1))
# features.append(TDLearning.getProtectedFeature(abgame, -1))
# features.append(TDLearning.getPushFeature(abgame, 1))
# features.append(TDLearning.getPushFeature(abgame, -1))
#features.append(TDLearning.getTurnFeature(1))
#features.append(TDLearning.getTurnFeature(-1))
minimax = Minimax.Minimax(explore=float(args["explore"]))
tdlearning = TDLearning.TDLearning(features,
step=float(args["step"]),
discount=float(args["discount"]))
TRAINING_DEPTH = 2
GAME_DEPTH = 3
print abgame
if args['weights'] != None:
tdlearning.applyWeights(
util.getPreloadedWeights("weights/" + args['weights'] + ".txt"))
tdlearning.printWeights()
if numGames > 0:
print "Training algorithm..."
if len(sys.argv) < 2:
print "Please enter the input position filename:"
input = sys.stdin.readlines()
# Take in from command line arguments
else:
input = sys.argv[1] # sys.argv[0] is this file's name (Driver.py)
# Does this input exists and is input a file (not a directory).
if os.path.exists(input) or os.path.isfile(input):
file = open(input, 'r') # open file for reading
parser = Parser.Parser(file) # construct new parser object.
(count, color, steps, board) = parser.parse() # Parse the file.
file.close()
if count == "1":
print MoveGenerator.MoveGenerator.randSetup(color)
else:
hash = Hash.Hash() # Construct a new hash
hash.calculateHashkey(
board) # Calculate the hash key for this given board.
mini = Minimax.Minimax(board, color)
res = mini.minimax(2, board, color, "", count, hash)
move = res[1].split('|')
print move[1].strip()
else:
print "File not found"
sys.exit()
def __init__(self): evaluacion=Tablero() algoritmo=Minimax() self.tablero=Tablero(evaluacion.evaluar_suma_peso) self.tablero.cargar_fichas() self.minimax=Minimax(algoritmo.minimax);
class Game: def __init__(self): evaluacion=Tablero() algoritmo=Minimax() self.tablero=Tablero(evaluacion.evaluar_suma_peso) self.tablero.cargar_fichas() self.minimax=Minimax(algoritmo.minimax); def quien_gano(self): value=self.tablero.evaluar_suma(1) if(value < 0): return "Perdiste!!!" return "Ganaste!!!" def juega_computadora(self): old_move_computadora,new_move_computadora=self.minimax.start(self.tablero) print "score : ", new_move_computadora lista, comer_move=self.tablero.comer_fichas(old_move_computadora) if(len(lista)-1==0): self.tablero.mover_ficha(old_move_computadora,new_move_computadora) lista.append(old_move_computadora) lista.append(new_move_computadora) comer_move=[] if(self.tablero.es_dama(new_move_computadora,Ficha.COMPUTADORA)): self.tablero.crear_dama(new_move_computadora, Ficha.COMPUTADORA) return lista,comer_move ''' ''' def traducir_a_index(self, move): return move.i*8+move.j%8 def juega_usuario(self,x,y): ''' debe verificar si: se comio una ficha y actualizar el tablero ''' def realizar_movimiento(self, old_move, new_move): if(self.tablero.es_valido_move(old_move,new_move)): if(self.es_dama_usuario(old_move)): #prueba una posicion self.tablero.mover_ficha(old_move, new_move) comer_move=self.tablero.get_pos_ficha_anterior(old_move,new_move) if(not self.tablero.es_duenho(comer_move, Ficha.COMPUTADORA)): comer_move=None else: comer_move=self.tablero.comer_ficha(old_move, new_move) self.tablero.mover_ficha(old_move, new_move) if(self.es_dama_usuario(new_move)): self.tablero.crear_dama(new_move) if not (comer_move==None): print self.tablero self.tablero.eliminar_ficha(comer_move) return comer_move.i*Tablero.MAX_DIM+comer_move.j%Tablero.MAX_DIM return True return False def route_valido(self, old_move, new_move): copia=self.tablero.get_copia() if(copia.es_valido_move(old_move,new_move)): return True return False def esta_bloqueada(self, move): if(self.tablero.casillas[move.i][move.j].duenho==Ficha.BLOQUEADA): return True; return False ''' verifica si una casilla esta ocupada por el duenho ''' def ocupe_casilla(self, move, duenho=Ficha.USUARIO): if(self.tablero.es_vacio(move.i, move.j) or not self.tablero.casillas[move.i][move.j].duenho==duenho): return False return True def eliminar_ficha(self, move): self.tablero.casillas[move.i][move.j]=Ficha() def es_dama_usuario(self,move): return self.tablero.es_dama(move, Ficha.USUARIO) def es_dama_computadora(self, move): return self.tablero.es_dama(move, Ficha.COMPUTADORA) def es_ficha_usuario(self,move): return self.tablero.casillas[move.i][move.j].duenho==Ficha.USUARIO def es_ficha_computadora(self, move): return self.tablero.casillas[move.i][move.j].duenho==Ficha.COMPUTADORA
def start(self):
while True:
#Evaluacion para no terminar con todos los items
#if self.interfaz.manzanas==[] or abs(len(self.user_items)-len(self.pc_items))>len(self.interfaz.manzanas):
#Evalua si el juego Termino
if self.interfaz.manzanas == []:
self.pintar_ganador()
#Eventos de tablero
#turno tablero
elif self.turno == True:
pos = self.next(self.interfaz.pos_cn)
self.crear_botones_player(pos)
#turno pc
elif self.turno == False:
minimax = Minimax(self.interfaz.pos_cn, self.interfaz.pos_cb,
self.user_items, self.pc_items,
self.interfaz.manzanas)
#mover caballo blanco
self.moves(minimax.pos_cb, False)
#cambia turno
self.turno = True
#aleatorio
#pos=self.next(self.interfaz.pos_cb)
#self.move_pc(pos)
for evento in pygame.event.get():
if evento.type == QUIT:
pygame.quit()
sys.exit()
if evento.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = evento.pos # gets mouse position
#Cuando un usuario selecciona una opcion envia la coordenada que selecciono el jugador
if self.b1.collidepoint(mouse_pos):
self.moves([int(self.b1.x / 60),
int(self.b1.y / 60)], 1)
if self.b2.collidepoint(mouse_pos):
self.moves([int(self.b2.x / 60),
int(self.b2.y / 60)], 1)
if self.b3.collidepoint(mouse_pos):
self.moves([int(self.b3.x / 60),
int(self.b3.y / 60)], 1)
if self.b4.collidepoint(mouse_pos):
self.moves([int(self.b4.x / 60),
int(self.b4.y / 60)], 1)
if self.b5.collidepoint(mouse_pos):
self.moves([int(self.b5.x / 60),
int(self.b5.y / 60)], 1)
if self.b6.collidepoint(mouse_pos):
self.moves([int(self.b6.x / 60),
int(self.b6.y / 60)], 1)
if self.b7.collidepoint(mouse_pos):
self.moves([int(self.b7.x / 60),
int(self.b7.y / 60)], 1)
if self.b8.collidepoint(mouse_pos):
self.moves([int(self.b8.x / 60),
int(self.b8.y / 60)], 1)
if self.b_reset.collidepoint(mouse_pos):
pygame.quit()
def take_turn(self, state):
decider = Minimax.Minimax(state, self.depth)
move = decider.get_best_move()
state.perform_action(move)
return move
import Minimax
import Node
estado_inicial = [['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
cont = 0
minimax = Minimax.Minimax()
root = Node.Node(estado_inicial, 9)
minimax.completar_arvore(root, 9)
resultado_minimax = minimax.minimax(root, 9, True)
print("O resultado minimax da raiz do jogo da velha é: {}".format(
resultado_minimax))
cont = minimax.cont_estados(root, 9)
print("Quantidade de estados existentes: {}".format(cont))
