Bonjour à toutes et à tous.
Voila j'ai quelques petits soucis avec mon code en C (pas c++) pour la création d'un puissance 4.
Il se trouve que ma fonction vérification ne marche pas, le pourquoi j'en ai réelement aucun idée c'est pour ça que je me tourne vers vous.
J'aurais aussi aimé un compte qui me donne le nombre de coup que le joueur à joué avant de gagner.
A l'origine j'aimerais que mon programme ressemble à ça.
1. Jeu classique
* Joueur vs Joueur (mon programme actuel)
* Joueur vs Ordinateur (donc intégrer une petite IA)
2. Jeu personnalisé
=> Définir la Hauteur: X (max 20)
=> Définir la Largeur: Y (max 20)
=> Définir nombre de joueur Z (max 4, si 1 alors ordinateur)
=> Jouer une fois que les 3 valeurs du dessus sont remplis
4. Meilleurs scores
Affichage de score "bidon" en simple printf
5. Instruction
Affichage des instructions par de simple printf
6. Quitter
Fermer le programme
Pour l'IA j'avais penser à faire quelque chose du genre:
Code C# :
1. if (alignement pion joueur = 3)
2. ajoutepionplateau 3+1 || 3-4 (en faite le faire jouer d'un coté et si c'est pas possible de l'autre côté)
3. else if (alignement pion ordi = 3)
4. ajoutepionplateau 3+1 || 3-4
5. else if (alignement pion joueur = 2)
6. ajoutepionplateau 2+1 || 2-3
7. else if (alignement pion ordinateur = 2)
8. ajoutepionplateau 2+1 || 2-3
9. else ajoutepionplateau random (pose un pion au hasard)
Voila l'idée global que je souhaiterais inclure, sauf que j'ai aucune idée du comment faire.
Voila mon code actuel
Code C# :
1. #include <stdio.h>
2. #include <stdlib.h>
3.
4. #define LARGEUR 7
5. #define HAUTEUR 6
6. #define VIDE ' '
7. #define J1 'X'
8. #define J2 'O'
9.
10.
11.
12.
13. typedef char plateau[LARGEUR][HAUTEUR];
14. // Initialisation de certaines variable du programme
15. plateau p;
16. char j1[20];
17. char j2[20];
18. int resultat,compteur=0;
19. int abscisse , ordonne;
20. char rejouer='o';
21.
22.
23.
24. void initialisePlateau(plateau p)
25. {
26. // Remplissage de la grille pour le debut du jeu: chaque cellule contient un espace
27.
28. int m, n, k=1;
29.
30. for(m=0; m<LARGEUR; m++){
31. for(n=0; n<HAUTEUR; n++){
32. p[m][n] = VIDE;
33. }
34. }
35. }
36.
37.
38. void menu()
39. {
40.
41. printf("\n *******************************************************\n" );
42. printf(" * *\n" );
43. printf(" * *\n" );
44. printf(" * PUISSANCE 4 *\n" );
45. printf(" * Dams *\n" );
46. printf(" * *\n" );
47. printf(" * *\n" );
48. printf(" *******************************************************\n" );
49. // Les joueurs choisissent leurs noms.
50. printf ("Joueur 1 vs Joueur 2. \n\n" );
51. printf("Nom du Joueur 1?" );
52. scanf("%s", &j1);
53. printf("Nom du Joueur 2?" );
54. scanf("%s",&j2);
55. }
56.
57.
58. void affichePlateau(plateau p)
59. {
60. // Affichage de la grille
61. int i,j;
62.
63. printf("| 0 | 1 | 2 | 3 | 4 | 5 | 6 |\n" );
64. printf("|---|---|---|---|---|---|---|\n" );
65. for(i=0; i<HAUTEUR; i++){
66. printf("|" );
67. for(j=0; j<LARGEUR; j++){
68. printf(" %c |", p[j][i]);
69. }
70. printf("\n" );
71. printf("|---|---|---|---|---|---|---|\n" );
72. }
73. printf("| 0 | 1 | 2 | 3 | 4 | 5 | 6 |\n\n\n" );
74. }
75.
76. int testPionPlateau(plateau p, int c)
77. {
78. if((p[c][0]==J1) || (p[c][0]==J2))
79. {
80. printf("La HAUTEUR est pleine!\n\n" );
81. return 1;
82. }
83.
84. if((c>6) || (c<0))
85. {
86. printf("Entrez une colonne correct!\n\n" );
87. return 1;
88. }
89. return 0;
90. }
91.
92.
93. int lire_entier(char *message, int bas, int haut)
94. {
95. // Tant que la valeur choisie est incompatible, le joueur doit en choisir une autre //
96. do
97. {
98. affichePlateau(p);
99. printf(message);
100. scanf("%d", &abscisse);
101. } while (testPionPlateau(p, abscisse));
102.
103. return abscisse;
104. }
105.
106.
107. void ajoutePionPlateau(plateau p, char j, int c)
108. {
109. /* Verifie si la premiere case (de la derniere LARGEUR
110. de la grille) est vide et choisi celle au dessus dans
111. le cas contraire (qui sera aussi verifiée) */
112. for(ordonne=5 ; ordonne >= 0 ; ordonne--)
113. {
114. if(p[c][ordonne] == VIDE)
115. {
116. if(j == J1)
117. {
118. p[c][ordonne] = J1;
119. break;
120. }
121. else
122. {
123. p[c][ordonne] = J2;
124. break;
125. }
126. }
127. }
128. }
129.
130.
131.
132.
133. int verification(plateau p, int j, int k)
134. {
135.
136. /*Verification de la cellule jouée et renvoie 1 s'il y a alignement*/
137. /*Verification d'un alignement vertical*/
138. if(k >= 3)
139. {
140. if((p[j][k] == J1 && p[j][k-1] == J1
141. && p[j][k-2] == J1 && p[j][k-3] == J1)
142. || (p[j][k]==J2 && p[j][k-1]==J2
143. && p[j][k-2]==J2 && p[j][k-3]==J2))
144. return 1;
145.
146. }
147. /*Verification d'un alignement horizontal*/
148. else if(j <= 3)
149. {
150. if((p[j][k]==J1 && p[j+1][k]==J1
151. && p[j+2][k]==J1 && p[j+3][k]==J1)
152. || (p[j][k]==J2 && p[j+1][k]==J2
153. && p[j+2][k]==J2 && p[j+3][k]==J2))
154. return 1;
155.
156. }
157. /*Verification d'un alignement diagonal de haut en bas*/
158. else if((k <= 2) && (j <= 3))
159. {
160. if((p[j][k]==J1 && p[j+1][k+1]==J1
161. && p[j+2][k+2]==J1 && p[j+3][k+3]==J1)
162. || (p[j][k]==J2 && p[j+1][k+1]==J2
163. && p[j+2][k+2]==J2 && p[j+3][k+3]==J2))
164. return 1;
165.
166. }
167. /*Verification d'un alignement diagonal de bas en haut*/
168. else if((k >= 3) && (j <= 3))
169. {
170. if((p[j][k]==J1 && p[j+1][k-1]==J1
171. && p[j+2][k-2]==J1 && p[j+3][k-3]==J1)
172. || (p[j][k]==J2 && p[j+1][k-1]==J2
173. && p[j+2][k-2]==J2 && p[j+3][k-3]==J2))
174. return 1;
175. }
176. else
177. return 0;
178.
179. }
180.
181.
182.
183. int main()
184. {
185.
186.
187. menu();
188.
189. do
190. {
191. printf("Que la partie commence!\n\n\n\n" );
192. initialisePlateau(p);
193.
194. do
195. {
196. printf ("Nombre de coup: \n" );
197. printf("A %s de jouer! \n", j1);
198. ajoutePionPlateau(p, J1, lire_entier("Choisissez une colonne : \n", 0, LARGEUR -1));
199. compteur++;
200.
201. if (compteur >= 7)
202. {
203. resultat=verification(p,abscisse,ordonne);
204. if (resultat == 1)
205. {
206. printf("Bien joue %s! Vous remportez la partie!", j1);
207. compteur = 43;
208. }
209. }
210.
211. if(resultat != 1)
212. {
213. printf("A %s de jouer! \n", j2);
214. ajoutePionPlateau(p, J2, lire_entier("Choisissez une colonne : \n", 0, LARGEUR -1));
215. compteur++;
216. if (compteur >= 8)
217. {
218. resultat=verification(p, abscisse, ordonne);
219. if (resultat == 1)
220. {
221. printf("Bien joue %s! Vous remportez la partie!", j2);
222. compteur = 43;
223. }
224. }
225. }
226. } while (compteur < 42);
227.
228.
229. if (compteur == 42)
230. {
231. printf("Match Nul!" );
232. }
233. printf("Voulez-vous rejouer la partie? o=oui ou n=non", rejouer);
234. scanf("%c", &rejouer);
235. } while (rejouer == 'o');
236.
237. }