def evaluationScore(jeu):
""" jeu -> reel
retourner le coup qui donne le meilleur resultat
"""
#print(((game.getScore(jeu,monJoueur-48))/48)*100)
return game.getScore(jeu, monJoueur) - game.getScore(
jeu, monJoueur % 2 + 1)
def atk(jeu):
"""
jeu*jeu -> float
Retourne un nombre compris entre [0,1] qui evalue l'effacite d'un coup joue par rapport au score
"""
return float(game.getScore(jeu, moi) - game.getScore(jeu, adv)) / 18
def attaque(jeu1, jeu2):
"""
jeu*jeu -> float
Retourne un nombre compris entre [0,1] qui evalue l'effacite d'un coup joue par rapport au score
"""
if float(game.getScore(jeu1, moi) - game.getScore(jeu2, moi)) / 18 > 0:
return float(
abs(game.getScore(jeu1, moi) - game.getScore(jeu2, moi))) / 18
else:
return 0
def choisieCoup(jeu):
""" jeu -> coup
Choisi le coup qui rapportera le plus de score
"""
# test tous les coups possibles avec une copie du jeu
meilleur_score = 0
jeu_test = game.getCopieJeu(jeu)
joueur = game.getJoueur(jeu)
for c in jeu.coups_possibles:
game.joueCoup(jeu_test, c)
if (game.getScore(jeu_test, joueur) >= meilleur_score):
meilleur_score = game.getScore(jeu_test, joueur)
meilleur_coup = c
jeu_test = game.getCopieJeu(jeu)
return meilleur_coup
def heuristic(self, grid):
"""https://github.com/nneonneo/2048-ai/blob/master/2048.cpp
SCORE_LOST_PENALTY = 200000
SCORE_MONOTONICITY_POWER = 4
SCORE_MONOTONICITY_WEIGHT = 47
SCORE_SUM_POWER = 3.5
SCORE_SUM_WEIGHT = 11
SCORE_MERGES_WEIGHT = 700
SCORE_EMPTY_WEIGHT = 270"""
return game.getScore(grid)
def joue():
jeu=game.initialiseJeu()
it=0
while((it<100)and (not game.finJeu(jeu))):
game.affiche(jeu)
coup=saisieCoup(jeu)
game.joueCoup(jeu,coup)
it+=1
game.affiche(jeu)
print("gagnant="+str(game.getGagnant(jeu)+":"+ str(game.getScore(jeu))))
return jeu
def joueCoup(jeu, coup):
save = game.getCopieJeu(
jeu
) #on simule d'abord le coup pour vérifier que celui-ci ne va pas affamer l'adversaire
v = game.getCaseVal(save, coup[0], coup[1])
game.setCaseVal(save, coup[0], coup[1], 0)
case = distribue(
save, coup, v
) #la fonction distribue renvoie la derniere case ou une graine a ete depose
score = game.getScore(save, game.getJoueur(save))
while case[0] == game.getJoueurAdverse(save) - 1 and (
save[0][case[0]][case[1]] == 2 or save[0][case[0]][case[1]] == 3):
score = score + recolte(save, case)
case = nextCase(save, case)
def do_GET(self):
if self.path == "/getRound":
response = game.getRound()
self.send_response(200)
self.send_header('Content-type','application/json')
self.end_headers()
print json.dumps(response)
self.wfile.write(json.dumps(response))
elif self.path == "/getScore":
self.send_response(200)
self.send_header('Content-type','application/json')
self.end_headers()
self.wfile.write(json.dumps(game.getScore()))
else:
SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
def evaluationScore(jeu):
""" jeu -> reel
retourner le coup qui donne le meilleur resultat
"""
return game.getScore(jeu, monJoueur) - game.getScore(
jeu, monJoueur % 2 + 1)
def f1(jeu):
#print ("difference de score " + str (game.getScore(jeu,moi)-game.getScore(jeu, moi%2+1)))
return game.getScore(jeu, moi) - game.getScore(jeu, moi % 2 + 1)
def evaluationDifference(jeu):
adv = monJoueur % 2 + 1
return game.getScore(jeu, monJoueur) - game.getScore(jeu, adv)
def evalj(jeu):
#pas sur de la fonction
return game.getScore(jeu,game.getJoueur(jeu))
def evaluationScore(jeu):
return game.getScore(jeu, monJoueur)-game.getScore(jeu, monJoueur%2+1)
def evalj(jeu):
return game.getScore(jeu, game.getJoueur(jeu))
def diffScores(jeu):
return game.getScore(jeu, moi) - game.getScore(jeu, moi % 2 + 1)
def evaluation(jeu):
""" jeu -> int
"""
return game.getScore(jeu, moi) - game.getScore(jeu, moi % 2 + 1)
v = game.getCaseVal(save, coup[0], coup[1])
game.setCaseVal(save, coup[0], coup[1], 0)
case = distribue(
save, coup, v
) #la fonction distribue renvoie la derniere case ou une graine a ete depose
score = game.getScore(save, game.getJoueur(save))
while case[0] == game.getJoueurAdverse(save) - 1 and (
save[0][case[0]][case[1]] == 2 or save[0][case[0]][case[1]] == 3):
score = score + recolte(save, case)
case = nextCase(save, case)
if advAffame(save):
distribue(jeu, coup, v)
else:
game.setCaseVal(jeu, coup[0], coup[1], 0)
case = distribue(jeu, coup, v)
score = game.getScore(jeu, game.getJoueur(jeu))
while case[0] == game.getJoueurAdverse(jeu) - 1 and (
jeu[0][case[0]][case[1]] == 2
or jeu[0][case[0]][case[1]] == 3):
score = score + recolte(jeu, case)
case = nextCase(jeu, case)
game.setAtmPlayerScore(jeu, score)
game.changeJoueur(jeu)
return
def finJeu(jeu):
if (jeu[0] == [[0 for i in range(6)]
for j in range(2)]) or getCoupsValides(jeu) == [] or len(
game.getCoupsJoues(jeu)) == 100:
return True
"""# print(game.joueur1)
# print(game.joueur2)
# print("Nombre de tours : " + str(len(game.getCoupsJoues(jeu))))"""
if len(game.getCoupsJoues(jeu)) == 4:#fin coup aleatoire
game.joueur1=game.joueurinter1
game.joueur2=game.joueurinter2
if game.getGagnant(jeu) == j1:
winsPlayer1+=1
elif game.getGagnant(jeu) == j2:
winsPlayer2+=1
else:
matchNul+=1
scoreMoyen1 += game.getScore(jeu,j1)#additionne les scores de j1 puis va diviser par n ensuite
scoreMoyen2 += game.getScore(jeu,j2)
nbc += len(game.getCoupsJoues(jeu))
jeuCopie = game.getCopieJeu(jeu)
jeuCopie[1] = game.getGagnant(jeu)
tabParties.append(jeuCopie)
#game.affiche(jeu)
tabNoeudsJ1.append(awele_alphaBeta.nombreDeNoeuds)
tabNoeudsJ2.append(awele_minMax.nombreDeNoeuds)
profondeur.append(awele_alphaBeta.prof)
print ("1:",tabNoeudsJ1)#affichage tab des noeuds qu'on utilisera pr les graph
print("2:",tabNoeudsJ2)
game.joueur1.prof += 1
game.joueur2.prof += 1
if i == n/2 :#changement de coté pour joueur
game.joueurinter1=game.joueur2
