1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
| ############################################################################
# # # #
# # Les imports # #
# # # #
############################################################################
# NumPy: est une extension du langage de programmation Python, destinee a #
# manipuler des matrices ou tableaux multidimensionnels ainsi que des #
# fonctions mathematiques operant sur ces tableaux. #
# Random: est un module qui implement des generateurs de nombres pseudo- #
# aleatoires pour diverses distributions. #
############################################################################
import numpy
import random
############################################################################
# # # #
# # Entrees/Sorties # #
# # # #
############################################################################
## Affichage de la grille de jeux:
#Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
#Resultat: La grille de jeux sans les crochets, la grille est retournee verticalement.
# Puis ajout d'une ligne avec les numeros des colonnes.
# Pour que le joueur sache a quel nombre correspond chaque colonne.
def Afficher_Grille(Grille):
Grille = numpy.flip(Grille, 0) #Retourne la grille verticalement.
for i in Grille: #Pour chaque rangee de la grille ([0 0 0 0 0 0 0]).
for j in i: #Pour chaque contennue de chaque rangee (0 0 0 0 0 0 0).
print j, #Afficher seulement le contennue de la rangee.
print
print
for i in range(0,1): #Pour i compris entre 0 et 1.
print i, i+1, i+2, i+3, i+4, i+5, i+6 #Affiche les indices des colonnes de 0 a 6.
print
## Demander la colonne sur la quel veut jouer le joueur:
#Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
#Resultat: Un entier correspondant a la colonne choisit par le joueur.
def Demander_une_colonne(Grille):
colonne = int(input("Choissisez une colonne(0-6):")) #Un entier correspondant a la colonne choisit par le joueur.
if colonne >= 0 and colonne <= 6: #Si l'entier que vous avez saisi est compris entre 0 et 6.
if Position_valide(Grille, colonne) == True: #Si l'une des rangees de cette colonne est vide, position valide renvoie vrai,
return colonne #donc on renvoie l'entier choisit par le joueur.
elif Position_valide(Grille, colonne) == False: #Si toutes les rangees de cette colonne sont pleines, position valide renvoie faux,
print "La colonne que vous avez choisie est pleine."
print "Vous devez rechoisir une colonne entre(0-6):"
return Demander_une_colonne(Grille) #donc on redemande au joueur de choisir une colonne.
elif colonne < 0 or colonne > 6: #Si l'entier que vous avez saisi est inferieur a 0 ou superieur a 6.
print "La colonne que vous avez choisie n'existe pas."
print "Vous devez rechoisir une colonne entre(0-6):"
return Demander_une_colonne(Grille) #on redemande au joueur de choisir une colonne.
############################################################################
# # # #
# # Fonctions metiers # #
# # # #
############################################################################
############################################################################
# # Creation du jeu # #
############################################################################
## Creer la grille de jeux:
# Donnees: M: un reel correspondant au nombre de rangee; N: un reel
# correspondant au nombre de colonne.
# Resultat: Elle creer un tableaux multidimensionnels de M lignes et
# N colonnes remplit de 0, et le contennue sera des entiers.
def Creer_Grille(M,N):
Grille = numpy.zeros((M, N), dtype='i') #Tableau 2d remplit de 0, de taille 6x7.
return Grille #on retourne le tableaux multidimensionnels.
## Fonction pour jouer 1 contre 1:
# Donnees: On ne sollicitera pas de donnees pour cette fonction.
# Resultat: Tour a tour les deux joueur vont jouer. A chaque coup la grille sera affichee avec le nouveau jeton.
def Jouer_1_vs_1():
print "¡Bienvenue aux Puissance 4!"
print "L'objectif du jeu est d'aligner quatre jetons dans une grille de 6 rangees et 7 colonnes. Chaque joueur a une valeur differente pour son jeton. Le joueur 1, son jeton aura comme valeur 1 ; Le joueur 2, son jeton aura comme valeur 2. Les joueurs mettent les jetons par tour dans la colonne souhaiter, le jeton se place alors dans la position la plus basse possible de la colonne, apres cela ces au prochain joueur de jouer. Le gagnant de la partie est celui qui fait le premier alignement (horizontal, vertical ou diagonal) d'au moins quatre jetons. Si toutes les colonnes sont pleines et aucun des deux joueurs a fait un alignement, on dit que la partie est nulle."
M=6 #M il s'agit du nombre de rangee.
N=7 #N il s'agit du nombre de colonne.
Grille = Creer_Grille(M,N) #On cree la grille 2d remplit de 0, de taille 6x7.
Game_over = False #Game_Over et la variable qui va nous permettre de donner fin a la partie, au debut elle sera "fausse".
Joueur_1 = raw_input("Joueur 1 saisissez votre prenom:") #On demande le prenom du joueur 1.
Joueur_2 = raw_input("Joueur 2 saisissez votre prenom:") #On demande le prenom du joueur 2.
tour = random.randint(0,1) #On tire au hasard le joueur qui va commencer a joueur.
Afficher_Grille(Grille) #On affiche la grille de jeux.
while not Game_over: #Tant que la partie n'est pas fini:
#Coup du joueur 1:
if tour == 0: #Si c'est au joueur 1 de jouer
print Joueur_1,"vous devez choisir une colonne"
colonne = Demander_une_colonne(Grille) #On lui demande de choisir une colonne.
rangee = Trouver_la_bonne_rangee(Grille, colonne) #Ensuite on trouve la derniere rangee occupe pour mettre le jeton sur la case du dessus.
Mettre_le_jeton_a_sa_place(Grille, rangee, colonne, 1) #Ont met le jeton a sa place.
if Detecter_Alignement(Grille, 1) == True: #Si ont detecte un mouvement permettant au joueur 1 de gagner.
print Joueur_1,"a gagner la partie!"
Game_over = True #La partie est finie.
if Fin_Partie(Grille) == True: #Si la grille est pleine et aucun des deux joueurs a fait un alignement:
print "Personne a gagner"
Game_over = True #La partie est finie.
#Coup du joueur 2:
if tour == 1: #Si c'est au joueur 2 de jouer
print Joueur_2,"vous devez choisir une colonne"
colonne = Demander_une_colonne(Grille) #On lui demande de choisir une colonne.
rangee = Trouver_la_bonne_rangee(Grille, colonne) #Ensuite on trouve la derniere rangee occupe pour mettre le jeton sur la case du dessus.
Mettre_le_jeton_a_sa_place(Grille, rangee, colonne, 2) #Ont met le jeton a sa place.
if Detecter_Alignement(Grille, 2) == True: #Si ont detecte un mouvement permettant au joueur 1 de gagner.
print Joueur_2,"a gagner la partie!"
Game_over = True #La partie est finie.
if Fin_Partie(Grille) == True: #Si la grille est pleine et aucun des deux joueurs a fait un alignement:
print "Personne a gagner"
Game_over = True #La partie est finie.
print Tableau_score(Grille, score_joueur1, score_joueur2)
Afficher_Grille(Grille) #On affiche la grille une derniere fois.
tour += 1 #On incremente de 1 "tour".
tour = tour % 2 #On divise "tour" par 2.
############################################################################
# # Evolution du jeu # #
############################################################################
## Verifie si la colonne choisi est pleine ou pas:
# Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
# Colonne: La colonne saisie par le joueur.
# Resultat: Cette fonction renvoie vrai si l’une des rangees de la colonne choisie est vide.
# Elle renvoie faux si toutes les rangees de la colonne choisie sont pleine.
def Position_valide(Grille, colonne):
if Grille[5][colonne] == 0: #Si le 5eme element de la colonne choisit correspond a une case vide " 0 ".
return True #on renvoie vrai.
else: #sinon
return False #on renvoie faux.
## Trouve la rangee dans la quel le jeton peut etre poser:
# Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
# Colonne: La colonne saisie par le joueur.
# Resultat: Elle renvoie un entier correspondant a la rangee dans la quel le jeton sera deposer.
def Trouver_la_bonne_rangee(Grille, colonne):
for r in range(6): #Ont parcours toutes les rangees:
if Grille[r][colonne] == 0: #En parcourant les rangees de la colonne saisie, on cherche quel est la derniere rangee avec " 0 " comme element.
return r #On renvoie la valeur de la rangee " r ".
## Met le jeton dans la colonne et rangee correspondante:
# Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
# Colonne: La colonne saisie par le joueur.
# Rangee: La rangee ou l'on va mettre le jeton.
# Jeton: Le jeton est soit 1 "Joueur 1" soit 2 "Joueur 2".
# Resultat: Elle met le jeton dans la colonne et rangee correspondante.
def Mettre_le_jeton_a_sa_place(Grille, rangee, colonne, jeton):
Grille[rangee][colonne] = jeton #Ont met le jeton, dans la colonne saisie par le joueur, et dans la bonne rangee.
## Verification alignement horizontale:
# Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
# Jeton: Le jeton est soit 1 "Joueur 1" soit 2 "Joueur 2".
# Resultat: Elle renvoie vrai si elle trouve un alignement horizontale.
def Verification_horizontale(Grille, jeton):
for r in range(6): #Pour r "rangee" allant de 0 a 5
for c in range(4): #et c "colonne" allante de 0 a 3:
#Si le jeton qui se trouve a l'endroit [r][c]
#et le meme que celui qui se trouve a [r][c+1], [r][c+2], [r][c+3].
if Grille[r][c] == Grille[r][c+1] == Grille[r][c+2] == Grille[r][c+3] == jeton:
return True #on renvoie vrai.
## Verification alignement verticale:
# Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
# Jeton: Le jeton est soit 1 "Joueur 1" soit 2 "Joueur 2".
# Resultat: Elle renvoie vrai si elle trouve un alignement verticale.
def Verification_verticale(Grille, jeton):
for r in range(3): #Pour r "rangee" allant de 0 a 2
for c in range(7): #et c "colonne" allante de 0 a 6:
#Si le jeton qui se trouve a l'endroit [r][c]
#et le meme que celui qui se trouve a [r+1][c], [r+2][c], [r+3][c].
if Grille[r][c] == Grille[r+1][c] == Grille[r+2][c] == Grille[r+3][c] == jeton:
return True #on renvoie vrai.
## Verification alignement diagonal croissante:
# Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
# Jeton: Le jeton est soit 1 "Joueur 1" soit 2 "Joueur 2".
# Resultat: Elle renvoie vrai si elle trouve un alignement diagonal croissant.
def Verification_diagonal_croissante(Grille, jeton):
for r in range(3): #Pour r "rangee" allant de 0 a 2
for c in range(4): #et c "colonne" allante de 0 a 3:
#Si le jeton qui se trouve a l'endroit [r][c]
#et le meme que celui qui se trouve a [r+1][c+1], [r+2][c+2], [r+3][c+3].
if Grille[r][c] == Grille[r+1][c+1] == Grille[r+2][c+2] == Grille[r+3][c+3] == jeton:
return True #on renvoie vrai.
## Verification alignement diagonal decroissante:
# Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
# Jeton: Le jeton est soit 1 "Joueur 1" soit 2 "Joueur 2".
# Resultat: Elle renvoie vrai si elle trouve un alignement diagonal decroissant.
def Verification_diagonal_decroissante(Grille, jeton):
for r in range(3,6): #Pour r "rangee" allant de 3 a 5
for c in range(4): #et c "colonne" allante de 0 a 3:
#Si le jeton qui se trouve a l'endroit [r][c]
#et le meme que celui qui se trouve a [r-1][c+1], [r-2][c+2], [r-3][c+3].
if Grille[r][c] == Grille[r-1][c+1] == Grille[r-2][c+2] == Grille[r-3][c+3] == jeton:
return True #on renvoie vrai.
## Detecter un alignement:
# Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
# Jeton: Le jeton est soit 1 "Joueur 1" soit 2 "Joueur 2".
# Resultat: Elle renvoie vrai si l'une des verifications est vraie. Sinon elle renvoie faux.
def Detecter_Alignement(Grille, jeton):
if Verification_horizontale(Grille, jeton) == True: #Si la verification horizontale est vraie:
return True #on renvoie vrai.
if Verification_verticale(Grille, jeton) == True: #Si la verification verticale est vraie:
return True #on renvoie vrai.
if Verification_diagonal_croissante(Grille, jeton) == True: #Si la verification diagonal croissante est vraie:
return True #on renvoie vrai.
if Verification_diagonal_decroissante(Grille, jeton) == True: #Si la verification diagonal decroissante est vraie:
return True #on renvoie vrai.
else: #Si aucune des verifications est vrai:
return False #on renvoie faux.
## Detecter fin de partie:
# Donnees: Grille: Il s'agit de la grille de jeux (tableaux multidimensionnels).
# Resultat: Elle renvoie vrai si la grille est pleine, faut si la grille n'est pas pleine.
def Fin_Partie(Grille):
for r in range(6): #Pour r "rangee" allant de 0 a 5.
for c in range(7): #et c "colonne" allant de 0 a 6.
if Grille[r][c] == 0: #Si dans un emplecement de la grille il y a un 0:
return False #on renvoie faux.
return True #sinon on renvoie vrai.
def Tableau_score(Grille, score_joueur1, score_joueur2):
if Detecter_Alignement(Grille, 1) == True:
score_joueur1 += 1
print "Le joueur 1 a",score_joueur1,"point(s)."
print "Le joueur 2 a",score_joueur2,"point(s)."
if Detecter_Alignement(Grille, 2) == True:
score_joueur2 += 1
print "Le joueur 1 a",score_joueur1,"point(s)."
print "Le joueur 2 a",score_joueur2,"point(s)."
if Detecter_Alignement(Grille, 2) == False and Detecter_Alignement(Grille, 2) == False:
score_joueur1 += 0
score_joueur2 += 0
print "Le joueur 1 a",score_joueur1,"point(s)."
print "Le joueur 2 a",score_joueur2,"point(s)."
score_joueur1 = 0
score_joueur2 = 0
Jouer_1_vs_1() |
Création d'une fonction pour gérer les scores, et une fonction pour demander au joueur s'il veut rejouer.
Répondre avec citation
Envoyé par ManuFG
Partager