def solve(self, game_map, player_info, came_from=[], depth=0):
agent = MinMax()
result = {}
result['anything-that-unsolved'] = []
best = -10000
action = None
parent = None
if len(came_from):
for j in came_from:
state = j
for i in self.children:
v = agent.forward(game_map, state['pinfo'], i, depth)
if v['progression']:
result['anything-that-unsolved'].append({'pinfo':
v['player_info'],
'action': i})
if v['additional_score'] > best:
best = v['additional_score']
action = i
parent = j
result['best'] = {'points': best,
'parent': parent,
'action': action
}
else:
for i in self.children:
v = agent.forward(game_map, player_info, i)
if v['progression']:
result['anything-that-unsolved'].append({'pinfo':
v['player_info'],
'action': i})
if v['additional_score'] > best:
best = v['additional_score']
action = i
result['best'] = {'points': best,
'parent': None,
'action': action
}
return result
def getAction(self):
bestMove = ""
with chess.polyglot.open_reader("bookfish.bin") as reader:
for entry in reader.find_all(self.board):
bestMove = entry.move.__str__()
break
#If the try succeed we can use bookfish, else we use min max with aplha beta
try:
move = chess.Move.from_uci(bestMove)
method = "(Move by Bookfish)"
except:
move = MinMax.minimaxRoot(3, self.board, True)
method = "(Move by Min Max and Alpha Beta pruning"
#Player
if (self.turnId % 2 == 0):
action = input("Donner une action à réaliser (ex:" + str(move) +
") : ")
while (self.moveEstLegal(action) == False):
print("L'action n'est pas autorisée, veuillez recommencer")
action = input("Donner une action à réaliser (ex:" +
str(move) + ") : ")
return chess.Move.from_uci(action)
else:
print(self.nameAI + " a joue " + str(move), method)
return move
def test_basics( dump_vcd ):
# Test vectors
test_vectors = [
# -- in -- -- out --
[ 4, 3, 3, 4 ],
[ 9, 6, 6, 9 ],
[ 12, 16, 12, 16 ],
[ 12, 16, 12, 16 ],
]
# Instantiate and elaborate the model
model = MinMax()
model.vcd_file = dump_vcd
model.elaborate()
# Function to set the inputs on the model
def tv_in( model, test_vector ):
model.in0.value = test_vector[0]
model.in1.value = test_vector[1]
# Function to verify the outputs from the model
def tv_out( model, test_vector ):
if test_vector[2] != '?':
assert model.min.value == test_vector[2]
if test_vector[3] != '?':
assert model.max.value == test_vector[3]
# Create and run the test simulation
sim = TestVectorSimulator( model, test_vectors, tv_in, tv_out )
sim.run_test()
def test_basics(dump_vcd):
# Test vectors
test_vectors = [
# -- in -- -- out --
[4, 3, 3, 4],
[9, 6, 6, 9],
[12, 16, 12, 16],
[12, 16, 12, 16],
]
# Instantiate and elaborate the model
model = MinMax()
model.vcd_file = dump_vcd
model.elaborate()
# Function to set the inputs on the model
def tv_in(model, test_vector):
model.in0.value = test_vector[0]
model.in1.value = test_vector[1]
# Function to verify the outputs from the model
def tv_out(model, test_vector):
if test_vector[2] != '?':
assert model.min.value == test_vector[2]
if test_vector[3] != '?':
assert model.max.value == test_vector[3]
# Create and run the test simulation
sim = TestVectorSimulator(model, test_vectors, tv_in, tv_out)
sim.run_test()
def IAvsIA():
board = chess.Board()
display(SVG(chess.svg.board(board=board)))
print("")
while not (board.is_game_over()):
moves = board.legal_moves
#It look if the best_move function has a move to push
#If not, we use alpha-beta method
if best_move(board) == "Nothing":
move = MinMax.minimaxRoot(3, board, True)
line.append(move)
board.push(move)
display(SVG(chess.svg.board(board=board, lastmove=move)))
print("")
#If there is a move from polyglot, we push it
elif best_move(board) in moves:
moveToPush = best_move(board)
line.append(moveToPush)
board.push(moveToPush)
display(SVG(chess.svg.board(board=board, lastmove=moveToPush)))
print("")
#We look after every move if the game is over in order to end it
if board.is_game_over():
print("The game is over")
print(board.result())
game.headers["Result"] = board.result()
###Game saving ###
game.add_line(line)
new_pgn = open("D:/Polytech/FI 3/Proj/gitTheo2.0/savedGames.pgn",
"a",
encoding="utf-8")
exporter = chess.pgn.FileExporter(new_pgn)
game.accept(exporter)
new_pgn.close()
def getAction(self):
bestMove = ""
with chess.polyglot.open_reader("bookfish.bin") as reader:
for entry in reader.find_all(self.board):
bestMove = entry.move.__str__()
break
#If the try succeed we can use bookfish, else we use min max with aplha beta
try:
move = chess.Move.from_uci(bestMove)
method = "(Move by Bookfish)"
except:
move = MinMax.minimaxRoot(3, self.board, True)
method = "Move by Min Max and Alpha Beta pruning"
#Player
if (self.turnId % 2 == 0):
print(self.nameAI1 + " a joue " + str(move), method)
return move
else:
print(self.nameAI2 + " a joue " + str(move), method)
return move
def new_bot_logic(self):
agent = MinMax()
moves = [i for i in Commands]
tree = BFTree(moves)
# new new bot login
c = copy.deepcopy(self.player_info)
result = tree.solve(self.map
, c) # <-- soup
r = 1
while len(result['anything-that-unsolved']):
temp = result['anything-that-unsolved']
result = tree.append_result(result
, BFTree(moves).solve(self.map, None, result['anything-that-unsolved']), r)
r += 1
result['anything-that-unsolved'] = [i for i in result['anything-that-unsolved'] if not i in temp]
#print(result["best"]["action"])
#print("{}|{}".format(result, i))
#self.command = Commands.NOTHING.value
self.command = result["best"]["action"]
return self.command
class methods:
def __init__(self, fps, clockObject, surface, font, bars, windowsize):
self.fps = fps
self.clock = clockObject
self.surface = surface
self.font = font
self.bars = bars
self.windowsize = windowsize
def get_array(self, length, mode=0):
arr = list(range(length))
if not mode:
random.shuffle(arr)
elif mode == 2:
arr = arr[::-1]
elif mode == 3:
for i in range(length - 1):
if random.randint(0, 10) < 8:
tmp = random.randint(4, 15)
try:
arr[i], arr[i + tmp] = arr[i + tmp], arr[i]
except:
pass
return arr
def setup(self, length, mode=0):
self.array = self.get_array(length, mode)
self.display = Display(self.windowsize[0] / length, self.windowsize,
self.surface, self.font)
self.accesses = 0
self.comparisons = 0
setattr(self.display, "bars", self.bars)
bubble = lambda self: Bubble(self.array, self.display, self.clock, self.fps
).main()
quicksort = lambda self: Quicksort(self.array, self.display, self.clock,
self.fps).main()
selection = lambda self: Selection(self.array, self.display, self.clock,
self.fps).main()
cocktail = lambda self: Cocktail(self.array, self.display, self.clock, self
.fps).main()
bogo = lambda self: Bogo(self.array, self.display, self.clock, self.fps
).main()
oddeven = lambda self: Oddeven(self.array, self.display, self.clock, self.
fps).main()
shell = lambda self: Shell(self.array, self.display, self.clock, self.fps
).main()
comb = lambda self: Comb(self.array, self.display, self.clock, self.fps
).main()
insertion = lambda self: Insertion(self.array, self.display, self.clock,
self.fps).main()
mergetd = lambda self: MergeTD(self.array, self.display, self.clock, self.
fps).main()
radixlsd = lambda self: RadixLSD(self.array, self.display, self.clock, self
.fps).main()
counting = lambda self: Counting(self.array, self.display, self.clock, self
.fps).main()
cycle = lambda self: Cycle(self.array, self.display, self.clock, self.fps
).main()
heap = lambda self: Heap(self.array, self.display, self.clock, self.fps
).main()
circle = lambda self: Circle(self.array, self.display, self.clock, self.fps
).main()
gnome = lambda self: Gnome(self.array, self.display, self.clock, self.fps
).main()
binaryinsertion = lambda self: BinaryInsertion(
self.array, self.display, self.clock, self.fps).main()
pancake = lambda self: Pancake(self.array, self.display, self.clock, self.
fps).main()
permutation = lambda self: Permutation(self.array, self.display, self.
clock, self.fps).main()
strand = lambda self: Strand(self.array, self.display, self.clock, self.fps
).main()
bucket = lambda self: Bucket(self.array, self.display, self.clock, self.fps
).main()
minmax = lambda self: MinMax(self.array, self.display, self.clock, self.fps
).main()
mergebu = lambda self: MergeBU(self.array, self.display, self.clock, self.
fps).main()
bitonic = lambda self: Bitonic(self.array, self.display, self.clock, self.
fps).main()
stooge = lambda self: Stooge(self.array, self.display, self.clock, self.fps
).main()
smooth = lambda self: Smooth(self.array, self.display, self.clock, self.fps
).main()
quick3 = lambda self: Quick3(self.array, self.display, self.clock, self.fps
).main()
def game(self):
self.deal_cards()
self.main_card = self.deck.get_first_card()
self.first, self.second = self.random_starter(self.player,
self.computer)
mm = None
while True:
mc = MC.MonteCarlo(self, self.first.isComputer)
if self.first.isComputer:
if self.deck.check_if_deck_empty():
if mm is None:
comp = self.first.current_cards
player = self.second.current_cards
mm = MM(player, comp, self.main_card)
card_rand = mm.find_best().card
else:
if len(self.first.current_cards) != 1:
card_rand = mm.find_best().card
else:
card_rand = self.first.current_cards[0]
else:
card_rand = mc.MC_random(self.iteration)
index = -1
for n, card in enumerate(self.first.current_cards):
if card.color == card_rand.color:
if card.power == card_rand.power:
index = n
card1_playing = self.first.throw_card(int(index + 1))
self.first.card_down = card1_playing
print("")
print(self.first.name + " played: " + str(card1_playing))
print("")
player2_pick = input("It's " + self.second.name +
" turn to play,\n(Main card is " +
str(self.main_card) +
") select number between 1 and " +
str(len(self.second.current_cards)) +
",\n" + str(self.second.current_cards) +
"\nwhich card in deck you want to play: ")
while int(player2_pick) < 1 or int(player2_pick) > len(
self.second.current_cards):
print("")
player2_pick = input(
"You have to select number between 1 and " +
str(len(self.second.current_cards)) + ",\n" +
str(self.second.current_cards) +
" \nwhich card in deck you want to play: ")
card2_playing = self.second.throw_card(int(player2_pick))
if mm is not None and self.deck.check_if_deck_empty() and len(
self.second.current_cards) != 1:
mm.enemy_move(card2_playing)
print("")
print(self.second.name + " played: " + str(card2_playing))
print("")
self.second.card_down = card2_playing
else:
player1_pick = input(
"It's " + self.first.name +
" turn to play,\n(Main card is " + str(self.main_card) +
") select number between 1 and " +
str(len(self.second.current_cards)) + ",\n" +
str(self.first.current_cards) +
" \nwhich card in deck you want to play: ")
while int(player1_pick) < 1 or int(player1_pick) > len(
self.first.current_cards):
print("")
player1_pick = input(
"You have to select number between 1 and " +
str(len(self.second.current_cards)) + ",\n" +
str(self.first.current_cards) +
" \nwhich card in deck you want to play: ")
card1_playing = self.first.throw_card(int(player1_pick))
self.first.card_down = card1_playing
print("")
print(self.first.name + " played: " + str(card1_playing))
print("")
if self.deck.check_if_deck_empty():
if mm is None:
comp = self.second.current_cards
player = self.first.current_cards
mm = MM(player, comp, self.main_card, card1_playing)
else:
if len(self.first.current_cards) != 0:
mm.enemy_move(card1_playing)
if len(self.second.current_cards) != 1:
card_rand = mm.find_best().card
else:
card_rand = self.second.current_cards[0]
else:
card_rand = mc.MC_random(self.iteration)
index = -1
for n, card in enumerate(self.second.current_cards):
if card.color == card_rand.color:
if card.power == card_rand.power:
index = n
card2_playing = self.second.throw_card(int(index + 1))
self.second.card_down = card2_playing
print("")
print(self.second.name + " played: " + str(card2_playing))
print("")
if heur.check_cards(card1_playing, card2_playing, self.main_card):
print(self.first.name + " win the turn.")
self.first.add_to_loot(card1_playing, card2_playing)
print(self.first.count_score() + "\n\n")
else:
print(self.second.name + " win the turn.")
self.second.add_to_loot(card1_playing, card2_playing)
print(self.second.count_score() + "\n\n")
tmp = self.first
self.first = self.second
self.second = tmp
self.used_cards.append(card1_playing)
self.used_cards.append(card2_playing)
if self.deck.check_if_deck_empty() is False:
card1, card2 = self.deck.deal_cards_on_turn()
self.first.pick_up_card(card1)
self.second.pick_up_card(card2)
if self.second.check_hand():
break
print("\n\n")
print(self.first.name + " has collected " + self.first.count_score() +
" points.")
print(self.second.name + " has collected " +
self.second.count_score() + " points.")
print("\n")
if self.first.score > self.second.score:
print(self.first.name +
" has won the game because he collected more points!")
elif self.first.score < self.second.score:
print(self.second.name +
" has won the game because he collected more points!")
else:
print("Game has finished with tied score!")
from board import board
from move import move
from MinMax import MinMax
playboard = board()
player = int(raw_input("Player colour? (1=White, 2=Black)"))
print "Player is %s; computer is %s"%("Black" if player == 2 else "White",
"White" if player == 2 else "Black")
level = int(raw_input("Computer level? (1-?)"))
computer = MinMax(level, 1 if player == 2 else 2)
turn_token = 1
while 1:
playboard.display()
print "Score: %d"%playboard.score()
if turn_token == player:
move_object = None
while move_object == None:
move_string = raw_input("%s move? (ROW, COLUMN or ROW, COLUMN, TAKE_ROW, TAKE_COLUMN) "%
("White" if (turn_token == 1) else "Black"))
move_object = move(turn_token, string = move_string)
else:
move_object = computer.move(playboard)
turn_token = 2 if (turn_token == 1) else 1
playboard.move(move_object)
def __init__(self, playerID, difficulty):
self.ID = playerID
self.diff = difficulty
self.MM = MinMax(self.ID, self)
class TTTMinMax(Player):
def __init__(self, playerID, difficulty):
self.ID = playerID
self.diff = difficulty
self.MM = MinMax(self.ID, self)
def readyPlayer(self):
pass
def queryAction(self, state):
print("Beginning MinMax.")
best = self.MM.MinMaxGo(None, state, self.diff)
# print("Best: ", best)
print("Best: ", best[0])
return best[0]
# Heuristic used to evaluate a state.
def evaluate(self, state):
# print("Evaluating state.")
result = state.gameover()
# print("Result: " + str(state.gameover()))
if result == -1: # Game not over
# Count number of possible 3s in a row to get
score = 0
# Go through rows
for i in range(0, 3):
ours, theirs, neither = 0, 0, 0
# print("row " + str(i))
for j in range(0, 3):
if state.board[i][j] == 0:
neither += 1
elif state.board[i][j] == self.ID:
ours += 1
else:
theirs += 1
# possible results
# print(str(ours) + " " + str(theirs) + " " + str(neither))
score += self.singleScore(ours, theirs, neither)
# print("Score after rows: " + str(score))
# Go through columns
for i in range(0, 3):
ours, theirs, neither = 0, 0, 0
# print("column " + str(i))
for j in range(0, 3):
if state.board[j][i] == 0:
neither += 1
elif state.board[j][i] == self.ID:
ours += 1
else:
theirs += 1
# possible results
# print(str(ours) + " " + str(theirs) + " " + str(neither))
score += self.singleScore(ours, theirs, neither)
# print("Score after cols: " + str(score))
# print("First diagonal")
ours, theirs, neither = 0, 0, 0
# Diagonal UL to DR
for i in range(0, 3):
if state.board[i][i] == 0:
neither += 1
elif state.board[i][i] == self.ID:
ours += 1
else:
theirs += 1
# possible results
# print(str(ours) + " " + str(theirs) + " " + str(neither))
score += self.singleScore(ours, theirs, neither)
# print("Second diagonal")
ours, theirs, neither = 0, 0, 0
# Diagonal UR to DL
for i in range(0, 3):
if state.board[i][2 - i] == 0:
neither += 1
elif state.board[i][2 - i] == self.ID:
ours += 1
else:
theirs += 1
# possible results
score += self.singleScore(ours, theirs, neither)
# print("Score after diags (Final): " + str(score))
return score
elif result == 0: # Tie
return 0
elif result == self.ID:
return 500
else:
return -500
def singleScore(self, ours, theirs, neither):
score = 0
if ours == 1 and neither == 2:
score += 1
elif ours == 2 and neither == 1:
score += 2
elif theirs == 1 and neither == 2:
score -= 1
elif theirs == 2 and neither == 1:
score -= 2
return score
def equals(self, arg):
if (arg.ID == self.ID):
return True
return False
def MANvsIA():
board = chess.Board()
display(SVG(chess.svg.board(board=board)))
while not (board.is_game_over()):
moves = board.legal_moves
#The MAN start everytime
man_move = chess.Move.from_uci(input("your move : "))
if man_move in moves:
board.push(man_move)
line.append(man_move)
display(SVG(chess.svg.board(board=board, lastmove=man_move)))
else:
while man_move not in moves:
print("Illegal move, please try an other one")
print("Here is the list of legal move")
for move in board.legal_moves:
print(move)
man_move = chess.Move.from_uci(input("your move : "))
board.push(man_move)
line.append(man_move)
display(SVG(chess.svg.board(board=board, lastmove=man_move)))
#We look after every move if the game is over in order to end it
if board.is_game_over():
print("The game is over")
print(board.result())
game.headers["Result"] = board.result()
print("")
#Now it's IA turns
moves = board.legal_moves
#It look if the best_move function has a move to push
#If not, we use alpha-beta method
if best_move(board) == "Nothing":
move = MinMax.minimaxRoot(3, board, True)
line.append(move)
board.push(move)
display(SVG(chess.svg.board(board=board, lastmove=move)))
print("")
#If there is a move from polyglot, we push it
elif best_move(board) in moves:
moveToPush = best_move(board)
line.append(moveToPush)
board.push(moveToPush)
display(SVG(chess.svg.board(board=board, lastmove=moveToPush)))
print("")
#We look after every move if the game is over in order to end it
if board.is_game_over():
print("The game is over")
print(board.result())
game.headers["Result"] = board.result()
print("")
###Game saving ###
game.add_line(line)
new_pgn = open("D:/Polytech/FI 3/Proj/gitTheo2.0/savedGames.pgn",
"a",
encoding="utf-8")
exporter = chess.pgn.FileExporter(new_pgn)
game.accept(exporter)
new_pgn.close()
def test():
'currently no error checking for valid user moves'
mm = MinMax()
board = mm.init_board()
player = True
while not mm.game_over(board):
if player: # black - AI
print mm.generate_black_moves(board)
mm.minmax(board, 2, False) # don't know why False
move = mm.BEST_MOVE
board = mm.move_black(board, *move)
mm.print_board(board)
player = False
else:
print mm.generate_white_moves(board)
i = int(raw_input("Enter piece i: "))
j = int(raw_input("Enter piece j: "))
i_new = int(raw_input("Enter new i: "))
j_new = int(raw_input("Enter new j: "))
board = mm.move_white(board, (i, j), (i_new, j_new))
mm.print_board(board)
player = True
def elaborate_logic(s):
#---------------------------------------------------------------------
# Stage A->B pipeline registers
#---------------------------------------------------------------------
s.reg_AB = [Reg(16) for x in range(4)]
s.connect(s.reg_AB[0].in_, s.in_[0])
s.connect(s.reg_AB[1].in_, s.in_[1])
s.connect(s.reg_AB[2].in_, s.in_[2])
s.connect(s.reg_AB[3].in_, s.in_[3])
#---------------------------------------------------------------------
# Stage B combinational logic
#---------------------------------------------------------------------
s.cmp_B0 = m = MinMax()
s.connect_dict({
m.in0: s.reg_AB[0].out,
m.in1: s.reg_AB[1].out,
})
s.cmp_B1 = m = MinMax()
s.connect_dict({
m.in0: s.reg_AB[2].out,
m.in1: s.reg_AB[3].out,
})
#---------------------------------------------------------------------
# Stage B->C pipeline registers
#---------------------------------------------------------------------
s.reg_BC = [Reg(16) for x in range(4)]
s.connect(s.reg_BC[0].in_, s.cmp_B0.min)
s.connect(s.reg_BC[1].in_, s.cmp_B0.max)
s.connect(s.reg_BC[2].in_, s.cmp_B1.min)
s.connect(s.reg_BC[3].in_, s.cmp_B1.max)
#---------------------------------------------------------------------
# Stage C combinational logic
#---------------------------------------------------------------------
s.cmp_C0 = m = MinMax()
s.connect_dict({
m.in0: s.reg_BC[0].out,
m.in1: s.reg_BC[2].out,
})
s.cmp_C1 = m = MinMax()
s.connect_dict({
m.in0: s.reg_BC[1].out,
m.in1: s.reg_BC[3].out,
})
s.cmp_C2 = m = MinMax()
s.connect_dict({
m.in0: s.cmp_C0.max,
m.in1: s.cmp_C1.min,
})
# Connect to output ports
s.connect(s.cmp_C0.min, s.out[0])
s.connect(s.cmp_C2.min, s.out[1])
s.connect(s.cmp_C2.max, s.out[2])
s.connect(s.cmp_C1.max, s.out[3])
