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 saisieCoup(jeu):
""" jeu -> coup
JOUEUR ALEATOIRE: Retourne un random coup a jouer
"""
return game.getCoupsValides(jeu)[random.randrange(
len(game.getCoupsValides(jeu)))]
def func3(jeu,liste):
""" jeu -> int
Mobilite
"""
cvAdv = game.getCoupsValides(jeu)
game.changeJoueur(jeu)
cvMoi = game.getCoupsValides(jeu)
game.changeJoueur(jeu)
if (game.getJoueur == moi and (cvMoi+cvAdv != 0)):
return (cvMoi-cvAdv)/(cvMoi+cvAdv)
return 0
def f3(jeu, liste):
""" jeu -> int
Mobilite, voir porté des coups que je pourrais joué par la suite
% de nbre de coup valide que j'ai par rapport a tous les coups valides de l'ennemie
"""
coupsValAdv = game.getCoupsValides(jeu)
game.changeJoueur(jeu)
coupsValMoi = game.getCoupsValides(jeu)
if (game.getJoueur == moi and (coupsValMoi + coupsValAdv != 0)):
return 100 * (
(coupsValMoi - coupsValAdv) / (coupsValMoi + coupsValAdv)
) #restreint la mobilité de l'adversaissaire; pousser a avoir moin possibilité de coup.
return 0
def saisieCoup(jeu):
""" jeu -> coup
Retourne un coup a jouer
"""
print("Coups valides: ", game.getCoupsValides(jeu))
ligneJoueur = game.getJoueur(jeu) - 1
colonne = int(input("Votre colonne:"))
while ((ligneJoueur, colonne) not in game.getCoupsValides(jeu)):
colonne = int(input("Coup invalid ! Votre colonne:"))
return (ligneJoueur, colonne)
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, 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, 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 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 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 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):
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 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, 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 finJeu(jeu):
if len(jeu[3]) > 100 or game.getCoupsValides(
jeu) == [] or jeu[-1][0] >= 25 or jeu[-1][1] >= 25:
return True
else:
return False
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 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 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 saisieCoup(jeu):
global debut_j,moi
#debut_j=game.getCopieJeu(jeu)
moi = game.getJoueur(jeu)
#adv=game.getJoueurAdverse(jeu)
coup = decision(jeu , game.getCoupsValides(jeu))
return coup
def finJeu(jeu):
res = alignes(jeu)
if game.getCoupsValides(jeu) == [] or res != 0:
jeu[-1][res - 1] = 10000000
return True
else:
return False
def saisieCoup(jeu):
""" jeu -> coup
Retourne un coup a jouer
"""
print("Les coups valides sont:")
print(str(game.getCoupsValides(jeu)))
i = int(input("Entrer la colonne du coup à jouer: "))
return [jeu[1] - 1, i]
def saisieCoup(jeu):
""" jeu -> coup
Retourne un coup a jouer
"""
global moi
moi = game.getJoueur(jeu)
coup = decision(jeu, game.getCoupsValides(jeu))
return coup
def saisieCoup(jeu):
""" jeu -> coup
Retourne un coup a jouer
"""
"""
colonne = random.randint(0, len(game.getCoupsValides(jeu))-1)
print(len(game.getCoupsValides(jeu))-1, colonne)
"""
return game.getCoupsValides(jeu)[0]
def saisieCoup(jeu):
""" jeu -> coup
Retourne un coup a jouer
"""
global moi, lautre, tours, coeff1, coeff2, coeff3
moi = game.getJoueur(jeu)
lautre = moi % 2 + 1
coup = decision(jeu, game.getCoupsValides(jeu))
return coup
def f3(jeu):
""" jeu -> int
Mobilite
"""
cv = game.getCoupsValides(jeu)
if game.getJoueur(jeu) == moi:
return len(cv)
else:
return -len(cv)
def saisieCoup(jeu):
""" jeu -> coup
Le coup a jouer apres calcul
"""
global moi, adv
moi = game.getJoueur(jeu)
adv = moi % 2 + 1
coup = decision(jeu, game.getCoupsValides(jeu))
return coup
def saisieCoup(jeu):
""" jeu -> coup
Retourne un coup a jouer
"""
global debut_j, moi
#debut_j = game.getCopieJeu(jeu)#copie
moi = game.getJoueur(jeu)
#adv = game.getJoueurAdverse(jeu)
adv = moi % 2 + 1
coup = decision(jeu, game.getCoupsValides(jeu))
return coup
def saisieCoup(jeu):
""" jeu -> coup
Retourne un coup a jouer
"""
"""
colonne = random.randint(0, len(game.getCoupsValides(jeu))-1)
print(len(game.getCoupsValides(jeu))-1, colonne)
"""
#print(game.getCoupsValides(jeu))
return random.choice(game.getCoupsValides(jeu))
#return (game.getJoueur(jeu) - 1, colonne)
