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 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 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 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 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 manger (jeu,coup):
"""
jeu*coup->jeu
mange les graines de l'adversaire si c'est possible et renvoie le jeu modifie
"""
jeu_bis=game.getCopieJeu(jeu)
case_val = game.getCaseVal(jeu,coup[0],coup[1])
while (case_val== 2) or (case_val== 3) and jeu[0][1]==game.getAdversaire(jeu)-1 :
#print "valeur de la case a manger : {}, coordonnees {}".format(case_val, coup)
jeu[4][jeu[1]-1] += case_val #mise a jour du score
#print "score : {}".format (jeu[4][jeu[1]-1])
#game.setCaseVal(jeu_bis, coup_bis[0], coup_bis[1],0)
jeu[0][coup[0]][coup[1]] = 0
#print "case mangee? : {}, coordonnees {}".format(jeu[0][coup[0]][coup[1]], coup)
if coup[0]==0 : #cas ou le joueur 2 mange
if coup[1]<5:
coup[1]+=1
else : #cas ou le joueur 1 mange
if coup [1]>0:
coup[1]-=1
case_val = game.getCaseVal(jeu,coup[0],coup[1])
#print "valeur de la nouvelle case a manger : {}, coordonnees {}".format(case_val, coup)
if estAffame(jeu, game.getAdversaire(jeu)) :
#print "on n'a pas pu manger"
for i in range(5):
jeu[i]=jeu_bis[i]
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 getCoupsValides(jeu):
"""jeu -> List[coup]
retourne la liste des coups valide a partir du plateau du jeu awele
"""
liste_coups_valides = []
camp_joueur = jeu.joueur - 1
# Boucle qui parcourt chaque trou du joueur qui va jouer
for t in range(colonnes):
# Si il y a des graines
if (jeu.plat.plateau[camp_joueur][t] > 0):
# test si le coup affame l'autre joueur
jeu_test = game.getCopieJeu(jeu)
Coup = game.coup(camp_joueur, t)
updatePlateauScore(jeu_test, Coup)
game.changeJoueur(jeu_test)
LautreCamp = jeu_test.joueur - 1
C = 0
compteur = 0
while (C < colonnes and jeu_test.plat.plateau[LautreCamp][C] == 0):
compteur += 1
C += 1
# si il ne l'affame pas alors c'est un coup valide
if (compteur != colonnes):
liste_coups_valides.append(Coup)
return liste_coups_valides
#def finJeu(jeu):
""" jeu -> bool
Retourne vrai si c'est la fin du jeu
"""
#test si un des deux camps n'est pas vide
"""res = [0,0]
def saisieCoup(jeu):
""" jeu -> coup
Retourne un coup a jouer aleatoire
"""
global joueur
joueur = jeu[1]
maxi = -10000
imax = 0
score = -10000
leftest = True
for i in range(len(jeu[2])):
score = CoupMin(5, game.getCopieJeu(jeu), jeu[2][i], leftest)
leftest = False
if score > maxi:
maxi = score
imax = i
return jeu[2][imax]
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 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):
#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 decision(jeu, ev):
joueur = game.getJoueur(jeu)
L = game.getCoupsValides(jeu)
J = []
alpha = -5000000
beta = 5000000
challenger = 0
i = 0
if (joueur == 1):
i = len(L) - 1
ok = 0
while (ok == 0):
l = estimation(game.getCopieJeu(jeu), L[i], 1, joueur, alpha, beta, ev)
if (l > alpha):
alpha = l
challenger = i
if (joueur == 1):
i -= 1
if (i < 0):
ok = 1
else:
i += 1
if (i >= len(L)):
ok = 1
#J.append(l)
#jeu2=game.getCopieJeu(jeu)
#while i< len (J):
# if(J[challenger]<J[i]):
# challenger=i
# i=i+1
return L[challenger]
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 decision(jeu):
joueur = game.getJoueur(jeu)
L = game.getCoupsValides(jeu)
J = []
alpha = -5000000
beta = 5000000
challenger = 0
i = 0
if (joueur == 1):
i = len(L) - 1
ok = 0
while (ok == 0):
l = estimation(game.getCopieJeu(jeu), L[i], 1, joueur, alpha, beta)
if (l > alpha):
alpha = l
challenger = i
if (joueur == 1):
i -= 1
if (i < 0):
ok = 1
else:
i += 1
if (i >= len(L)):
ok = 1
return L[challenger]
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 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 saisieCoupTr(jeu, ev):
j = game.getJoueur(jeu)
if (j == 1):
j = joueur1
else:
j = joueur2
coup = j.saisieCoup(game.getCopieJeu(jeu), ev)
return coup
def decision(jeu):
L = game.getCoupsValides(jeu)
J = []
jeu2 = game.getCopieJeu(jeu)
for i in range(0, len(L)):
game.joueCoup(jeu2, L[i])
l = evaluation(game.getCopieJeu(jeu), L[i])
J.append(l)
jeu2 = game.getCopieJeu(jeu)
challenger = 0
i = 1
while i < len(J):
if (J[challenger] < J[i]):
challenger = i
i = i + 1
return L[challenger]
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 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 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 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 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 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)
