def estimation(jeu, coup, prf, joueur):
game.joueCoup(jeu, coup)
#L= game.getCoupsValides(jeu)
if game.finJeu(jeu):
g = game.getGagnant(jeu)
if g == joueur:
return 100000
elif g == 0:
return -100
else:
return -100000
elif prf >= 2:
return evaluation(jeu, coup, joueur)
else:
L = game.getCoupsValides(jeu)
m = []
for i in L:
jeu2 = game.getCopieJeu(jeu)
#game.joueCoup(jeu2,i)
m.append(estimation(jeu2, i, prf + 1, joueur))
if game.getJoueur(jeu) == joueur:
return max(m)
else:
return min(m)
def joueN(n):
global y
v1, j1 = 0, 1
"""
# =============================================================================
# - v1 (nombre de victoires du joueur 1), v2 (nombre de victoires du joueur 2), mn (nombre de matchs nuls)
# - sc1 et sc2 (scores moyens de chaque joueur)
# - nbc (nombre de coups joues en moyenne)
# =============================================================================
"""
#lancer une partie, 3 coups alea au debut puis chaque joueur se met a jouer
for i in range(n):
game.joueur1 = awele_alea
game.joueur2 = awele_alea
jeu = game.initialiseJeu()
while not game.finJeu(jeu):
coup = game.saisieCoup(jeu)
game.joueCoup(jeu, coup)
if len(game.getCoupsJoues(jeu)) == 4:
game.joueur1 = game.joueurinter1
game.joueur2 = game.joueurinter2
if game.getGagnant(jeu) == j1:
v1 += 1
v1 = float(v1) / float(n) #ratio victoire/nbre de match
y.append(
v1
) #y=liste de victoire éfféctué (ou on ajoute a la fin de la liste le nombre de victoire pour n partie faite)
def JoueN(
joueur1, joueur2
): # joue 10 partie (variable N) et compte le nombre de victoire de joueur 1 (l'eleve)
global j1, j2
victoires = 0
for i in range(N):
game.joueur1 = othello_alea #transforme mes joueur en joueur aleatoire
game.joueur2 = othello_alea #permet de tirer des coups aleatoire au debut, sinon tjr meme partie
jeu = game.initialiseJeu()
while not game.finJeu(jeu):
coup = game.saisieCoup(
jeu) #joues different coups tant que cest pas la fin du jeu
game.joueCoup(jeu, coup)
if len(game.getCoupsJoues(jeu)
) == 4: #apres 4 coups aleatoire,le jeu commence vraiment
game.joueur2 = joueur2
game.joueur1 = joueur1
g = game.getGagnant(jeu)
if g == j1: #on compte le nbre de victoire de leleve
victoires += 1
if i == N / 2:
game.joueur1 = joueur2 #apres N/2 partie, on echange les joeuur , pour quon ai pas le meme joueur qui commence
game.joueur2 = joueur1
j1 = game.joueur2
j1 = game.joueur1
return victoires
def estimation(jeu, coup, profondeur):
copie = game.getCopieJeu(jeu)
game.joueCoup(copie, coup)
if game.finJeu(copie):
gagnant = game.getGagnant(copie)
if gagnant == moi:
return 10000
elif gagnant == 0:
return -100
else:
return -10000
if profondeur == PMAX:
return evaluation(copie)
listeCoups = game.getCoupsValides(copie)
if profondeur % 2 == 0:
scoremax = -10000
for c in listeCoups:
score_estime = estimation(copie, c, profondeur + 1)
if score_estime > scoremax:
scoremax = score_estime
return scoremax
if profondeur % 2 == 1:
scoremin = 10000
for c in listeCoups:
score_estime = estimation(copie, c, profondeur + 1)
if score_estime < scoremin:
scoremin = score_estime
return scoremin
def estimation(jeu, coup, p):
#retourne le score d'utilite pour un coup donne
copie = game.getCopieJeu(jeu)
game.joueCoup(copie, coup)
if game.finJeu(copie):
g = game.getGagnant(copie)
if g == moi:
return 100000000
else:
if g == 0:
return -500
else:
return -100000000
if p == prof:
return evaluation(copie)
if p < prof:
coups = game.getCoupsValides(copie)
max_min = estimation(copie, coups[0], p + 1)
for c in coups[1:]:
s = estimation(copie, c, p + 1)
if p % 2 == 0 and s > max_min:
max_min = s
if p % 2 != 0 and s < max_min:
max_min = s
return max_min
def estimation(jeu, coup, p, a, b):
copie = game.getCopieJeu(jeu)
game.joueCoup(copie, coup)
if game.finJeu(copie):
g = game.getGagnant(copie)
if g == moi:
return 12345
else:
if g == 0:
return -123
else:
return -12345
if p == prof:
return evaluation(copie)
else:
cp = game.getCoupsValides(copie)
if p % 2 == 0:
m = a
else:
m = b
for c in cp:
s = estimation(copie, c, p + 1, a, b)
if p % 2 == 0:
if s >= m:
a = s
m = s
if s > b:
return b
else:
if s <= m:
b = s
m = s
if s < a:
return a
return m
def jouePARTIE(j1, j2):
global playerONE
global playerTWO
#On initialise a ALEA les 4 premier Coups pr que ce soit équilibré et pr éviter même partie.
for i in range(1):
jeu = game.initialiseJeu()
game.joueur1 = othello_alea
game.joueur2 = othello_alea
while not game.finJeu(jeu):
#game.affiche(jeu)
coup = game.saisieCoup(jeu)
game.joueCoup(jeu, coup)
if len(game.getCoupsJoues(jeu)) == 4:
game.joueur1 = j1
game.joueur2 = j2
if i == nbRounds / 2:
game.joueur1 = j2
game.joueur2 = j1
#playerONE=2
#playerTWO=1
#print ("Nombre de tours : " + str(len(game.getCoupsJoues(jeu))))
#print("Gagnant de la partie est : ",game.getGagnant(jeu))
gagnant = game.getGagnant(jeu)
return gagnant
def estimation(jeu, coup, p):
global nbNoeuds
nbNoeuds += 1
copie = game.getCopieJeu(jeu)
game.joueCoup(copie, coup)
if game.finJeu(jeu):
g = game.getGagnant(jeu)
if g == moi:
return 100000
else:
if g == 0:
return -100
else:
return -100000
if p == prof:
l = parcoursPlateau(jeu)
return evaluation(copie, l)
cp = game.getCoupsValides(copie)
m = 0
for c in cp:
s = estimation(copie, c, p + 1)
if p % 2 == 0:
if s >= m:
m = s
else:
if s <= m:
m = s
return m
def estimation(jeu, coup, p):
global nbNoeuds
nbNoeuds+=1
copie = game.getCopieJeu(jeu)
game.joueCoup(copie,coup)
if game.finJeu(jeu):
g=game.getGagnant(jeu)
if g == moi:#si c'est moi le vainqueur alors estimation élevée
return 12345
else:
if g == 0:#si c'est nul alors estimation moyenne
return -123
else:#pire cas estimation faible
return -12345
if p >= prof:
liste_parcoursPlat= parcoursPlateau(jeu)
return evaluation(copie,liste_parcoursPlat)
coupsV=game.getCoupsValides(copie)
mValue=0
for c in coupsV:
est =estimation(copie,c,p+1)
if p%2 == 0:#MAX
if est >= mValue:
mValue= est
else:#MIN
if est <=mValue:
mValue = est
return mValue
def estimationMIN(jeu, p=1):
Vmin = float("inf")
if game.finJeu(jeu):
g = game.getGagnant(jeu)
if g == monJoueur:
return 1000
else:
return -1000
if p == Pmax:
#print("VMIN:",Vmin)
return evaluation(jeu)
#game.changeJoueur(jeu)
coups = game.getCoupsValides(jeu)
for cp in coups:
j = game.getCopieJeu(jeu)
game.joueCoup(j, cp)
v = estimationMAX(j, p + 1)
#print(cp," ",v," ", p)
if Vmin > v:
Vmin = v
# print("VMIN:",Vmin)
return Vmin
def estimation(jeu, coup, p):
global nombreDeNoeuds
nombreDeNoeuds += 1
copie = game.getCopieJeu(jeu)
game.joueCoup(copie, coup)
if game.finJeu(copie):
g = game.getGagnant(copie)
if g == moi: #si c'est moi le vainqueur alors estimation élevée
return 12345
else:
if g == 0: #si c'est nul alors estimation moyenne
return -123
else: #pire cas estimation faible
return -12345
if p >= prof:
#max profondeur donc on evalue
return evaluation(jeu, copie)
else:
coupsV = game.getCoupsValides(copie)
mValue = 0
for c in coupsV:
est = estimation(copie, c, p + 1)
if p % 2 == 0: #MAX
if est >= mValue:
mValue = est
else: #MIN
if est <= mValue:
mValue = est
return mValue
def joueplsr():
nbrepartie = 0
j1 = 0
j2 = 0
eg = 0
tj1 = 0
tj2 = 0
tt = time.time()
while (nbrepartie < NBPARTIE):
if (nbrepartie == (NBPARTIE / 2)):
global joueur2
global joueur1
print("score mi-temps(" + str(nbrepartie) + " partie):\nj1: " +
str(j1) + " \nscore j2: " + str(j2) + "\nnb d'equalite : " +
str(eg) + "\n")
s = joueur1
joueur1 = joueur2
joueur2 = s
a = j1
j1 = j2
j2 = a
a = tj1
tj1 = tj2
tj2 = a
jeu = game.initialiseJeu()
it = 0
while ((it < 100) and (not (game.finJeu(jeu)))):
if (it < 4):
coup = Random.saisieCoup(game.getCopieJeu(jeu))
game.joueCoup(jeu, coup)
else:
t1 = time.time()
coup = saisieCoup(jeu)
if game.getJoueur(jeu) == 1:
tj1 += time.time() - t1
else:
tj2 += time.time() - t1
game.joueCoup(jeu, coup)
it += 1
g = game.getGagnant(jeu)
tj1 = tj1 / it
tj2 = tj2 / it
if (g == 1):
j1 += 1
if (g == 2):
j2 += 1
if (g == 0):
eg += 1
nbrepartie += 1
tt = time.time() - tt
print("score final :\nj1: " + str(j2) + "temps/coup=" + str(tj2) +
"\nj2: " + str(j1) + "temps/coup=" + str(tj2) +
"\nnb d'equalite : " + str(eg))
def joue():
jeu = game.initialiseJeu()
while (not game.finJeu(jeu)):
game.affiche(jeu)
c = game.saisieCoup(game.getCopieJeu(jeu))
jeu = game.joueCoup(jeu, c)
g = game.getGagnant(jeu)
return g
def jouePARTIE():
jeu = game.initialiseJeu()
while not game.finJeu(jeu):
game.affiche(jeu)
coup = game.saisieCoup(jeu)
game.joueCoup(jeu, coup)
print(
"Nombre de tours : " + str(len(game.getCoupsJoues(jeu)))
) #str permet de cast, sinon on peut pas concatener un str et un int
if game.getGagnant(jeu) == 0:
print("\nEgalite parfaite !")
else:
print("\nLe joueur " + str(game.getGagnant(jeu)) + " a gagne !")
print("\nPlateau de fin de jeu: ")
game.game.affiche(jeu)
g = game.getGagnant(jeu)
return g
def play():
jeu = game.initialiseJeu()
while True:
#game.affiche(jeu)
valides = game.getCoupsValides(jeu)
if game.finJeu(jeu):
break
elif valides != None:
coup = game.saisieCoup(jeu)
game.joueCoup(jeu, coup)
print("Le gagnant est : ", game.getGagnant(jeu))
return game.getGagnant(jeu)
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 joue():
"""void -> nat
retourne un gagnant"""
jeu = game.initialiseJeu()
while not game.finJeu(jeu):
#game.affiche(jeu)
print "joueur : {}".format(game.getJoueur(jeu))
coup = game.saisieCoup(jeu)
print "coup joue : {}".format(coup)
game.joueCoup(jeu, coup)
print "score : {}".format(game.getScores(jeu))
#game.affiche(jeu)
return game.getGagnant(jeu)
def jouentrainement(ev):
global joueur2
global joueur1
nbrepartie=0
j1=0
j2=0
eg=0
switch=1
while(nbrepartie<NBPARTIE):
if (nbrepartie==(NBPARTIE/2)):
s=joueur1
joueur1=joueur2
joueur2=s
a=j1
j1=j2
j2=a
switch=2
jeu=game.initialiseJeu()
it=0
while((it<100)and (not(game.finJeu(jeu)))):
if (it<4):
coup=joueur_alea.saisieCoup(game.getCopieJeu(jeu))
game.joueCoup(jeu,coup)
else :
if(game.getJoueur(jeu)==switch):
coup=saisieCoupTr(jeu,ev)
else:
coup=saisieCoup(jeu)
game.joueCoup(jeu,coup)
it+=1
g=game.getGagnant(jeu)
if (g==1):
j1+=1
if(g==2):
j2+=1
if(g==0):
eg+=1
nbrepartie+=1
if (nbrepartie==NBPARTIE):
s=joueur2
joueur2=joueur1
joueur1=s
return j2
def play():
jeu = game.initialiseJeu()
while True:
#game.affiche(jeu)
valides = game.getCoupsValides(jeu)
if game.finJeu(jeu):
break
if len(valides) !=0:
coup = game.saisieCoup(jeu)
game.joueCoup(jeu,coup)
print("Le gagnant est : " + str(game.getGagnant(jeu)))
return game.getGagnant(jeu)
def fitness(jeu):
joueur = 1 if game.joueur1 == Joueur1 else 2
enemi = 1 if joueur == 2 else 2
f = 0.0
n = 0
if joueur == game.getGagnant(jeu):
f += min(jeu[4][joueur - 1] * 1.0 / jeu[4][enemi - 1] *
1.0, 5) if jeu[4][enemi - 1] > 0 else 5
if enemi == game.getGagnant(jeu):
f -= min(jeu[4][enemi - 1] * 1.0 / jeu[4][joueur - 1] *
1.0, 5) if jeu[4][joueur - 1] > 0 else 5
f += 0 if jeu[4][enemi - 1] > 0 else 5
f += 0 if jeu[4][joueur - 1] > 0 else 5
n += 1 if jeu[0][0][0] == joueur else 0
n += 1 if jeu[0][0][7] == joueur else 0
n += 1 if jeu[0][7][0] == joueur else 0
n += 1 if jeu[0][7][7] == joueur else 0
n *= 2
f += n
return f
def joue(ev1, ev2):
it = 0
jeu = game.initialiseJeu()
while ((it < 100) and (not (game.finJeu(jeu)))):
if (it < 4):
coup = Random.saisieCoup(game.getCopieJeu(jeu))
game.joueCoup(jeu, coup)
else:
if (game.getJoueur(jeu) == 1):
coup = Alpha_Beta_Train.saisieCoup(jeu, ev1)
else:
coup = Alpha_Beta_Train.saisieCoup(jeu, ev2)
game.joueCoup(jeu, coup)
it += 1
return game.getGagnant(jeu)
def joue():
"""void -> nat
retourne un gagnant"""
jeu = game.initialiseJeu()
for i in range(4):
random.seed()
coup = joueur_aleatoire.saisieCoup(jeu)
game.joueCoup(jeu, coup)
while not game.finJeu(jeu):
#game.affiche(jeu)
coup = game.saisieCoup(jeu)
game.joueCoup(jeu, coup)
return game.getGagnant(jeu)
def play():
global W
global Alpha
jeu = game.initialiseJeu()
print(game.joueur1)
while True:
#game.affiche(jeu)
valides = game.getCoupsValides(jeu)
print(EvalCoupHorizon1(game.getCopieJeu(jeu), valides[0]))
print(oracle.scorescoups(jeu)[0])
"""if jeu[2] !=None:
scoresoracle= oracle.scorescoups(jeu)
o=EvalCoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu))
for i in range(len(valides)):
if scoresoracle[i] < max(scoresoracle):
if (o-EvalCoupHorizon1(game.getCopieJeu(jeu),valides[i]))<1:
W[0]= W[0]-Alpha*(h1CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h1CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu)))
W[1]= W[1]-Alpha*(h2CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h2CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu)))
W[2]= W[2]-Alpha*(h3CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h3CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu)))
W[3]= W[3]-Alpha*(h4CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h4CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu)))
W[4]= W[4]-Alpha*(h5CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h5CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu)))
W[5]= W[5]-Alpha*(h6CoupHorizon1(game.getCopieJeu(jeu),valides[i])-h6CoupHorizon1(game.getCopieJeu(jeu),oracle.saisieCoup(jeu)))
"""
if game.finJeu(jeu):
break
elif valides != None:
coup = game.saisieCoup(jeu)
game.joueCoup(jeu, coup)
return game.getGagnant(jeu)
def estimationMIN(jeu, p=1):
if game.finJeu(jeu):
g = game.getGagnant(jeu)
if g == monJoueur:
return 1000
else:
return -1000
if p == Pmax:
return evaluation(jeu)
Vmin = float("inf")
for cp in game.getCoupsValides(jeu):
j = game.getCopieJeu(jeu)
game.joueCoup(j, cp)
v = estimationMAX(j, p + 1)
if Vmin > v:
Vmin = v
return Vmin
def estimation(jeu, coup, prf, joueur, alpha, beta):
global n
game.joueCoup(jeu, coup)
if game.finJeu(jeu):
n = n + 1
g = game.getGagnant(jeu)
if g == joueur:
return 100000
elif g == 0:
return -100
else:
return -100000
elif prf >= PRONF:
n = n + 1
return evaluation(jeu, coup, joueur)
else:
L = game.getCoupsValides(jeu)
if (joueur == game.getJoueur(jeu)):
val = -5000000
for i in L:
n = n + 1
jeu2 = game.getCopieJeu(jeu)
val = max(val, estimation(jeu2, i, prf + 1, joueur, alpha,
beta))
if val >= beta:
return val + 1
alpha = max(val, alpha)
return val
else:
val = 5000000
for i in L:
n = n + 1
jeu2 = game.getCopieJeu(jeu)
val = min(val, estimation(jeu2, i, prf + 1, joueur, alpha,
beta))
if val <= alpha:
return val - 1
beta = min(val, beta)
return val
def estimationBetaMin(jeu, alpha, beta, p=1):
if game.finJeu(jeu):
g = game.getGagnant(jeu)
if g == monJoueur:
return 1000
else:
return -1000
if p == Pmax:
return evaluation(jeu)
Vmin=float("inf")
coups=game.getCoupsValides(jeu)
for cp in coups:
j = game.getCopieJeu(jeu)
game.joueCoup(j, cp)
v = estimationAlphaMax(j,alpha, beta, p+1)
if Vmin>v :
Vmin = v
if Vmin <= alpha:
return Vmin
beta = min(beta, Vmin)
return Vmin
def estimation(jeu, coup, p, alpha, beta):
global nombreDeNoeuds
nombreDeNoeuds += 1
#retourne le score d'utilite pour un coup donne
copie = game.getCopieJeu(jeu)
game.joueCoup(copie, coup)
if game.finJeu(copie):
g = game.getGagnant(copie)
if g == moi:
return 123456 #cas gagnant = estimation élevé
else:
if g == 0:
return -123 #cas egalité = estimation neutre-negative
else:
return -123456 #cas perdant = estimation NEGATIVE
if p >= prof: #si profondeur trop élevé, (dernier noeud) renvoie une evaluation de la copie du jeu.
liste_parcoursPlat = parcoursPlateau(jeu)
return evaluation(copie, liste_parcoursPlat)
mValue = 0
coupsV = game.getCoupsValides(copie)
for c in coupsV:
est = estimation(copie, c, p + 1, alpha, beta)
if p % 2 == 0: #noeud MAX
mValue = alpha
if est >= beta:
return beta
if est > alpha:
alpha = est #on donne à a l'estimation s, qui sera réincrementé dans la boucle.
mValue = alpha #on donne a m la valeur de l'estimation, car c'est m qui sera retourné a la fin
else: #noeud MIN
mValue = beta
if est <= alpha:
return alpha
if est < beta:
beta = est
mValue = beta
return mValue
def estimation(jeu, coup, alpha, beta, p):
#retourne le score d'utilite pour un coup donne
global cpt
cpt += 1
copie = game.getCopieJeu(jeu)
game.joueCoup(copie, coup)
m = -100000 if p % 2 == 0 else 100000
if game.finJeu(copie):
g = game.getGagnant(copie)
if g == moi:
return 10000
else:
if g == 0:
return -100
else:
return -10000
if p >= prof:
return evaluation(copie)
if p < prof:
coups = game.getCoupsValides(copie)
for c in coups:
s = estimation(copie, c, alpha, beta, p + 1)
if p % 2 == 0:
if s >= beta:
return beta + 1
if s > m:
alpha = max(alpha, s)
m = s
if p % 2 != 0:
if s <= alpha:
return alpha - 1
if s < m:
beta = min(beta, s)
m = s
return m
def estimation(jeu, p=1):
if game.finJeu(jeu):
g = game.getGagnant(jeu)
if g == monJoueur:
return 1000
else:
return -1000
if p == Pmax:
return evaluation(jeu)
Vmax = float("-inf")
listvaleurs = []
for cp in game.getCoupsValides(jeu):
j = game.getCopieJeu(jeu)
game.joueCoup(j, cp)
listvaleurs.append(estimation(j, p + 1))
avgValue = sum(listvaleurs) / len(listvaleurs)
closestValue = min(listvaleurs, key=lambda x: abs(x - avgValue))
return closestValue
def estimation(jeu, coup, profondeur, alpha, beta):
copie = game.getCopieJeu(jeu)
game.joueCoup(copie, coup)
if game.finJeu(copie):
gagnant = game.getGagnant(copie)
if gagnant == moi:
return 10000
elif gagnant == 0:
return -100
else:
return -10000
if profondeur == PMAX:
return evaluation(copie)
listeCoups = game.getCoupsValides(copie)
if profondeur % 2 == 0: #noeud max
scoremax = -10000000
for c in listeCoups:
score_estime = estimation(copie, c, profondeur + 1,
max(alpha, scoremax), beta)
if score_estime >= beta:
return 10000000
if score_estime > scoremax:
scoremax = score_estime
return scoremax
if profondeur % 2 == 1: #noeud min
scoremin = 10000000
for c in listeCoups:
score_estime = estimation(copie, c, profondeur + 1, alpha,
min(beta, scoremin))
if score_estime <= alpha:
return -10000000
if score_estime < scoremin:
scoremin = score_estime
return scoremin
