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 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 Piege(jeu, joueur):
L = game.getScores(jeu)
eval = 0
j1 = 0
j2 = 0
if (L[0] + L[1] > 48 - 15):
for i in range(0, 6):
j1 = game.getCaseVal(jeu, 0, i)
j2 = game.getCaseVal(jeu, 1, i)
if (joueur == 1):
"""
if game.getCaseVal(jeu,1,1)<=1 and game.getCaseVal(jeu,1,0)==1:
eval=eval+2
"""
eval = eval + j1 - j2
else:
"""
if game.getCaseVal(jeu,0,4)<=1 and game.getCaseVal(jeu,0,5)==1:
eval=eval+2
"""
eval = eval + j2 - j1
return eval
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 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 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 placePion(jeu, joueur):
val = 0
for i in Coin:
if game.getCaseVal(jeu, i[0], i[1]) == joueur:
val = val + ValCoin
elif game.getCaseVal(jeu, i[0], i[1]) == joueur:
val = val + 0
else:
val = val - ValCoin
return val
def VCoin(jeu, joueur):
eval = 0
for i in Coin:
if game.getCaseVal(jeu, i[0], i[1]) == 0:
eval = eval + 0
elif game.getCaseVal(jeu, i[0], i[1]) == joueur:
eval = eval + 1
else:
eval = eval - 1
return eval
def VCoteCoin(jeu, joueur):
eval = 0
for i in CoteCoin:
#while i <len(CoteCoin):
#if (game.getCaseVal(jeu,CoteCoin[i/3][0],getCaseVal(jeu,CoteCoin[i//3][0])
if game.getCaseVal(jeu, i[0], i[1]) == 0:
eval = eval + 0
elif game.getCaseVal(jeu, i[0], i[1]) == joueur:
eval = eval + 1
else:
eval = eval - 1
return eval
def entourageVide(jeu, l, c):
"""Return cases vides autour du parametre case"""
res = []
if (l > 0):
if (game.getCaseVal(jeu, l - 1, c) == 0):
res.append([l - 1, c])
if (c > 0):
if (game.getCaseVal(jeu, l - 1, c - 1) == 0):
res.append([l - 1, c - 1])
if (c < 7):
if (game.getCaseVal(jeu, l - 1, c + 1) == 0):
res.append([l - 1, c + 1])
if (l < 7):
if (game.getCaseVal(jeu, l + 1, c) == 0):
res.append([l + 1, c])
if (c > 0):
if (game.getCaseVal(jeu, l + 1, c - 1) == 0):
res.append([l + 1, c - 1])
if (c < 7):
if (game.getCaseVal(jeu, l + 1, c + 1) == 0):
res.append([l + 1, c + 1])
if (c < 7):
if (game.getCaseVal(jeu, l, c + 1) == 0):
res.append([l, c + 1])
if (c > 0):
if (game.getCaseVal(jeu, l, c - 1) == 0):
res.append([l, c - 1])
return res
def entourageVide(jeu, case):
"""Pair[nat nat] -> Set[str]
Retourne l'ensemble des chaines de caracteres reppresentant des cases vides contigues a la case passee en parametre
"""
ret = set()
l = case[0]
c = case[1]
if (l > 0):
if (game.getCaseVal(jeu, l - 1, c) == 0):
ret.add(str([l - 1, c]))
if (c > 0):
if (game.getCaseVal(jeu, l - 1, c - 1) == 0):
ret.add(str([l - 1, c - 1]))
if (c < 7):
if (game.getCaseVal(jeu, l - 1, c + 1) == 0):
ret.add(str([l - 1, c + 1]))
if (l < 7):
if (game.getCaseVal(jeu, l + 1, c) == 0):
ret.add(str([l + 1, c]))
if (c > 0):
if (game.getCaseVal(jeu, l + 1, c - 1) == 0):
ret.add(str([l + 1, c - 1]))
if (c < 7):
if (game.getCaseVal(jeu, l + 1, c + 1) == 0):
ret.add(str([l + 1, c + 1]))
if (c > 0):
if (game.getCaseVal(jeu, l, c - 1) == 0):
ret.add(str([l, c - 1]))
if (c < 7):
if (game.getCaseVal(jeu, l, c + 1) == 0):
ret.add(str([l, c + 1]))
return ret
def joueCoup(jeu,coup):
v=game.getCaseVal(jeu,coup[0],coup[1])
game.setCaseVal(jeu,coup[0],coup[1],0)
distribue(jeu,coup,v)
game.addCoupJoues(jeu,coup)
jeu[2]=None
game.changeJoueur(jeu)
def estaffame(jeu,joueur) :
testjeu = game.getCopieJeu(jeu)
if joueur==1:
for i in range (6):
coup = [1,i]
game.joueCoup(testjeu,coup)
if ((game.getCaseVal(testjeu,0,i)!=2) and (game.getCaseVal(testjeu,0,i)!=3)):
return False
return True
if joueur==2:
for i in range (6):
coup = [0,i]
game.joueCoup(testjeu,coup)
if ((game.getCaseVal(testjeu,1,i)!=2) and (game.getCaseVal(testjeu,1,i)!=3)):
return False
return True
def f3(jeu):
"""
Retourne le nombre de cases sur les côtés appartenant au joueur
"""
return len([[x, y] for x in range(8) for y in range(8)
if (x == 0 or y == 0 or x == 7 or y == 7)
and game.getCaseVal(jeu, x, y) == 1])
def joueCoup(jeu, coup):
v = game.getCaseVal(jeu, coup[0], coup[1])
game.setCaseVal(jeu, coup[0], coup[1], 0)
distribue(jeu, coup, v)
game.addCoupJoue(jeu, coup)
game.changeJoueur(jeu)
game.resetCoupsValides(jeu)
def retournePieces(jeu, coup, direction):
"""jeu * coup* Pair[int int] -> Pair[nat nat]
Attribue au joueur courant les pieces encadres selon la direction donnee a partir du coup
Retourne le nombre de pieces perdues ou gagnees par chacun des deux joueurs
La direction est definie de la meme maniere que dans la fonction checkEncadrement
"""
ret = [0, 0]
sud = direction[0]
est = direction[1]
l = coup[0]
c = coup[1]
l += sud
c += est
if (l > 7) or (l < 0) or (c > 7) or (c < 0):
raise Exception('Pas d encadrement ici!')
j = game.getJoueur(jeu)
v = game.getCaseVal(jeu, l, c)
if (v == j) or (v == 0):
raise Exception('Pas d encadrement ici !')
game.setCaseVal(jeu, l, c, j)
if (j == 1):
ret[0] += 1
ret[1] -= 1
else:
ret[0] -= 1
ret[1] += 1
while True:
l += sud
c += est
#print str(l)+','+str(c)
if (l > 7) or (l < 0) or (c > 7) or (c < 0):
raise Exception('Pas d encadrement ici !')
v = game.getCaseVal(jeu, l, c)
if (v == 0):
raise Exception('Pas d encadrement ici !')
#print str(v)+','+str(j)
if (v == j):
return ret
else:
game.setCaseVal(jeu, l, c, j)
if (j == 1):
ret[0] += 1
ret[1] -= 1
else:
ret[0] -= 1
ret[1] += 1
return ret
def Krou(jeu, joueur):
eval = 0
for i in range(0, 6):
if game.getCaseVal(jeu, joueur - 1, i) >= 12:
eval = eval + 1
return eval
return case
def joueCoup(jeu, coup) :
"""jeu*coup->jeu
re-initialise le jeu en fonction du coup joue
"""
nb_graines = game.getCaseVal(jeu, coup[0], coup[1])
game.setCaseVal(jeu, coup[0], coup[1], 0)
distribueJeu(jeu, coup, nb_graines)
jeu[3].append(coup)
jeu[2]=None
game.changeJoueur(jeu)
def defense(jeu1, jeu2):
"""
jeu*jeu -> float
Retourne un nombre compris entre [0,1] qui evalue l'effacite d'un coup joue par rapport au nombre de cases à 0 , 1 ou 2 graines chez le joueur
"""
nbCases = 0
for i in range(6):
if game.getCaseVal(jeu2, moi - 1, i) < 3:
nbCases += 1
return 1.0 - float(nbCases) / 6
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
def getCoupsValides (jeu):
coups = []
for i in range(7):
j = 0
while j < 6 and game.getCaseVal(jeu, j, i) == 0:
j += 1
if j != 0:
coups.append([j-1, i])
return coups
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 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 joueCoup(jeu,coup):
"""jeu*coup->void
Joue un coup a l'aide de la fonction distribue
Hypothese:le coup est valide
"""
v=game.getCaseVal(jeu,coup[0],coup[1])
game.setCaseVal(jeu,coup[0],coup[1],0)
distribue(jeu,coup,v)
game.addCoupJoue(jeu,coup)
game.changeJoueur(jeu)
game.razCoupsValides(jeu)
def Bord(jeu, joueur):
eval = 0
for i in range(2, 6):
for j in [0, 7]:
p = game.getCaseVal(jeu, j, i)
if (p == joueur):
eval = eval + 1
elif (p == 0):
continue
else:
eval = eval - 1
for j in [0, 7]:
p = game.getCaseVal(jeu, i, j)
if (p == joueur):
eval = eval + 1
elif (p == 0):
continue
else:
eval = eval - 1
return eval
def coupValide (jeu, coup, affame = False) :
"""jeu*coup*bool -> bool
permet de savoir si un coup est valide"""
nb_graines = game.getCaseVal(jeu, coup[0], coup[1])
if nb_graines == 0 :
return False
if affame : #permet de savoir s'il est possible de nourrir l'adversaire et donc si on doit le faire
if coup[0]==0 :
return nb_graines > coup[1]
else :
return nb_graines > 5-coup[1]
return True
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):
"""adv=jeu[1]%2+1
s=[entourageVide(jeu,l,c)for l in range(8) for c in range(8) if jeu[0][l][c]==adv]
s=reduce(lambda a,b : a|b,s,s)
return 0"""
adv = jeu[1] % 2 + 1
s = []
for l in range(8):
for c in range(8):
for coup in entourageVide(jeu, l, c):
if coup not in s and game.getCaseVal(jeu, l, c) == adv:
s.append(coup)
return s
def joueCoup(jeu, coup):
l,c = distribue(jeu, coup)
save = game.getCopieJeu(jeu)
j = game.getJoueur(jeu)
v = game.getCaseVal(jeu,l, c)
while(l == (j%2) and ((v == 2) or (v == 3))):
#print("in")
jeu[0][l][c] = 0
#print(jeu[0][l][c])
jeu[-1][j-1] += v
#print(jeu[-1][j-1])
l,c = nextCase(l,c,True)
v = game.getCaseVal(jeu, l, c)
if advaffame(jeu):
jeu[0] = save[0]
jeu[-1] = save[-1]
game.changeJoueur(jeu)
jeu[2] = None
jeu[3].append(coup)
def estValide(jeu,coup,checkNourrit=True):
"""jeu*coup*bool->bool
"""
l=coup[0]
c=coup[1]
g=game.getCaseVal(jeu,l,c)
if(g==0):
return False
if(checkNourrit):
if(l==0):
return (g>c)
else:
return (g>(5-c))
return True
