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 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 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 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 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 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 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 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 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 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 joueCoup(jeu, coup):
"""jeu*coup->void
Joue un coup:
- Cherche toutes les directions d'encadrement
- Pour toutes les directions trouvees, lance la fonction retournePieces pour retourner les pieces encadrees
- Met a jour les scores selon le nombre de pieces retournees
Hypothese:le coup est valide
"""
l = trouveEncadrements(jeu, coup)
a = [retournePieces(jeu, coup, x) for x in l]
j = game.getJoueur(jeu)
sc = [0, 0]
if (j == 1):
sc[0] = 1
else:
sc[1] += 1
game.setCaseVal(jeu, coup[0], coup[1], j)
s = reduce(lambda x, y: [x[0] + y[0], x[1] + y[1]], a, sc)
game.addScore(jeu, 1, s[0])
game.addScore(jeu, 2, s[1])
game.addCoupJoue(jeu, coup)
game.changeJoueur(jeu)
game.razCoupsValides(jeu)
def joueCoup(jeu, coup):
"""
jeu[0][coup[0]][coup[1]]=jeu[1]
jeu[4][jeu[1]]+=1 #ajout de points au score
d=getEncadrements(jeu,coup,True)
for x in d:
retournePions(jeu,coup,d)
jeu[3].append(coup)
jeu[2]=None
jeu[1]=jeu[1]%2+1
global r
version:
"""
#retournePions(jeu,coup,d)
j = game.getJoueur(jeu)
adv = game.getJoueurAdverse(jeu)
score = game.getScores(jeu)
enca = getEncadrements(jeu, coup, True)
for d in enca:
l = coup[0]
c = coup[1]
game.setCaseVal(jeu, l, c, j)
while True:
l += d[0]
c += d[1]
if game.getCaseVal(jeu, l, c) == j:
break
game.setCaseVal(jeu, l, c, j)
score[j - 1] += 1
score[adv - 1] -= 1
game.setPlayerScore(jeu, j, score[j - 1] + 1)
game.setPlayerScore(jeu, adv, score[adv - 1])
game.changeJoueur(jeu)
jeu[3] = []
"""
adversaire = joueur % 2 + 1
game.setCaseVal(jeu, coup[0], coup[1], joueur)
jeu[4][joueur - 1] += 1
#print "encadrement :{}".format(encadrements(jeu, coup, True))
for d in encadrements(jeu, coup, True):
#print "direction :{}".format(d)
case = [coup[0], coup[1]]
case[0] += d[0]
case[1] += d[1]
while game.getCaseVal(jeu, case[0], case[1]) == adversaire:
game.setCaseVal(jeu, case[0], case[1], joueur)
#print "case retournee :{}".format(jeu[0][case[0]][case[1]])
#print "case : {}".format (case)
jeu[4][joueur - 1] += 1
jeu[4][adversaire - 1] -= 1
game.changeJoueur(jeu)
jeu[2] = None
def finPartie(jeu):
"""jeu->bool
retourne vrai si la fin du jeu est atteinte, false sinon"""
if game.getCoupsValides == []:
return True
fin_atteinte = True
for i in range(8):
for j in range(8):
if jeu[0][i][j] == 0:
fin_atteinte = False
