def saisieCoup(jeu):
""" jeu-> coup
retourne un coup a jouer
"""
c = input("joueur" + str(game.getJoueur(jeu)) + ": quelle colonne?")
coup = [game.getJoueur(jeu) - 1, c]
while (not (game.coupValide(jeu, coup))):
c = input("coup non valide recommencer")
coup = (game.getJoueur(jeu) - 1, c)
return coup
def nourrit(jeu, coup):
"""Retourne true si le coup peut nourrir l'adv, faux sinon"""
j = game.getJoueur(jeu)
if (j == 1):
return coup[1] < game.getCaseVal(jeu, coup[0], coup[1])
return game.getCaseVal(jeu, coup[0], coup[1]) > (5 - coup[1])
def joueCoup(jeu, coup):
game.addCoupJoue(jeu, coup)
j = game.getJoueur(jeu)
s = jeu[-1]
e = encadrements(jeu,coup,True)
adv = (j%2) + 1
game.setCaseVal(jeu, coup[0], coup[1], j)
for d in e:
l = coup[0]
c = coup[1]
while True :
l+=d[0]
c+=d[1]
if game.getCaseVal(jeu,l,c)==j :
break
game.setCaseVal(jeu,l,c,j)
s[j-1]+=1
s[adv-1]-=1
jeu[-1] = [0, 0]
for i in range(8):
for j in range(8):
sc = game.getCaseVal(jeu, i, j)
if (sc != 0):
jeu[-1][sc - 1] += 1
game.changeJoueur(jeu)
game.resetCoupsValides(jeu)
def checkEncadrementDirection(jeu, l, c, sud, est):
"""jeu*nat*nat*nat*nat*nat->bool
Verifie si a partir d'une case l+sud,c+est de l'adversaire on peut trouver des pions au joueur courant dans la direction donnee avant de tomber sur une case vide
Retourne False si l,c n'appartient pas a l'adversaire
si sud est 1, on se deplace vers le bas
si sud est -1, on se deplace vers le haut
si est est 1, on se deplace vers la droite
si est est -1, on se deplace vers la gauche
"""
l += sud
c += est
if (l > 7) or (l < 0) or (c > 7) or (c < 0):
return False
j = game.getJoueur(jeu)
v = game.getCaseVal(jeu, l, c)
if (v == j) or (v == 0):
return False
while True:
l += sud
c += est
#print str(l)+','+str(c)
if (l > 7) or (l < 0) or (c > 7) or (c < 0):
return False
v = game.getCaseVal(jeu, l, c)
if (v == 0):
return False
if (v == j):
return True
return False
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 getCoupsValides (jeu) :
"""jeu->list(coups)
renvoie la liste des coups valides
"""
joueur = game.getJoueur(jeu)
a = estAffame(jeu,game.getAdversaire(jeu))
return [[joueur-1, coup] for coup in range(6) if coupValide(jeu, [joueur-1, coup], a)]
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 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 advaffame(jeu):
""" jeu -> bool
checks if the opponent starves (his row is 0)
"""
j = game.getJoueur(jeu)
adv = j%2+1
return sum(jeu[0][adv-1]) == 0
def nourrit(jeu, coup):
""" jeu, coup -> bool
checks if a coup reaches opponents row
"""
j = game.getJoueur(jeu)
if (j==1):
return coup[1]<game.getCaseVal(jeu, coup[0], coup[1])
return game.getCaseVal(jeu, coup[0], coup[1]) + coup[1] > 5
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 saisieCoup(jeu):
""" jeu -> coup
Retourne un coup a jouer
"""
global monJoueur
monJoueur = game.getJoueur(jeu)
return decisionAB(jeu)
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 f3(jeu):
""" jeu -> int
Mobilite
"""
cv = game.getCoupsValides(jeu)
if game.getJoueur(jeu) == moi:
return len(cv)
else:
return -len(cv)
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 joueCoup(jeu, cp):
jeu[0][cp[0]][cp[1]] = jeu[1]
jeu[4][game.getJoueur(jeu) - 1] += 1
d = getEncadrements(jeu, cp)
for x in d:
returnPions(jeu, cp, x)
jeu[3].append(cp)
jeu[2] = None
jeu[1] = jeu[1] % 2 + 1
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 joueCoup(jeu, coup):
game.addCoupJoue(jeu, coup)
j = game.getJoueur(jeu)
i = 0
while i < 6 and game.getCaseVal(jeu, i, coup[1]) == 0:
i += 1
game.setCaseVal(jeu, i - 1, coup[1], j)
game.changeJoueur(jeu)
game.resetCoupsValides(jeu)
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 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 adversaireAffame(jeu):
"""jeu->bool
Retourne vrai si l'adversaire n'a aucune graine dans son jeu
"""
j=game.getJoueur(jeu)
j=j%2+1
for i in range(0,6):
x=game.getCaseVal(jeu,j-1,i)
if x!=0:
return False
return True
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
"""
j=game.getJoueur(jeu)
global moi
moi=j
global scores
scores=game.getScores(jeu)
l=game.getCoupsValides(jeu)
return decision(jeu,l)
def peutManger(jeu,c):
"""jeu * Pair[nat nat] -> bool
Retourne vrai si on peut manger le contenu de la case:
- c'est une case appartenant a l'adversaire du joueur courant
- La case contient 2 ou 3 graines
"""
if c[0]==(game.getJoueur(jeu)-1):
return False
v=game.getCaseVal(jeu,c[0],c[1])
if(v!=2) and (v!=3):
return False
return True
def coups(jeu):
c = []
a = game.getJoueur(jeu)
a = a%1+1
for i in range (8):
for j in range(8):
if(jeu[0][i][j]==0):
for k in [-1,0,1]:
for l in [-1,0,1]:
if( (i+k)>=0 and (i+k)<8 and (j+l)>=0 and (j+l)<8 ):
if(jeu[0][i+k][i+l]==a):
c.append([i,j])
return c
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 returnPions(jeu, cp, x):
""" jeu->void
retourne les pions dans la direction x
"""
joueur = game.getJoueur(jeu)
while (jeu[0][cp[0] + x[0]][cp[1] + x[1]] == joueur % 2 + 1):
jeu[0][cp[0] + x[0]][cp[1] + x[1]] = joueur
jeu[4][joueur - 1] += 1
jeu[4][joueur % 2] -= 1
cp = cp[0] + x[0], cp[1] + x[1]
def decision(jeu,coupsV):
global moi,adv
moi = game.getJoueur(jeu)
adv = game.getJoueurAdverse(jeu)
#coup=coupsV[0]
maxi =-1234567
for c in coupsV:
est = estimation(jeu,c, 1)
#print ("Decision",c,s)
if est >= maxi:
maxi=est
coup = c
return coup
def getCoupValides(jeu):
def coupValide(jeu,coup,checknourrit):
v=game.getCaseVal(jeu,coup[0],coup[1])
if v==0:
return False
if checknourrit:
if coup[0]==0:
return v>coup[1]
else:
return v>5-coup[1]
return True
j=game.getJoueur(jeu)
a=estaffame(jeu,j%2+1)
return [[j-1,c]for c in range(6) if coupValide(jeu,[j-1,c],a)]