def chooseBestAttribute(data, attributes, target, criterion):
# This function chooses the heuristic that must be applied in order to fulfill the
# user's request. For each criterion there's a different call. Otherwise, it throws
# an exception which stops the program execution.
data = data[:]
bestGain = 0.0
bestAttr = None
for attr in attributes:
try:
if criterion == 'gini':
gainAttr = heur.gainGini(data, attr, target)
elif criterion == 'entropy':
gainAttr = heur.gainEntr(data, attr, target)
elif criterion == 'missclass':
gainAttr = heur.gainMisclass(data, attr, target)
else:
raise Exception('No criterion with such name.')
except Exception as ex:
print ex.args
if (gainAttr >= bestGain and attr != target):
bestGain = gainAttr
bestAttr = attr
return bestAttr
def coeff_train(game):
coeff = [1, 1, 1]
old_h = H.LinearCombinationHeuristic(coeff)
pick = random.randint(0, 2)
for i in range(0, 15):
coeff[pick] += 1
new_h = H.LinearCombinationHeuristic(coeff)
pl1_score = 0
pl2_score = 0
print(coeff)
print("--------------START GAME LOOP-----------------")
for j in range(0, 10):
print("----------------PLAY START-----------------")
score = ai_vs_ai(game, new_h, old_h, 5, 5, False)
if score == 1:
pl1_score += 1
elif score == 2:
pl2_score += 2
game.reset()
if pl1_score > pl2_score:
old_h = new_h
print("PL1 wins")
else:
print("PL2 wins")
new_pick = random.randint(0, 2)
while new_pick == pick:
new_pick = random.randint(0, 2)
pick = new_pick
print("--------------END GAME LOOP-------------------")
print(coeff)
return coeff
def checkInOpenList(toCompare):
for i in range(len(open_list)):
if np.array_equal(open_list[i].child_node.initialState,toCompare):
if Heuristics.getHammingDist_GOAL(toCompare) < Heuristics.getHammingDist_GOAL(open_list[i].child_node.initialState):
return i
else:
return -1 #ignore toComapre
return -2 #insert as usual
def streak4OrDraw(board, move): if(Heuristics.checkForStreak(board,"red", 4) > 0 or Heuristics.checkForStreak(board,"yellow", 4) > 0): return True chip_count = 0 for y in range(0, 6): for x in range (0, 7): if(board[x][y] != "empty"): chip_count += 1 if (chip_count == 42): return True return False
def streak4OrDraw(board, move):
if (Heuristics.checkForStreak(board, "red", 4) > 0
or Heuristics.checkForStreak(board, "yellow", 4) > 0):
return True
chip_count = 0
for y in range(0, 6):
for x in range(0, 7):
if (board[x][y] != "empty"):
chip_count += 1
if (chip_count == 42):
return True
return False
def update_and_repaint(self, instance): if (self.game.mode == 0): status = self.game.updateBoard(int(instance.text)) if ((status == "won") or (status == "draw")): self.repaint_board() return self.repaint_board() elif (self.game.mode == 1): status1 = self.game.updateBoard(int(instance.text)) if ((status1 == "won") or (status1 == "draw")): self.repaint_board() return self.repaint_board() #cpu_move_num = mode_controller.human_vs_cpu(self.game) cpu_move_num = Heuristics.rando() status2 = self.game.updateBoard(cpu_move_num) if ((status2 == "won") or (status2 == "draw")): self.repaint_board() return self.repaint_board()
def update_and_repaint(self, instance):
if (self.game.mode == 0):
status = self.game.updateBoard(int(instance.text))
if ((status == "won") or (status == "draw")):
self.repaint_board()
return
self.repaint_board()
elif (self.game.mode == 1):
status1 = self.game.updateBoard(int(instance.text))
if ((status1 == "won") or (status1 == "draw")):
self.repaint_board()
return
self.repaint_board()
#cpu_move_num = mode_controller.human_vs_cpu(self.game)
cpu_move_num = Heuristics.rando()
status2 = self.game.updateBoard(cpu_move_num)
if ((status2 == "won") or (status2 == "draw")):
self.repaint_board()
return
self.repaint_board()
def train():
goal = [i + 1 for i in range(pow(size, 2) - 1)]
goal.append(0)
snake = get_snake(size)
to_move = goal[snake.index(0)]
to_remember = snake[goal.index(0)]
goal = Node(goal, size)
heu = Heuristics(['manhattan'], size, to_move, to_remember)
for pattern in patterns:
pdbs.append(train_pattern(goal, pattern, heu))
print("DB CACHED")
def trump_bidding_strategy(self, *args):
max_score = None
cont = None
for symbol in CardSymbol:
cont_num = Heuristics.approx_rounds_simple(self.player.cards,
symbol)
score = self.game.contract_score(cont_num, cont_num)
if max_score is None:
max_score = score
cont = WistContract(symbol, cont_num)
elif score > max_score:
max_score = score
cont = WistContract(symbol, cont_num)
if not self.game.trump_contract_legal(cont):
return WistContract()
else:
return cont
def main(id_offer):
""" Compute scores for all users given an offer
:param: id_offer
:return: Stringify object, sent to the client
"""
offer = db_loader.load_offer(id_offer)
res = []
if(offer):
if(len(listUsers) > 0):
for user in listUsers:
res.append(mainH.computeHeurisitcs(user, offer))
return json.dumps({'status': 200, 'message': 'OK', 'body': res})
else:
return json.dumps({'status':404, 'message': 'No user found in database'})
else:
return json.dumps({'status': 404, 'message': 'Offer not found in database'})
def getPath(): global localdata global path global mapper global PATH cmap = CustomMap(img.imread(PATH)) heuristics = Heuristics() search = Astar(cmap, heuristics) start = [localdata[0], localdata[1]] start = search.LocaltoGlobal(start[0],start[1]) destination = [coordinates[0][0], coordinates[0][1]] destination = search.LocaltoGlobal(destination[0],destination[1]) start = [start[0], start[1]] destination = [destination[0] , destination[1]] path = search.searchPath(start, destination) mapper.printpath(path) path = pixeltoglobal(path) path = dropWaypoints(path) addToDestinations(path) pixelToWaypoints()
def main():
print("Sliding Puzzle Solver!\n")
# Get size of the board from user
size = int()
while True:
try:
size = int(input("Insert the size of the board:"))
if size < 2:
raise ValueError
else:
break
except ValueError:
print("Insert a positive natural number > 1 !")
continue
game = G.Game(size)
heuristic = H.Heuristics(game)
inserted_value = str()
inserted_position = []
initial_state = None
# Get the initial state (doesn't check the user input properly :()
while not (inserted_value.upper() == 'Y') or (inserted_value.upper()
== 'N'):
inserted_value = input(
"Would you like to start from a random position (Y/N)?").upper()
if inserted_value == 'Y':
# Start with a random initial position
game.shuffle()
# Save the initial state/table
initial_state = copy.deepcopy(game.state)
break
if inserted_value.upper() == 'N':
for i in range(size**2):
value = input(f"Insert the value number {i + 1}: ")
try:
inserted_position.append(int(value))
except ValueError:
print("Insert a positive natural number! Exiting ...")
break
s = from_list_to_state(inserted_position, size)
game.set_state(s)
initial_state = copy.deepcopy(game.state)
break
game.set_state(initial_state)
print("Initial state:")
game.print()
print()
input("Press Enter to continue ...")
starting_date = time.asctime(time.localtime(time.time()))
print(f"Start searching at {starting_date}", )
time.sleep(1)
searching = True
attempt = 1
# Search routine
while searching:
searching = not search(game, heuristic, attempt)
# If search return False executes the following if clause
if searching:
print("I'll try again from:")
# Clean the game and set the previous initial state
attempt += 1
game.set_state(initial_state)
game.explored = []
game.state.previous_actions = []
game.print()
print()
print("Start again in 2 seconds ...")
time.sleep(2)
# input("Press Enter to continue ...")
searching = True
continue
def GrowTree(dataset, attributes):
global cnt_nonleaf_nodes,heuristic
max_gain_attr = None
max_gain = 0.0
gain = 0.0
# print "Attributes ", attributes
if not attributes:
common_val = get_max_val(dataset.get("Class"))
root = BTreeNode(str(common_val))
root.left = None
root.right = None
else:
if dataset.has_key('NA'):
return BTreeNode(str(dataset.get('NA')))
else:
class_list = dataset.get("Class")
# print class_list
tmp_negcnt, tmp_poscnt = get_count(class_list)
if tmp_poscnt == 0:
print "class: all negative examples"
# print class_list
return BTreeNode('0')
if tmp_negcnt == 0:
print "class: all positive examples"
# print class_list
return BTreeNode('1')
for val in attributes:
neg_dict, pos_dict = Dataset.split_dataset(dataset, val)
# print "Neg dict class" , neg_dict.get("Class")
# print "Pos dict class" , pos_dict.get("Class")
if heuristic == 0:
entropy_set = Heuristics.Entropy_Set(class_list)
elif heuristic == 1:
variance_set = Heuristics.Variance_Impurity_Set(class_list)
# print "Entropy set for ", val ,entropy_set
member_list = dataset.get(val)
if heuristic == 0:
entropy_member = Heuristics.Entropy_Members(dataset,neg_dict,pos_dict,member_list)
elif heuristic == 1:
variance_member = Heuristics.Variance_Impurity_Members(dataset,neg_dict,pos_dict,member_list)
# print "Entropy member for ",val,entropy_member
if heuristic == 0:
gain = Heuristics.gain(entropy_set, entropy_member)
elif heuristic == 1:
gain = Heuristics.gain(variance_set, variance_member)
print "gain for ",val ,gain
if bool([a for a in neg_dict.values() if a == []]):
print "Sub values empty - zero dataset"
common_val = get_max_val(dataset.get("Class"))
neg_dict = {}
neg_dict.update({'NA':common_val})
elif bool([a for a in pos_dict.values() if a == []]):
print "Sub values empty - one dataset"
common_val = get_max_val(dataset.get("Class"))
pos_dict = {}
pos_dict.update({'NA':common_val})
if gain >= max_gain:
max_gain = gain
max_gain_attr = val
root_zero_dataset = neg_dict
# print "inside max gain cal zeros ",val, neg_dict.get("Class")
root_one_dataset = pos_dict
# print "inside max gain cal ones ",val, pos_dict.get("Class")
neg_dict = {}
pos_dict = {}
# print
print "Maximum Information Gain: ",max_gain
print "Node selected: " , max_gain_attr
print "Zero Dataset: ", root_zero_dataset.get("Class")
print "One Dataset: ", root_one_dataset.get("Class")
root = BTreeNode(max_gain_attr)
cnt_nonleaf_nodes += 1
root.order = cnt_nonleaf_nodes
root.subset = dataset
if max_gain_attr in attributes:
attributes.remove(max_gain_attr)
if root != None:
# if root.left:
root.left = GrowTree(root_zero_dataset,attributes)
# if root.right:
root.right = GrowTree(root_one_dataset,attributes)
return root
def get_latest_heuristic():
"""
Returns the latest heuristic that was found with the genetic algorithm
"""
return Heuristics.Main(weights=tuple(LATEST_VECTOR))
from Game import MancalaGame
import Heuristics as H
from time import time
import Utils
import random
PL1 = 0
PL2 = 7
HP = H.RelativePointsHeuristic()
HB = H.PebblesHeuristic()
HR = H.RightCellHeuristic()
def man_vs_ai(game, heuristic, depth):
# make you play against an heuristic
# PL1 is human, PL2 is AI
game.state.print()
move = Utils.choose_move()
game.make_move(move, PL1)
player = PL2
counter = 0
while not game.no_moves():
counter += 1
# game loop
game.state.print()
if player is PL2:
t = time()
# ai player
val, move = Utils.alpha_beta(game.state,
player,
def start_mc(self, player_played = None):
root = Node(self.GM)
for i,move in enumerate(self.comp.current_cards):
c = 0
parent = root
while True:
# print(c)
c+=1
GMcopy = copy.deepcopy(parent.state)
GMcopy.deck.random_shuffle()
if c == 1:
comp_card = GMcopy.computer.throw_card(i + 1)
if player_played:
player_card = player_played
else:
player_card = GMcopy.player.throw_card(
random.choice([i + 1 for i in range(len(GMcopy.player.current_cards))]))
else:
player_card = GMcopy.player.throw_card(
random.choice([i + 1 for i in range(len(GMcopy.player.current_cards))]))
comp_card = GMcopy.computer.throw_card(random.choice([i+1 for i in range(len(GMcopy.computer.current_cards))]))
if self.turn:
winner = heur.check_cards(comp_card, player_card, GMcopy.main_card)
else:
winner = heur.check_cards(player_card,comp_card,GMcopy.main_card)
#computer wins
if (winner and self.turn) or (not winner and not self.turn):
GMcopy.computer.add_to_loot(comp_card, player_card)
GMcopy.first = GMcopy.computer
GMcopy.second = GMcopy.player
self.turn = True
else:
GMcopy.player.add_to_loot(comp_card, player_card)
GMcopy.second = GMcopy.computer
GMcopy.first = GMcopy.player
self.turn = False
GMcopy.used_cards.append(comp_card)
GMcopy.used_cards.append(player_card)
if GMcopy.deck.check_if_deck_empty() is False:
card1, card2 = GMcopy.deck.deal_cards_on_turn()
GMcopy.computer.pick_up_card(card1)
GMcopy.player.pick_up_card(card2)
child = Node(GMcopy, parent)
parent.add_child(child)
if c == 17:
print(1)
if GMcopy.second.check_hand():
self.backpropagate(child)
break
parent = child
pass
for cell in obj_list[r]:
board[i + cell[0]][j + cell[1]] = 2 + obs
cells += 1
obs += 1
break
print("Number of objects : " + str(obs))
print("Number of cells : " + str(cells))
return board, obs
# Main
start_time = time.time()
heuristic = H.PianoMoverHeur()
# Instance generation
board, obj = get_starting_board(RATIO)
print(board)
print("\n")
game = G.PianoMoverGame(board, obj)
state0 = game.getState()
dicOfStates[state0] = heuristic.euclidean(state0)
solution = search(game, state0)
print("Start \n")
cost = 0
def GrowTree(dataset, attributes, level):
print "Constructing Decision Tree" , level
max_gain, max_gain_attr, level = 0, None, 0
print "Attributes ", attributes
if not attributes:
common_val = get_max_val(dataset.get("Class"))
root = BTreeNode(str(common_val))
root.left = None
root.right = None
else:
if dataset.has_key('NA'):
return BTreeNode(str(dataset.get('NA')))
else:
class_list = dataset.get("Class")
tmp_negcnt, tmp_poscnt = get_count(class_list)
if tmp_poscnt == 0:
print "class: all negative examples"
return BTreeNode('0')
if tmp_negcnt == 0:
print "class: all positive examples"
return BTreeNode('1')
for val in attributes:
neg_dict, pos_dict = Dataset.split_dataset(dataset, val)
variance_set = Heuristics.Variance_Impurity_Set(class_list)
print "Variance Impurity set for ", val ,variance_set
member_list = dataset.get(val)
variance_member = Heuristics.Variance_Impurity_Members(dataset,neg_dict,pos_dict,member_list)
print "Variance Impurity member for ",val,variance_member
var_gain = Heuristics.gain(variance_set, variance_member)
print "Variance Impurity gain for ",val ,var_gain
print "Bool value - zeros" , bool([a for a in neg_dict.values() if a == []])
print "Bool value - ones" , bool([a for a in pos_dict.values() if a == []])
if bool([a for a in neg_dict.values() if a == []]):
print "Sub values empty - zero dataset"
common_val = get_max_val(dataset.get("Class"))
neg_dict = {}
neg_dict.update({'NA':common_val})
elif bool([a for a in pos_dict.values() if a == []]):
print "Sub values empty - one dataset"
common_val = get_max_val(dataset.get("Class"))
pos_dict = {}
pos_dict.update({'NA':common_val})
if var_gain > max_gain:
max_gain = var_gain
max_gain_attr = val
root_zero_dataset = neg_dict
root_one_dataset = pos_dict
else:
max_gain = var_gain
max_gain_attr = val
root_zero_dataset = neg_dict
root_one_dataset = pos_dict
print "Maximum Information Gain: ",max_gain
print "Node selected" , max_gain_attr
print "Zero Dataset", root_zero_dataset
print "One Dataset", root_one_dataset
root = BTreeNode(max_gain_attr)
if max_gain_attr in attributes:
attributes.remove(max_gain_attr)
if root != None:
root.left = GrowTree(root_zero_dataset,attributes,level)
root.right = GrowTree(root_one_dataset,attributes,level)
level+= 1
return root
padre = padre.parent
return reversed(lStates)
def search(game, state0):
sHorizon = set([])
sExplored = set([])
sHorizon.add(state0)
while (len(sHorizon) > 0):
view = pick(sHorizon)
if not (view is None):
if game.solution(view):
return backpath(view)
sExplored.add(view)
sHorizon = sHorizon | (game.neighbors(view) - sExplored)
return None
# Main
heuristic = H.MissCannHeuristic()
game = G.MissCannGame(mr=5,
cr=5,
ml=0,
cl=0,
ship=True,
shipMax=2,
heuristic=heuristic)
state0 = game.getState()
dicOfStates[state0] = heuristic.H(state0)
solution = search(game, state0)
[0, 12, 3, 0, 0],
[0, 13, 0, 0, 0],
[14, 0, 1, 0, 0],
]
# a 4x4 board with 1 as the smallest number, and 16 as the highest
hidatoBoard2 = [[0, 0, 0, 10], [14, 16, 0, 11], [0, 4, 8, 1], [5, 0, 0, 0]]
# a 5x5 board with 1 as the smallest number, and 25 as the highest
hidatoBoard3 = [
[0, 0, 0, 0, 0],
[0, 0, 12, 1, 2],
[16, 0, 0, 10, 25],
[0, 0, 0, 0, 24],
[0, 0, 0, 21, 22],
]
heuristic = H.HidatoHeuristic()
start_time1 = time.time()
# example number 1
print("This is the first example given board:")
print('\n'.join(
[''.join(['{:4}'.format(item) for item in row]) for row in hidatoBoard1]))
game1 = G.HidatoGame(hidatoBoard1, 1, 4, 2, heuristic=heuristic)
state0 = game1.getState()
dictOfStates[state0] = heuristic.H(state0)
solution1 = breadth_first_search(game1, state0)
print("This is the winning state board:")
print('\n'.join([
def build(self,card_down = None):
root = MinMaxNode(None, self.first_cards, self.second_cards, True)
last_level_nodes = []
if card_down:
self.first_cards.append(card_down)
#prva karta - prvi krog
for card in self.first_cards:
first_cards_left = self.first_cards[:]
second_cards_left = self.second_cards[:]
first_cards_left.pop(first_cards_left.index(card))
n = MinMaxNode(card, first_cards_left, second_cards_left, True, root)
root.children.append(n)
#druga karta - prvi krog
for card_1 in self.second_cards:
second_cards_left_1 = second_cards_left[:]
second_cards_left_1.pop(second_cards_left_1.index(card_1))
# vrednost prvega kroga
val1 = get_value(card, card_1)
turn_winner = heur.check_cards(card,card_1,self.main_card)
if(turn_winner):
turn_1_winner_cards = first_cards_left
turn_1_loser_cards = second_cards_left_1
else:
turn_1_winner_cards = second_cards_left_1
turn_1_loser_cards = first_cards_left
# shrani kdo je zmagal v zgodovini in koliko točk je dobil računalnik
if (not card_down and not turn_winner) or (card_down and turn_winner):
computer_level_winner = [True]
computer_values = [val1]
else:
computer_level_winner = [False]
computer_values = [-val1]
if computer_level_winner[0]:
n_1 = MinMaxNode(card_1, turn_1_winner_cards, turn_1_loser_cards, computer_level_winner[0], n)
else:
n_1 = MinMaxNode(card_1, turn_1_loser_cards, turn_1_winner_cards, computer_level_winner[0], n)
n.children.append(n_1)
for card_2 in turn_1_winner_cards:
turn_1_winner_cards_2 = turn_1_winner_cards[:]
turn_1_winner_cards_2.pop(turn_1_winner_cards_2.index(card_2))
#preveri če je komp zmagal ali ne
if (computer_level_winner[0]):
n_2 = MinMaxNode(card_2, turn_1_winner_cards_2, turn_1_loser_cards, computer_level_winner[0], n_1)
else:
n_2 = MinMaxNode(card_2, turn_1_loser_cards, turn_1_winner_cards_2, computer_level_winner[0], n_1)
n_1.children.append(n_2)
for card_3 in turn_1_loser_cards:
turn_1_loser_cards_3 = turn_1_loser_cards[:]
turn_1_loser_cards_3.pop(turn_1_loser_cards_3.index(card_3))
computer_level_winner_2 = computer_level_winner[::]
computer_values_2 = computer_values[::]
# Shrani če je v drugem krogu zmagal računalnik in koliko točk je dobil
val2 = get_value(card_2, card_3)
turn_winner_1 = heur.check_cards(card_2, card_3, self.main_card)
if (not computer_level_winner[0] and not turn_winner_1) or (computer_level_winner[0] and turn_winner_1):
computer_level_winner_2.append(True)
computer_values_2.append(int(val2))
else:
computer_level_winner_2.append(False)
computer_values_2.append(-int(val2))
if(computer_level_winner_2[1]):
n_3 = MinMaxNode(card_3, turn_1_winner_cards_2, turn_1_loser_cards_3, turn_winner_1, n_2)
turn_winner_2 = heur.check_cards(turn_1_winner_cards_2[0], turn_1_loser_cards_3[0],
self.main_card)
else:
n_3 = MinMaxNode(card_3, turn_1_loser_cards_3, turn_1_winner_cards_2, turn_winner_1,n_2)
turn_winner_2 = heur.check_cards(turn_1_loser_cards_3[0], turn_1_winner_cards_2[0],
self.main_card)
n_2.children.append(n_3)
val3 = int(get_value(turn_1_loser_cards_3[0], turn_1_winner_cards_2[0]))
if (not computer_level_winner_2[1] and not turn_winner_2) or (
computer_level_winner_2[1] and turn_winner_2):
computer_level_winner_2.append(True)
computer_values_2.append(val3)
else:
computer_level_winner_2.append(False)
computer_values_2.append(-val3)
n_3.value = int(sum(computer_values_2))
last_level_nodes.append(n_3)
if card_down:
self.doMiniMax(last_level_nodes, True, 4)
else:
self.doMiniMax(last_level_nodes, False, 4)
self.tree = root
if self.turn:
self.enemy_move(self.turn)
self.first_cards.pop(len(self.first_cards)-1)
print("")
def approx_rounds(self, idx):
cards = self.game.players[idx].cards
trump_symbol = self.game.trump_symbol
return Heuristics.approx_rounds_simple(cards, trump_symbol)
import argparse
DEFAULT_NUM_PLAYERS = 4
RANDOM_AGENT = 'random'
ONE_MOVE_AGENT = 'onemove'
HUMAN_AGENT = 'human'
PROBABILITY_AGENT = 'prob'
MONTECARLO_AGENT = 'monte'
GENETIC_AGENT = 'genetic'
GENETIC_WEIGHTS = (0.77197979, 0.8782323, 0.07241402, 0.82772027, 0.45152069,
0.17718227, 0.37266962, 0.15663299, 0.19536229)
AGENTS = {
RANDOM_AGENT:
Agent.RandomAgent(),
ONE_MOVE_AGENT:
Agent.OneMoveHeuristicAgent(Heuristics.AmossComb1()),
HUMAN_AGENT:
Agent.HumanAgent(),
PROBABILITY_AGENT:
Agent.ProbabilityAgent(),
MONTECARLO_AGENT:
Agent.MonteCarloAgent(Heuristics.Everything()),
GENETIC_AGENT:
Agent.MonteCarloAgent(Heuristics.Everything(weights=GENETIC_WEIGHTS))
}
DEFAULT_AGENTS = [RANDOM_AGENT]
PLAYER_NAMES = ['Roy', 'Boaz', 'Oriane', 'Amoss']
def get_args() -> argparse.Namespace:
parser = argparse.ArgumentParser()
def game():
board = [
[' ', 'w', ' ', 'w', ' ', 'w', ' ', 'w'],
['w', ' ', 'w', ' ', 'w', ' ', 'w', ' '],
[' ', 'w', ' ', 'w', ' ', 'w', ' ', 'w'], # machine frontier
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
[' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '],
['k', ' ', 'k', ' ', 'k', ' ', 'k', ' '], # human frontier
[' ', 'k', ' ', 'k', ' ', 'k', ' ', 'k'],
['k', ' ', 'k', ' ', 'k', ' ', 'k', ' ']
]
LEVEL = 3
heuristic = H.CheckerHeuristic()
rep = G.CheckerRepresentation(board)
rep.setCurrentPlayer('w')
curState = G.CheckerState(heuristic, rep)
f = open("log", "w")
f.close()
while True:
turn = 'w' # machine
curState.setCurrentPlayer(turn)
states = curState.neighbors(
turn
) # find possible moves from here (1 level deeper). these are first level TRIANGLES DOWN
for s in states:
print str(s)
mx = -9999
ix = None # best state
for s in states: # in this loop I want to choose the best move
start = time.time()
h = heuristic.H(s, LEVEL, 'k',
mx) # for each move, calculate heuristic value
end = time.time()
print "Time needed for heuristic: ", str((end - start))
if h > mx: # find best heuristic value (MAX one) and remember the corresponding state
mx = h
ix = s
# generate a move in function of ix
curState = ix
print "MATRIX AFTER MACHINE MOVE:"
print str(curState)
f = open("log", "a")
f.write(str(curState))
f.close()
# if machine has just moved a peg to the last line of human frontier (row 7) => add it to free set
for i in range(0, 8):
if curState.getRepresentation().getPiece(7, i) == 'w':
curState.addToFree(7, i)
# check if final break WHITE wins!
if curState.solution() == 'machine':
print "You lose"
return
turn = 'k' # human
curState.setCurrentPlayer(turn)
movePossible = False
while movePossible == False:
s = input('Position of move start. [row.column]: ')
s = str(s)
r = int(s.split('.')[0])
c = int(s.split('.')[1])
s = input('Position of move end. [row.column]: ')
s = str(s)
re = int(s.split(".")[0])
ce = int(s.split(".")[1])
# is it feasible?
movePossible = curState.isAdmissible(r, c, re, ce)
if not movePossible:
print "Move not admissible"
curState = curState.makeMove(r, c, re, ce)
print "RESULTING MATRIX:"
print str(curState)
f = open("log", "a")
f.write(str(curState))
f.close()
# check if final break BLACK wins!
if curState.solution() == 'human':
print "You win"
return
time.sleep(3)
return -2 #insert as usual
start_time = time.time()
fileNum = 0
for initialConfig in readInputFile.getPuzzles('puzzles.txt', (2, 4)):
goalNum = 1
init_state = np.array(initialConfig)
#GBS initial phase
#H1: Hamming Distance - GOAL1
puzzleIni = XPuzzle.XPuzzle(init_state)
open_list = [
Node(puzzleIni, None,
Heuristics.getHammingDist_GOAL(init_state, goalNum), None, 0)
]
closed_list = []
#end time is set after 60 seconds
t_end = time.time() + 60
count = 0
IsASol = False
while time.time() < t_end:
if len(open_list) == 0: #check if open_list is empty
print("No solution")
break
#pop the least cost element in the open_list and push it to hte closed_list
closed_list.append(open_list.pop(0))
nodeToGenerateChildren = closed_list[len(closed_list) - 1]
def contract_bidding_strategy(self, *args):
cont = Heuristics.approx_rounds_simple(self.player.cards,
self.game.trump_symbol)
if cont not in self.game.legal_contracts():
cont = cont + 1
return cont
def __init__(self, in_ini, in_env):
self.frontier = [in_ini]
self.env = in_env
self.visited = []
self.heu_calc = heu.AltHeuristic(self.env)
if __name__ == "__main__": draws = 0 red_wins = 0 red_losses = 0 num_games_to_play = 20 connect4_game = connect4.Connect4() first_turns = True while (num_games_to_play > 0): print "cpu1 thinking" if (first_turns): # introduce random variation cpu1_move_num = Heuristics.rando() else: cpu1_move_num = cpu1(connect4_game) status = connect4_game.updateBoard(cpu1_move_num) if (status == "red won"): red_wins += 1 num_games_to_play -= 1 first_turns = True connect4_game = connect4.Connect4() continue if (status == "yellow won"): red_losses += 1 num_games_to_play -= 1
def random_game(self, GM, move, turn, leftOver = False):
# print(len(GM.player.current_cards), len(GM))
main_card = GM.main_card
deck = GM.deck
# print(len(deck.deck))
if leftOver:
card1_playing = GM.player.card_down
card2_playing = move
# print(len(GM.player.current_cards), "zacetek1")
# print(len(GM.computer.current_cards), "zacetek2")
if heur.check_cards(card1_playing, card2_playing, main_card):
GM.player.add_to_loot(card1_playing, card2_playing)
turn = 2
if deck.check_if_deck_empty() is False:
card1, card2 = deck.deal_cards_on_turn()
GM.player.pick_up_card(card1)
GM.computer.pick_up_card(card2)
else:
GM.computer.add_to_loot(card1_playing, card2_playing)
turn = 1
if deck.check_if_deck_empty() is False:
card1, card2 = deck.deal_cards_on_turn()
GM.computer.pick_up_card(card1)
GM.player.pick_up_card(card2)
# random = randint(1, len(GM.computer.current_cards))
if turn == 1:
first = GM.computer
second = GM.player
else:
second = GM.computer
first = GM.player
# if len(first.current_cards) == 0 or len(second.current_cards) == 0:
first_turn = True
while True:
card1_playing = None
card2_playing = None
if first_turn:
first_turn = False
if turn == 1:
card1_playing = move
player2_pick = randint(1, len(second.current_cards))
card2_playing = second.throw_card(int(player2_pick))
# print(card1_playing, card2_playing)
elif turn == 2:
card2_playing = move
player1_pick = randint(1, len(first.current_cards))
card1_playing = first.throw_card(int(player1_pick))
else:
# print(len(first.current_cards), len(second.current_cards))
player1_pick = randint(1, len(first.current_cards))
card1_playing = first.throw_card(int(player1_pick))
# print(card1_playing)
player2_pick = randint(1, len(second.current_cards))
# print(player2_pick, len())
card2_playing = second.throw_card(int(player2_pick))
# print(card2_playing)
if heur.check_cards(card1_playing, card2_playing, main_card):
first.add_to_loot(card1_playing, card2_playing)
else:
second.add_to_loot(card1_playing, card2_playing)
tmp = first
first = second
second = tmp
if deck.check_if_deck_empty() is False:
card1, card2 = deck.deal_cards_on_turn()
first.pick_up_card(card1)
second.pick_up_card(card2)
if first.check_hand() or second.check_hand():
# print("pride")
# print(deck.check_if_deck_empty())
# print(len(first.current_cards),"prvi")
# print(len(second.current_cards), "drugi")
break
if first.score > second.score:
if first.name == 'Computer':
return 1
return -1
# print(first.name+" has won the game because he collected more points!")
elif first.score < second.score:
if second.name == 'Computer':
return 1
return -1
# print(second.name + " has won the game because he collected more points!")
else:
return 0
def vec_to_agent(vector):
"""
Returns a new agent based on the given vector
"""
heur = Heuristics.Main(weights=tuple(vector))
return Agent.OneMoveHeuristicAgent(heuristic=heur)
def neighbors(self, state, rep_alfa, rep_beta):
heuristic = H.RubikCubeHeuristics()
out = set([])
# GENERO PASSI SUCCESSIVI RAGGIUNGIBILI
# ROTAZIONE ORARIA PANNELLO LATERALE SINISTRO
rep_beta = RubikCubeRepresentation([
state.representation.retro[6], state.representation.alto[1],
state.representation.alto[2], state.representation.retro[3],
state.representation.alto[4], state.representation.alto[5],
state.representation.retro[0], state.representation.alto[7],
state.representation.alto[8]
], [
state.representation.fronte[0], state.representation.basso[1],
state.representation.basso[2], state.representation.fronte[3],
state.representation.basso[4], state.representation.basso[5],
state.representation.fronte[6], state.representation.basso[7],
state.representation.basso[8]
], [
state.representation.sinistra[6], state.representation.sinistra[3],
state.representation.sinistra[0], state.representation.sinistra[7],
state.representation.sinistra[4], state.representation.sinistra[1],
state.representation.sinistra[8], state.representation.sinistra[5],
state.representation.sinistra[2]
], state.representation.destra, [
state.representation.alto[0], state.representation.fronte[1],
state.representation.fronte[2], state.representation.alto[3],
state.representation.fronte[4], state.representation.fronte[5],
state.representation.alto[6], state.representation.fronte[7],
state.representation.fronte[8]
], [
state.representation.basso[6], state.representation.retro[1],
state.representation.retro[2], state.representation.basso[3],
state.representation.retro[4], state.representation.retro[5],
state.representation.basso[0], state.representation.retro[7],
state.representation.retro[8]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ANTIORARIA PANNELLO LATERALE SINISTRO
rep_beta = RubikCubeRepresentation([
state.representation.fronte[0], state.representation.alto[1],
state.representation.alto[2], state.representation.fronte[3],
state.representation.alto[4], state.representation.alto[5],
state.representation.fronte[6], state.representation.alto[7],
state.representation.alto[8]
], [
state.representation.retro[6], state.representation.basso[1],
state.representation.basso[2], state.representation.retro[3],
state.representation.basso[4], state.representation.basso[5],
state.representation.retro[0], state.representation.basso[7],
state.representation.basso[8]
], [
state.representation.sinistra[2], state.representation.sinistra[5],
state.representation.sinistra[8], state.representation.sinistra[1],
state.representation.sinistra[4], state.representation.sinistra[7],
state.representation.sinistra[0], state.representation.sinistra[3],
state.representation.sinistra[6]
], state.representation.destra, [
state.representation.basso[0], state.representation.fronte[1],
state.representation.fronte[2], state.representation.basso[3],
state.representation.fronte[4], state.representation.fronte[5],
state.representation.basso[6], state.representation.fronte[7],
state.representation.fronte[8]
], [
state.representation.alto[6], state.representation.retro[1],
state.representation.retro[2], state.representation.alto[3],
state.representation.retro[4], state.representation.retro[5],
state.representation.alto[0], state.representation.retro[7],
state.representation.retro[8]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ORARIA PANNELLO LATERALE DESTRO (alto,basso, sinistra, destra, fronte, retro)
rep_beta = RubikCubeRepresentation([
state.representation.alto[0], state.representation.alto[1],
state.representation.fronte[2], state.representation.alto[3],
state.representation.alto[4], state.representation.fronte[5],
state.representation.alto[6], state.representation.alto[7],
state.representation.alto[8]
], [
state.representation.basso[0], state.representation.basso[1],
state.representation.retro[8], state.representation.basso[3],
state.representation.basso[4], state.representation.retro[5],
state.representation.basso[6], state.representation.basso[7],
state.representation.retro[2]
], state.representation.sinistra, [
state.representation.destra[6], state.representation.destra[3],
state.representation.destra[0], state.representation.destra[7],
state.representation.destra[4], state.representation.destra[1],
state.representation.destra[8], state.representation.destra[5],
state.representation.destra[2]
], [
state.representation.fronte[0], state.representation.fronte[1],
state.representation.basso[2], state.representation.fronte[3],
state.representation.fronte[4], state.representation.basso[5],
state.representation.fronte[6], state.representation.fronte[7],
state.representation.basso[8]
], [
state.representation.retro[0], state.representation.retro[1],
state.representation.alto[8], state.representation.retro[3],
state.representation.retro[4], state.representation.alto[5],
state.representation.retro[6], state.representation.retro[7],
state.representation.alto[2]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ANTIORARIA PANELLO LATERALE DESTRO
rep_beta = RubikCubeRepresentation([
state.representation.alto[0], state.representation.alto[1],
state.representation.retro[8], state.representation.alto[3],
state.representation.alto[4], state.representation.retro[5],
state.representation.alto[6], state.representation.alto[7],
state.representation.retro[2]
], [
state.representation.basso[0], state.representation.basso[1],
state.representation.fronte[2], state.representation.basso[3],
state.representation.basso[4], state.representation.fronte[5],
state.representation.basso[6], state.representation.basso[7],
state.representation.fronte[8]
], state.representation.sinistra, [
state.representation.destra[2], state.representation.destra[5],
state.representation.destra[8], state.representation.destra[1],
state.representation.destra[4], state.representation.destra[7],
state.representation.destra[0], state.representation.destra[3],
state.representation.destra[6]
], [
state.representation.fronte[0], state.representation.fronte[1],
state.representation.alto[2], state.representation.fronte[3],
state.representation.fronte[4], state.representation.alto[5],
state.representation.fronte[6], state.representation.fronte[7],
state.representation.alto[8]
], [
state.representation.retro[0], state.representation.retro[1],
state.representation.basso[8], state.representation.retro[3],
state.representation.retro[4], state.representation.basso[5],
state.representation.retro[6], state.representation.retro[7],
state.representation.basso[2]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ORARIA PANNELLO SUPERIORE
rep_beta = RubikCubeRepresentation([
state.representation.alto[6], state.representation.alto[3],
state.representation.alto[0], state.representation.alto[7],
state.representation.alto[4], state.representation.alto[1],
state.representation.alto[8], state.representation.alto[5],
state.representation.alto[2]
], state.representation.basso, [
state.representation.fronte[0], state.representation.fronte[1],
state.representation.fronte[2], state.representation.sinistra[3],
state.representation.sinistra[4], state.representation.sinistra[5],
state.representation.sinistra[6], state.representation.sinistra[7],
state.representation.sinistra[8]
], [
state.representation.retro[8], state.representation.retro[7],
state.representation.retro[6], state.representation.destra[3],
state.representation.destra[4], state.representation.destra[5],
state.representation.destra[6], state.representation.destra[7],
state.representation.destra[8]
], [
state.representation.destra[0], state.representation.destra[1],
state.representation.destra[2], state.representation.fronte[3],
state.representation.fronte[4], state.representation.fronte[5],
state.representation.fronte[6], state.representation.fronte[7],
state.representation.fronte[8]
], [
state.representation.retro[0], state.representation.retro[1],
state.representation.retro[2], state.representation.retro[3],
state.representation.retro[4], state.representation.retro[5],
state.representation.sinistra[2], state.representation.sinistra[1],
state.representation.sinistra[0]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ANTIORARIA PANNELLO SUPERIORE
rep_beta = RubikCubeRepresentation([
state.representation.alto[2], state.representation.alto[5],
state.representation.alto[8], state.representation.alto[1],
state.representation.alto[4], state.representation.alto[7],
state.representation.alto[0], state.representation.alto[3],
state.representation.alto[6]
], state.representation.basso, [
state.representation.retro[8], state.representation.retro[7],
state.representation.retro[6], state.representation.sinistra[3],
state.representation.sinistra[4], state.representation.sinistra[5],
state.representation.sinistra[6], state.representation.sinistra[7],
state.representation.sinistra[8]
], [
state.representation.fronte[0], state.representation.fronte[1],
state.representation.fronte[2], state.representation.destra[3],
state.representation.destra[4], state.representation.destra[5],
state.representation.destra[6], state.representation.destra[7],
state.representation.destra[8]
], [
state.representation.sinistra[0], state.representation.sinistra[1],
state.representation.sinistra[2], state.representation.fronte[3],
state.representation.fronte[4], state.representation.fronte[5],
state.representation.fronte[6], state.representation.fronte[7],
state.representation.fronte[8]
], [
state.representation.retro[0], state.representation.retro[1],
state.representation.retro[2], state.representation.retro[3],
state.representation.retro[4], state.representation.retro[5],
state.representation.destra[2], state.representation.destra[1],
state.representation.destra[0]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ORARIA PANNELLO INFERIORE
rep_beta = RubikCubeRepresentation(state.representation.alto, [
state.representation.basso[6], state.representation.basso[3],
state.representation.basso[0], state.representation.basso[7],
state.representation.basso[4], state.representation.basso[1],
state.representation.basso[8], state.representation.basso[5],
state.representation.basso[2]
], [
state.representation.sinistra[0], state.representation.sinistra[1],
state.representation.sinistra[2], state.representation.sinistra[3],
state.representation.sinistra[4], state.representation.sinistra[5],
state.representation.fronte[6], state.representation.fronte[7],
state.representation.fronte[8]
], [
state.representation.destra[0], state.representation.destra[1],
state.representation.destra[2], state.representation.destra[3],
state.representation.destra[4], state.representation.destra[5],
state.representation.retro[2], state.representation.retro[1],
state.representation.retro[0]
], [
state.representation.fronte[0], state.representation.fronte[1],
state.representation.fronte[2], state.representation.fronte[3],
state.representation.fronte[4], state.representation.fronte[5],
state.representation.destra[6], state.representation.destra[7],
state.representation.destra[8]
], [
state.representation.sinistra[8], state.representation.sinistra[7],
state.representation.sinistra[6], state.representation.retro[3],
state.representation.retro[4], state.representation.retro[5],
state.representation.retro[6], state.representation.retro[7],
state.representation.retro[8]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ANTIORARIA PANNELLO INFERIORE
rep_beta = RubikCubeRepresentation(state.representation.alto, [
state.representation.basso[2], state.representation.basso[5],
state.representation.basso[8], state.representation.basso[1],
state.representation.basso[4], state.representation.basso[7],
state.representation.basso[0], state.representation.basso[3],
state.representation.basso[6]
], [
state.representation.retro[0], state.representation.sinistra[1],
state.representation.sinistra[2], state.representation.retro[3],
state.representation.sinistra[4], state.representation.sinistra[5],
state.representation.retro[6], state.representation.sinistra[7],
state.representation.sinistra[8]
], [
state.representation.fronte[0], state.representation.destra[1],
state.representation.destra[2], state.representation.fronte[3],
state.representation.destra[4], state.representation.destra[5],
state.representation.fronte[6], state.representation.destra[7],
state.representation.destra[8]
], [
state.representation.sinistra[0], state.representation.fronte[1],
state.representation.fronte[2], state.representation.sinistra[3],
state.representation.fronte[4], state.representation.fronte[5],
state.representation.sinistra[6], state.representation.fronte[7],
state.representation.fronte[8]
], [
state.representation.destra[6], state.representation.retro[1],
state.representation.retro[2], state.representation.destra[3],
state.representation.retro[4], state.representation.retro[5],
state.representation.destra[3], state.representation.retro[7],
state.representation.retro[8]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ORARIA PANNELLO FRONTALE
rep_beta = RubikCubeRepresentation([
state.representation.alto[0], state.representation.alto[1],
state.representation.alto[2], state.representation.alto[3],
state.representation.alto[4], state.representation.alto[5],
state.representation.sinistra[8], state.representation.sinistra[5],
state.representation.sinistra[2]
], [
state.representation.destra[6], state.representation.destra[3],
state.representation.destra[0], state.representation.basso[3],
state.representation.basso[4], state.representation.basso[5],
state.representation.basso[6], state.representation.basso[7],
state.representation.basso[8]
], [
state.representation.sinistra[0], state.representation.sinistra[1],
state.representation.basso[0], state.representation.sinistra[3],
state.representation.sinistra[4], state.representation.basso[1],
state.representation.sinistra[6], state.representation.sinistra[7],
state.representation.basso[2]
], [
state.representation.alto[6], state.representation.destra[1],
state.representation.destra[2], state.representation.alto[7],
state.representation.destra[4], state.representation.destra[5],
state.representation.alto[8], state.representation.destra[7],
state.representation.destra[8]
], [
state.representation.fronte[6], state.representation.fronte[3],
state.representation.fronte[0], state.representation.fronte[7],
state.representation.fronte[4], state.representation.fronte[1],
state.representation.fronte[8], state.representation.fronte[5],
state.representation.fronte[2]
], state.representation.retro)
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ANTIORARIA PANNELLO FRONTALE
rep_beta = RubikCubeRepresentation([
state.representation.alto[0], state.representation.alto[1],
state.representation.alto[2], state.representation.alto[3],
state.representation.alto[4], state.representation.alto[5],
state.representation.destra[0], state.representation.destra[3],
state.representation.destra[6]
], [
state.representation.sinistra[2], state.representation.sinistra[5],
state.representation.sinistra[8], state.representation.basso[3],
state.representation.basso[4], state.representation.basso[5],
state.representation.basso[6], state.representation.basso[7],
state.representation.basso[8]
], [
state.representation.sinistra[0], state.representation.sinistra[1],
state.representation.alto[8], state.representation.sinistra[3],
state.representation.sinistra[4], state.representation.alto[7],
state.representation.sinistra[6], state.representation.sinistra[7],
state.representation.alto[6]
], [
state.representation.basso[2], state.representation.destra[1],
state.representation.destra[2], state.representation.basso[1],
state.representation.destra[4], state.representation.destra[5],
state.representation.basso[0], state.representation.destra[7],
state.representation.destra[8]
], [
state.representation.fronte[2], state.representation.fronte[5],
state.representation.fronte[8], state.representation.fronte[1],
state.representation.fronte[4], state.representation.fronte[7],
state.representation.fronte[0], state.representation.fronte[3],
state.representation.fronte[6]
], state.representation.retro)
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ORARIA PANNELLO POSTERIORE
rep_beta = RubikCubeRepresentation([
state.representation.destra[2], state.representation.destra[5],
state.representation.destra[8], state.representation.alto[3],
state.representation.alto[4], state.representation.alto[5],
state.representation.alto[6], state.representation.alto[7],
state.representation.alto[8]
], [
state.representation.basso[0], state.representation.basso[1],
state.representation.basso[2], state.representation.basso[3],
state.representation.basso[4], state.representation.basso[5],
state.representation.sinistra[0], state.representation.sinistra[3],
state.representation.sinistra[6]
], [
state.representation.alto[2], state.representation.sinistra[1],
state.representation.sinistra[2], state.representation.alto[1],
state.representation.sinistra[4], state.representation.sinistra[5],
state.representation.alto[2], state.representation.sinistra[7],
state.representation.sinistra[8]
], [
state.representation.destra[0], state.representation.destra[1],
state.representation.basso[6], state.representation.destra[3],
state.representation.destra[4], state.representation.basso[7],
state.representation.destra[6], state.representation.destra[7],
state.representation.basso[8]
], state.representation.fronte, [
state.representation.retro[2], state.representation.retro[5],
state.representation.retro[8], state.representation.retro[1],
state.representation.retro[4], state.representation.retro[7],
state.representation.retro[0], state.representation.retro[3],
state.representation.retro[6]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
# ROTAZIONE ANTIORARIA PANNELLO POSTERIORE
rep_beta = RubikCubeRepresentation([
state.representation.sinistra[6], state.representation.sinistra[3],
state.representation.sinistra[0], state.representation.alto[3],
state.representation.alto[4], state.representation.alto[5],
state.representation.alto[6], state.representation.alto[7],
state.representation.alto[8]
], [
state.representation.basso[0], state.representation.basso[1],
state.representation.basso[2], state.representation.basso[3],
state.representation.basso[4], state.representation.basso[5],
state.representation.destra[2], state.representation.destra[5],
state.representation.destra[8]
], [
state.representation.basso[6], state.representation.sinistra[1],
state.representation.sinistra[2], state.representation.basso[7],
state.representation.sinistra[4], state.representation.sinistra[5],
state.representation.basso[8], state.representation.sinistra[7],
state.representation.sinistra[8]
], [
state.representation.destra[0], state.representation.destra[1],
state.representation.alto[0], state.representation.destra[3],
state.representation.destra[4], state.representation.alto[1],
state.representation.destra[6], state.representation.destra[7],
state.representation.alto[2]
], state.representation.fronte, [
state.representation.retro[6], state.representation.retro[3],
state.representation.retro[0], state.representation.retro[7],
state.representation.retro[4], state.representation.retro[1],
state.representation.retro[8], state.representation.retro[5],
state.representation.retro[2]
])
n = RubikCubeState(
state, rep_beta.alto, rep_beta.basso, rep_beta.sinistra,
rep_beta.destra, rep_beta.fronte, rep_beta.retro,
heuristic.H(rep_beta)
) #euristica lavora su una rappresentazione di stato non sullo stato direttamente
out.add(n)
return out
def main():
logging.basicConfig(level='INFO')
level = input("Insert level (odd number): ")
# the play will be saved in this file
file_name = "_plays/othello_{}.txt".format(
datetime.now().strftime('%Y-%m-%d_%H-%M-%S'))
out = open(file_name, "w")
heuristic = heur.OthelloHeuristic()
othello = game.OthelloGame(heuristic)
# k start first
turn = 'k'
logging.info("starting player: {}, initial board:\n {}\n\n".format(
turn, np.array(cp.copy(game.initial_board))))
ix = othello.state
start = time.time()
while True:
states = othello.neighbors(turn, ix)
mx = -9999
# store previous board
previous = ix
# cycle through the neighbors
for s in states:
# if the state is the previous one make it less valuable (so you will not get stuck)
if s == previous:
h = -1000
else:
# compute the heuristic value of the state s
h = heuristic.Hl(othello, s, level, turn)
logging.info(
"possible move for player {}; state = \n {} \n heuristic = {}\n"
.format(turn, s.representation.board, h))
if h > mx:
mx = h
ix = s
# at the end ix will contain the best state of the neighbor, log the state and write it in the out file
logging.info("MOVE: player {} = \n {}\n\n".format(
turn, ix.representation.board))
out.write("MOVE: player {} = \n {}\n\n".format(
turn, ix.representation.board))
# check whether the state is final
winner = ix.is_final()
# if there is a winner print it and quit
if winner is not None:
elapsed_time = time.time() - start
logging.info("The winner is player: {}".format(winner))
logging.info("Elapsed time: {}".format(elapsed_time))
out.write("The winner is player: {}\n".format(winner))
out.write("Elapsed time: {}".format(elapsed_time))
out.close()
break
turn = heur.OthelloHeuristic.get_enemy_color(turn)
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!")
def main():
# It gives the user the option to choose the (odd) level up to where he will come to explore the minMax
level = input("Choose the depth you want to get to explore the tree : ")
# From the rules of Othello the starting player is always black
# Remember: k--> black, w--> white, '-'--> empty cell
turn = 'k'
print("All the moves of the play are saved in the file.\n")
# Each play is saved on a file
file_name = input("Choose a name for the file: ")
file_path = "output/{}.txt".format(file_name)
print("Please, wait...\n")
out = open(file_path, "w")
start = t.time()
out.write("Starting player is: {}\n".format(turn))
out.write("Level: {}\n\n\n".format(level))
heuristic = he.OthelloHeuristic()
othello = g.OthelloGame(heuristic)
# Initial state of the game
ix = othello.state
out.write("\nInitial configuration: \n {}\n\n".format(
ix.representation.board))
#Start the game
while True:
# Save the states that it's possible to reach from the current state knowing the current turn
states = othello.neighbors(turn, ix)
# Initial value gives to find a better heuristic value (it is valid only in the first iteration, in next
# iterations will be save the best heuristic value compute)
mx = -9999
# Save the last state in ix on prev because we must denied to stay always in the same state at least it is the
# only possible move
prev = ix
# Start to explore the states
for s in states:
# for each state in states
# if the state is the previous one make it less valuable (so you will not choose always the same state at
# least it is the only possible move)
if s == prev:
# set h to -500 (arbitrary low)
h = -500
# if the state is not equal to the previus one
else:
# compute the heuristic on the state s
h = heuristic.MinMax(othello, s, level, turn)
# if the returned value from the heuristic method is grather than mx
if h > mx:
# save the new value in mx
mx = h
# save the state associate to the best heuristic value found
ix = s
# Write the move's player on the file
out.write("\nplayer {}, move:\n {}\n\n".format(
turn, ix.representation.board))
print("player {}, move:\n {}\n\n".format(turn,
ix.representation.board))
# Return the winner of the game
winner = ix.is_final()
# If ther's a winner
if winner is not None:
print("The game is finished! The winnwr is: {}".format(winner))
# write the winner in the file
out.write("The winner is player: {}\n".format(winner))
end = t.time() - start
# close file
out.write("The time spent is: {}".format(end))
out.close()
print("The time spent is: {}".format(end))
break
# otherwise give the control to the other player
turn = he.OthelloHeuristic.get_enemy_color(turn)
