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 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 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 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 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():
"""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 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 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 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 Entrainement(ev, alpha):
nbrepartie = 0
j1 = 0
j2 = 0
it = 0
j = 1
while (nbrepartie < NBPARTIE):
if (nbrepartie == NBPARTIE / 2):
j = 2
jeu = game.initialiseJeu()
while (it < 100 or game.finJeu(jeu)):
if (game.getJoueur == j):
coupElv = eleve.saisieCoup(game.getCopieJeu(jeu), ev)
coupM = maitre.saisieCoup(game.getCopieJeu(jeu))
if (coupElv == coupM):
game.saisieCoup(coupElv)
else:
print "mauvais"
game.saisiecoup(eleve.saisieCoup(game.getCopieJeu(jeu), ev))
else:
game.saisieCoup(sparing.saisieCoup(jeu))
it += 1
j = 1
nbrepartie += 1
if (g == 1):
j1 += 1
if (g == 2):
j2 += 1
if (g == 0):
eg += 1
nbrepartie += 1
print("score final :\nj1: " + str(j2) + "\nj2: " + str(j1) +
"\nnb d'equalite : " + str(eg))
print ev
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)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import awele
import sys
sys.path.append("..")
import game
game.game = awele
sys.path.append("./Joueurs")
import joueur_humain
game.joueur1 = joueur_humain
game.joueur2 = joueur_humain
jeu = game.initialiseJeu()
game.affiche(jeu)
print("coups valides pour le joueur", jeu[1], ":", game.getCoupsValides(jeu))
def apprentissageSupervise():
a = 0.1
jeux = 1
while True:
jeuInit = game.initialiseJeu()
game.joueur1 = student
game.joueur2 = joueur_alphabeta
eleve = game.joueur1
nbCoupsTourne1 = 0
nbCoupsImite1 = 0
turn = 0
while not game.finJeu(jeuInit):
if game.getJoueur(jeuInit) == 1: #monJoueur == 1
coups = game.getCoupsValides(jeuInit)
prof_coups = []
alpha = float("-inf")
beta = float("inf")
#on joue l'oracle
for c in coups:
#print("FOR1")
j = game.getCopieJeu(jeuInit)
oracle.monJoueur = game.getJoueur(j)
game.joueCoup(j, c)
#liste des scores de oracle
val = oracle.estimationBetaMin(j, alpha, beta)
prof_coups.append(val)
alpha = max(val, alpha)
opt_max_index = prof_coups.index(
max(prof_coups)) #index de score maximal
opt = coups[
opt_max_index] #coup avec score maximal (meilleur coup)
#потегот оракл што го направил, ние земаме и одлучуваме дека е најдобар и го играме
copy_opt = game.getCopieJeu(jeuInit)
eleve.monJoueur = game.getJoueur(
copy_opt
) #on change la variable globale dans le fichier eleve (utilise dans saisie coup)
game.joueCoup(
copy_opt, opt
) #eleve joue meilleur coup d'oracle. On utilise copy_opt dans l'evaluation
#trouver lest coups possibles tq o(c)<o(opt)
coups_a_jouer = []
for i in range(len(coups)):
#on cree la liste o(c) < o(opt)
#print("FOR2")
if prof_coups[i] < prof_coups[opt_max_index]:
coups_a_jouer.append(coups[i])
for cp in coups_a_jouer:
#print('asdasd')
copie = game.getCopieJeu(jeuInit)
eleve.monJoueur = game.getJoueur(copie)
game.joueCoup(copie, cp)
o = eleve.evaluation(
copy_opt
) #evaluacija na eleve za najdobriot poteg na oracle
s = eleve.evaluation(
copie) #evaluacijata na eleve za polosite potezi
changedParam = []
nbCoupsTourne1 += 1
if (o - s) < 1:
for j in range(len(eleve.coefficients)):
scjo = eleve.scores(copy_opt)[j]
scjc = eleve.scores(copie)[j]
changedParam.append(eleve.coefficients[j] - a *
(scjc - scjo))
eleve.setParameters(changedParam)
else:
nbCoupsImite1 += 1 #tie coups sto ne se koregirani sto se dobri.
#procent kolku coups ne se koregirani od oracle, sto znaci deka se imitirani
#print(prof_coups)
#print(coups_a_jouer)
if (turn > 4):
coupJoueEleve = eleve.saisieCoup(jeuInit)
else:
coupJoueEleve = joueur_random.saisieCoup(jeuInit)
game.joueCoup(jeuInit, coupJoueEleve)
turn += 1
else:
if (turn > 4):
game.joueCoup(jeuInit, game.joueur2.saisieCoup(jeuInit))
else:
game.joueCoup(jeuInit, joueur_random.saisieCoup(jeuInit))
#print("------",jeux,"------")
#print("a=",a)
#print(eleve.coefficients)
#print("eleve vs alphabeta: ",game.getScores(jeuInit))
#print("Coups imite ", nbCoupsImite1," NbTournes ", nbCoupsTourne1 ," % ", (nbCoupsImite1/nbCoupsTourne1)*100)
a *= 0.999
#print()
if (game.getGagnant(jeuInit) == 1):
gagne = 1
else:
gagne = 0
print(nbCoupsTourne1)
print(jeux, ";1;", (nbCoupsImite1 / nbCoupsTourne1) * 100, ";", gagne,
";", eleve.coefficients)
###################################################################################################
jeuInit = game.initialiseJeu()
game.joueur1 = joueur_alphabeta
game.joueur2 = student
eleve = game.joueur2
nbCoupsTourne2 = 0
nbCoupsImite2 = 0
turn = 0
while not game.finJeu(jeuInit):
if game.getJoueur(jeuInit) == 2: #monJoueur == 1
coups = game.getCoupsValides(jeuInit)
prof_coups = []
alpha = float("-inf")
beta = float("inf")
#on joue l'oracle
for c in coups:
#print("FOR1")
j = game.getCopieJeu(jeuInit)
oracle.monJoueur = game.getJoueur(j)
game.joueCoup(j, c)
#liste des scores de oracle
val = oracle.estimationBetaMin(j, alpha, beta)
prof_coups.append(val)
alpha = max(val, alpha)
opt_max_index = prof_coups.index(
max(prof_coups)) #index de score maximal
opt = coups[
opt_max_index] #coup avec score maximal (meilleur coup)
#потегот оракл што го направил, ние земаме и одлучуваме дека е најдобар и го играме
copy_opt = game.getCopieJeu(jeuInit)
eleve.monJoueur = game.getJoueur(
copy_opt
) #on change la variable globale dans le fichier eleve (utilise dans saisie coup)
game.joueCoup(
copy_opt, opt
) #eleve joue meilleur coup d'oracle. On utilise copy_opt dans l'evaluation
#trouver lest coups possibles tq o(c)<o(opt)
coups_a_jouer = []
for i in range(len(coups)):
#on cree la liste o(c) < o(opt)
#print("FOR2")
if prof_coups[i] < prof_coups[opt_max_index]:
coups_a_jouer.append(coups[i])
for cp in coups_a_jouer:
#print('asdasd')
copie = game.getCopieJeu(jeuInit)
eleve.monJoueur = game.getJoueur(copie)
game.joueCoup(copie, cp)
o = eleve.evaluation(
copy_opt
) #evaluacija na eleve za najdobriot poteg na oracle
s = eleve.evaluation(
copie) #evaluacijata na eleve za polosite potezi
changedParam = []
nbCoupsTourne2 += 1
if (o - s) < 1:
for j in range(len(eleve.coefficients)):
scjo = eleve.scores(copy_opt)[j]
scjc = eleve.scores(copie)[j]
changedParam.append(eleve.coefficients[j] - a *
(scjc - scjo))
eleve.setParameters(changedParam)
else:
nbCoupsImite2 += 1 #tie coups sto ne se koregirani sto se dobri.
#procent kolku coups ne se koregirani od oracle, sto znaci deka se imitirani
#print(prof_coups)
#print(coups_a_jouer)
if (turn > 4):
coupJoueEleve = eleve.saisieCoup(jeuInit)
else:
coupJoueEleve = joueur_random.saisieCoup(jeuInit)
game.joueCoup(jeuInit, coupJoueEleve)
turn += 1
else:
if (turn > 4):
game.joueCoup(jeuInit, game.joueur2.saisieCoup(jeuInit))
else:
game.joueCoup(jeuInit, joueur_random.saisieCoup(jeuInit))
#print("------",jeux,"------")
#print("a=",a)
#print(eleve.coefficients)
#print("alphabeta vs eleve",game.getScores(jeuInit))
#print("Coups imite ", nbCoupsImite2," NbTournes ", nbCoupsTourne2 ," % ", (nbCoupsImite2/nbCoupsTourne2)*100)
a *= 0.999
#print()
if (game.getGagnant(jeuInit) == 1):
gagne = 0
else:
gagne = 1
print(jeux, ";2;", (nbCoupsImite2 / nbCoupsTourne2) * 100, ";", gagne,
";", eleve.coefficients)
jeux += 1
#nbc (nombre de coups joues en moyenne)
victoiresj1 = []
victoiresj2 = []
profondeur = []
winsPlayer1, winsPlayer2, j1, j2, scoreMoyen1, scoreMoyen2, nbc, matchNul = 0, 0, 1, 2, 0, 0, 0, 0
for k in range(3): #assigne nos joueur
game.joueur1 = Vesemir
game.joueur2 = othello_PremierCoupValide
game.joueurinter1 = game.joueur1 #assigne joueur intermediaire
game.joueurinter2 = game.joueur2
winsPlayer1, winsPlayer2, j1, j2, scoreMoyen1, scoreMoyen2, nbc, matchNul = 0, 0, 1, 2, 0, 0, 0, 0
for i in range(1, n + 1):
game.joueur1 = othello_alea #coup aleatoire
game.joueur2 = othello_alea
jeu = game.initialiseJeu() #demarre jeu
while not game.finJeu(jeu):
coup = game.saisieCoup(jeu)
game.joueCoup(jeu, coup)
if len(game.getCoupsJoues(jeu)) == 4: #fin coup aleatoire
game.joueur1 = game.joueurinter1
game.joueur2 = game.joueurinter2
if game.getGagnant(jeu) == j1: #compte vicoire j1
winsPlayer1 += 1
elif game.getGagnant(jeu) == j2: #compte vicoire j2
winsPlayer2 += 1
else: #♀compte match nul
matchNul += 1
scoreMoyen1 += game.getScore(
jeu,
j1) #additionne les scores de j1 puis va diviser par n ensuite
