def play():
jeu = game.initialiseJeu()
while len(jeu[3]) < 4:
valides = game.getCoupsValides(jeu)
if game.finJeu(jeu):
break
if len(valides) != 0:
coup = random.choice(valides)
game.joueCoup(jeu, coup)
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 fitness(jeu)
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 saisieCoupSimuMin(profondeur, jeu, coup):
""" jeu -> coup
Retourne un coup a jouer aleatoire
"""
game.joueCoup(jeu, coup)
if profondeur == 0:
return eval(jeu)
valides = game.getCoupsValides(jeu)
if game.finJeu(jeu):
return eval(jeu)
else:
global joueur
imin = 0
mini = 1000
for i in range(len(jeu[2])):
score = saisieCoupSimuMax(profondeur - 1, game.getCopieJeu(jeu),
jeu[2][i])
if score < mini:
mini = score
imin = i
return jeu[2][imin]
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, 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 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 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 saisieCoupSimuMax(profondeur, jeu, coup):
""" jeu -> coup
Retourne un coup a jouer aleatoire
"""
game.joueCoup(jeu, coup)
valides = game.getCoupsValides(jeu)
if profondeur == 0 or game.finJeu(jeu):
return eval(jeu)
else:
global joueur
maxi = -1000
for i in range(len(jeu[2])):
score = saisieCoupSimuMin(profondeur - 1, game.getCopieJeu(jeu),
jeu[2][i])
if score > maxi:
maxi = score
return maxi
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 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 CoupMin(profondeur, jeu, coup):
""" jeu -> coup
Retourne un coup a jouer aleatoire
"""
game.joueCoup(jeu, coup)
valides = game.getCoupsValides(jeu)
if profondeur == 0 or game.finJeu(jeu):
return eval(jeu)
else:
global Alpha
global Beta
score = 10000
for i in range(len(jeu[2])):
score = min(
score, CoupMax(profondeur - 1, game.getCopieJeu(jeu),
jeu[2][i]))
if score <= Alpha:
return score
Beta = min(Beta, score)
return score
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 CoupMax(profondeur, jeu, coup, leftest):
""" jeu -> coup
Retourne un coup a jouer aleatoire
"""
game.joueCoup(jeu, coup)
valides = game.getCoupsValides(jeu)
if game.finJeu(jeu) or profondeur == 0:
return eval(jeu, coup, leftest)
else:
global Alpha
global Beta
score = -10000
leftest = True
for i in range(len(jeu[2])):
score = max(
score,
CoupMin(profondeur - 1, game.getCopieJeu(jeu), jeu[2][i],
leftest))
leftest = False
if score >= Beta:
return score
Alpha = max(Alpha, score)
return score
def estimation(jeu,coup,prof):
""" jeu * coup * prof -> number
Estime la valeur d'un coup
"""
global nbNoeuds
nbNoeuds+=1
copie=game.getCopieJeu(jeu)
game.joueCoup(copie,coup)
if(game.finJeu(copie)):
#A Completer
return evaluation(copie)
def evaluation(jeu):
""" jeu->number
evalue une situation de jeu pour le joueur moi
"""
l=getEvals(jeu)
return dotProduct(l,params)
def dotProduct(l1,l2):
#A Completer
def getEvals(jeu):
return [evalScores(jeu),evalPos(jeu)]
def evalScores(jeu):
""" jeu -> List[number}
evalue une situation de jeu en faisant la difference entre le score de moi et le score de l'adversaire
"""
autre=moi%2+1
sc=game.getScores(jeu)
return sc[moi-1]-sc[autre-1]
def evalPos(jeu):
diffExtr = 0
p = 0.8
plateau=game.getPlateau(jeu)
j1=0
j2=0
ligne=plateau[0]
ligne2=plateau[1]
for i in range(6):
j1 += p * ligne[i]
j2 += p * ligne2[-i-1]
p-=0.1
diffExtr=j1-j2
if(moi==2):
diffExtr=-diffExtr
return diffExtr
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 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:#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 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 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 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 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 saisieCoupSimuMin(profondeur, jeu, coup):
""" jeu -> coup
Retourne un coup a jouer aleatoire
"""
global joueur
Pscore = jeu[4][joueur]
game.joueCoup(jeu, coup)
valides = game.getCoupsValides(jeu)
if profondeur == 0 or game.finJeu(jeu):
return eval(coup)
else:
score = []
for i in range(len(jeu[2])):
score.append(
saisieCoupSimuMax(profondeur - 1, game.getCopieJeu(jeu),
jeu[2][i]))
estimate = []
si = 0
for s in score:
i = s - 639
si += i
estimate.append(i)
for ie in range(len(estimate)):
estimate[ie] = estimate[ie] * 1.0 / si * 1.0
finalScore = 0
for fi in range(len(estimate)):
score[fi] = score[fi] * 1.0 * estimate[fi]
finalScore += score[fi]
return finalScore
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 saisieCoupSimuNegaBeta(profondeur, jeu, coup):
""" jeu -> coup
Retourne un coup a jouer aleatoire
"""
global enemi
global PROFONDEUR
ScorePrecedent = jeu[4]
game.joueCoup(jeu, coup)
valides = game.getCoupsValides(jeu)
if profondeur == PROFONDEUR or game.finJeu(jeu):
if profondeur % 2 == 0:
return eval(jeu, ScorePrecedent)
else:
return -eval(jeu, ScorePrecedent)
else:
global precedent
imax = 0
maxi = -1000
for i in range(len(jeu[2])):
score = saisieCoupSimuNegaBeta(profondeur + 1,
game.getCopieJeu(jeu), jeu[2][i])
if score >= precedent:
return calcul(
score, (jeu[4][joueur - 1] - ScorePrecedent[joueur - 1] -
jeu[4][enemi - 1] - ScorePrecedent[enemi - 1]))
elif score > maxi:
maxi = score
precedent = max
return calcul(maxi, (jeu[4][joueur - 1] - ScorePrecedent[joueur - 1] -
jeu[4][enemi - 1] - ScorePrecedent[enemi - 1]))
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