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, 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 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 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 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 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, 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 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 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, 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 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 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 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 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 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, 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 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 h4CoupHorizon1(jeu, coup):
if jeu[2][0] == coup:
Leftest = True
else:
Leftest = False
game.joueCoup(jeu, coup)
return jeu[4][joueur - 1]
def h6CoupHorizon1(jeu, coup):
if jeu[2][0] == coup:
Leftest = True
else:
Leftest = False
game.joueCoup(jeu, coup)
return -jeu[4][enemi - 1]
def EvalCoupHorizon1(jeu, coup):
if jeu[2][0] == coup:
Leftest = True
else:
Leftest = False
game.joueCoup(jeu, coup)
return oracle.eval(jeu, coup, Leftest)
def h1CoupHorizon1(jeu,coup):
joueur = jeu[1]
if jeu[2][0]==coup:
Leftest=True
else:
Leftest=False
game.joueCoup(jeu,coup)
return max(jeu[0][joueur-1])
def h3CoupHorizon1(jeu, coup):
if jeu[2][0] == coup:
Leftest = True
else:
Leftest = False
game.joueCoup(jeu, coup)
h3 = len(jeu[2]) if jeu[2] != None else 0
return h3
def h5CoupHorizon1(jeu, coup):
if jeu[2][0] == coup:
Leftest = True
else:
Leftest = False
game.joueCoup(jeu, coup)
h5 = 1 if leftest else 0
return h5
def evaluation(jeu, coup):
j = game.getJoueur(jeu)
game.joueCoup(jeu, coup)
L = game.getScores(jeu)
if j == 1:
a = L[0]
else:
a = L[1]
return a
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 h6CoupHorizon1(jeu,coup):
joueur = jeu[1]
enemi=1 if joueur == 2 else 2
if jeu[2][0]==coup:
Leftest=True
else:
Leftest=False
game.joueCoup(jeu,coup)
return -jeu[4][enemi-1]
def decision(jeu):
valMax = None
cpMax = None
for cp in game.getCoupsValides(jeu):
j = game.getCopieJeu(jeu)
game.joueCoup(j, cp)
val = estimation(j)
if valMax is None or val > valMax:
valMax = val
cpMax = cp
return cpMax
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 h2CoupHorizon1(jeu, coup):
if jeu[2][0] == coup:
Leftest = True
else:
Leftest = False
game.joueCoup(jeu, coup)
h2 = 0
for i in jeu[0][joueur - 1]:
h2 += i
return h2
